斯维夫特(Swift)(Swift) Basic Operators

操作符就是局部专用的符号或短语,用于值的检讨、更改、合并等。例如加号操作符+
将五个数加起来(as in
let i = 1 + 2)。更复杂的例证如逻辑与AND操作符&& (as in
if enteredDoorCode && passedRetinaScan)和增值操作符++i,方便的给指定变量i
的值加1

斯维夫特是一种新出现的付出iOS,OS X 和
watchOS应用程序的编程语言。就算如此,有 C 和 Objeictive-C
开发经历的你,会从斯维夫特(Swift)很多局部中发现熟悉的感觉到。

斯维夫特(Swift)(Swift)扶助大多数标准 C
操作符,并立异了几个成效用以消除周边的编码错误。赋值操作符 =
不再次来到值,可预防在采取相当操作符 ==
时不当地行使了赋值操作符。数学操作符(+, -, *, / %
等)会检测并堵住溢出,以制止出现超出类型允许存储范围的不测结果。使用斯威夫特(Swift)(Swift)的溢出操作符,能够挑选值溢出的作为,进一步的信息请看溢出操作符

基本类型:Int、Double、Float、Bool、String
汇合类型:Array、Set、Dictionary
常量:使代码更安全、更清晰
元组:
Optional types:表示有值或没值

与 C 不同的是,斯维夫特(Swift)允许浮点数举办取余(%)运算。还提供了六个 C
没有的限定操作符(a..<ba...b),用于简便地意味着范围内的值

Swift(Swift)是项目安全语言

这章重点描述斯威夫特(Swift)(Swift)的常用操作符。其他高档操作符请看高级操作符,在这章里首要讲怎么着自定义操作符和为自定义类实现规范操作符

变量与常量


术语 Terminology


操作符分为一元(unary)、二元(binary)、三元(ternary)操作符:

  • 一元操作符只功用于一个对象/操作数(如
    -a)。一元前缀操作符紧挨在操作数前(例如
    !b),一元后缀操作符紧挨在操作数的后面(例如 i++
  • 二元操作符有六个操作数(如
    2 + 3),并在几个操作数中间,是中缀操作符
  • 新正操作符有四个操作数。和 C
    一样,斯威夫特(Swift)唯有一个三元操作符:条件操作符(a ? b : c

操作符使用的值就叫操作数。在发挥式 1 + 2中,+
加号是二元操作符,而她的六个操作数是 12

声明

变量与常量必须先讲明,再使用。

  • let 表明常量
  • var 讲明变量

<pre><code>
let maximumNumberOfLoginAttempts = 10
var currentLoginAttempt = 0
</code></pre>

在一行中声称多少个变量或常量,使用逗号分隔
<pre><code>
var x = 0.0, y = 0.0, z = 0.0
</code></pre>

赋值操作符 Assignment Operator


赋值操作符(a = b)使用 b 的值起始化或更新 a 的值
<pre><code>
let b = 10
var a = 5
a = b
// a is now equal to 10
</code></pre>

只要赋值操作符右边是一个有两个值的元组,其元素的值可以表明到三个常量或变量中:
<pre><code>
let (x, y) = (1, 2)
// x is equal to 1, and y is equal to 2
</code></pre>

与 C 和 Objective-C
不同,赋值操作符本身不重回值,所以下边对讲话是没用的:
<pre><code>
if x = y {
// this is not valid, because x = y does not return a value
}
</code></pre>

以此特点会制止将相当于操作符(==),意外写成赋值操作符(=)。因为
if x = y 无效,所以斯威夫特(Swift)将帮忙您制止代码中的此类问题。

类型声明

在变量或常量名后,添加冒号,空格,类型名称
<pre><code>
var welcomeMessage: String
</code></pre>

在一行中声称两个同系列的变量
<pre><code>
var red, green, blue: Double
</code></pre>

注:在骨子里运用中,类型讲明很少使用。在概念变量和常量时,假使授予伊始值,Swfit几乎都能臆度出类型,细节在“项目安全与系列揣测”中。

算数操作符 Arithmetic Operators


斯威夫特(Swift)的拥有数字类型都帮助4种标准的算数操作符:

  • 加(+
  • 减(-
  • 乘(*
  • 除(/

<pre><code>
1 + 2 // equals 3
5 – 3 // equals 2
2 * 3 // equals 6
10.0 / 2.5 // equals 4.0
</code></pre>

不同于 C 和 Objective-C
的算数操作符,斯维夫特(Swift)算数操作符默认不允许值溢出。可以应用斯维夫特(Swift)的溢出操作符选拔溢出行为(如
a &+ b)。详情请看溢出操作符

加号操作符同时也补助 String 连结:
<pre><code>
“hello, ” + “world” // equals “hello, world”
</code></pre>

取名规范

几乎帮忙具有的字符,包括Unicode字符。
<pre><code>
let π = 3.14159
let 你好 = “你好世界”
let 🐶🐮 = “dogcow”
</code></pre>

不可以包含空白字符、数学符号、箭头、连字符-、画框线、私有或无效的Unicode
code points;不可以已数字初始,然而数字可以用在除最先外的别样地点。

无法声称同名的变量或常量名称,不可能存放与表明时不同品种的多寡,也不可以将常量变为变量-反之亦然。

注:假设名称与Swift(Swift)的保存重要字相同,使用`(反单引号)扩住名称。可是,除非别无采用,最好制止采纳紧要字。

取余操作符 Remainder Operator

取余操作符(a % b)算出 a 能容纳多少个
b,并赶回剩下的值(即:余数)

注:取余操作符在另外语言中也有些叫取模操作符。不过严俊来说,在Swift中对此负数而言是余数而不是模操作

下图演示取余操作符如何总括的。 总括 9 % 4,首先要算出 9 里面有微微个
4

平头统计余数

可以看出,这里有四个 4,最终剩余 1(图中青色的有的)

中斯威夫特(Swift)中,取余操作符使用形式如下:
<pre><code>
9 % 4 // equals 1
</code></pre>

要确定 a % b 的答案,% 操作符总计如下等式并赶回 remainder
a = (b x some multiplier) + remainder
some multiplier是最大的倍增 b 仍可以兼容于 a 的数

94 代入等式,产出:
9 = (4 x 2) + 1

无异于,负数也使用此措施总括余数
<pre><code>
-9 % 4 // equals -1
</code></pre>

-94 代入等式,产出:
-9 = (4 x -2) + -1
余数是 -1

some multiplier一经是负数,将会忽略其标志。意思是 a % ba % -b
将回来相同的结果

输出

可以动用print(_:)函数输出变量或常量的值
<pre><code>
var friendlyWelcome = “Bonjour!”
print(friendlyWelcome)
// prints “Bonjour!”
</code></pre>

print(\_:) 是全局函数,在出口内容后,行尾输出换行符。
print(\_:appendNewline:)print(\_:),只是有参数控制是否输出换行符

在输出字符串中接纳“\(变量或常量名称)”的花样作为占位符,输出变量或常量的值
<pre><code>
print(“The current value of friendlyWelcome is (friendlyWelcome)”)
// prints “The current value of friendlyWelcome is Bonjour!”
</code></pre>

浮点数余数总括 Floating-Point Remainder Calculations

不同于 C 和 Objective-C
的取余操作符,斯威夫特(Swift)(Swift)的取余操作符可以总计浮点数的余数:
<pre><code>
8 % 2.5 // equals 0.5
</code></pre>

浮点数统计余数

注释 Comments


单行注释:
<pre><code>
// 注释内容到行尾
</code></pre>

多行注释:/* 注释内容 */,多行注释可嵌套使用
<pre><code>
/* this is the start of the first multiline comment
/* this is the second, nested multiline comment */
this is the end of the first multiline comment */
</code></pre>

增量和减量操作符 Increment and Decrement Operators

与 C
类似,斯维夫特(Swift)(Swift)也提供了增量操作符(++)和减量操作符(--),方便的对数值举办加/减
1 操作,可以用于整数和浮点数变量
<pre><code>
var i = 0
++i // i now equals 1
</code></pre>

每调用 ++i 一次,i 的值增添 1,本质上说,++ii = i + 1
的简写。类似地,--i 可以是 i = i - 1 的简写

++-- 即可以作为前缀操作符,也可以看成后缀操作符。++ii++
都可以使 i 的值加 1。类似地,--ii-- 都可以使 i 值减 1

只顾,这多少个操作符即修改 i 的值,也再次回到值。假诺只是想 i 加/减
1,可以忽略再次来到值。然则,假诺想利用重临值,那么前缀和后缀操作符会重返不同的值,规则如下:

  • 只要操作符在变量前,则先变更变量值,并赶回改变后的值
  • 如果操作符中变量后,则先回到变量原值,后更改变量的值

<pre><code>
var a = 0
let b = ++a
// a and b are now both equal to 1
let c = a++
// a is now equal to 2, but c has been set to the pre-increment value of
1
</code></pre>

除非您需要以 i++ 的不二法门选用操作符,否则推荐在具备的情形下使用 ++i
--i 的样式,因为再次回到值与实际值是同一的。

分号 Semicolons


Swift不需要在每个语句结尾输入分号,可是你这样做也不会出错。唯有一种意况是索要分号的:在一行中输入多条独立的言语
<pre><code>
let cat = “🐱”; print(cat)
// prints “🐱”
</code></pre>

一元负号操作符 Unary Minus Operator

使用 - 操作符(前缀操作符)可以每一回切换数值的符号,这就是负号操作符
<pre><code>
let three = 3
let minusThree = -three // minusThree equals -3
let plusThree = -minusThree // plusThree equals 3, or “minus minus
three”
</code></pre>

负号操作符需要紧挨在操作数前面,之间不可能有任何空白字符

整数 Integers


概括有标志整数:正数、0、负数;无标志整数:正数、0
Swift的整数:Int8、Int16、Int32、Int64,UInt8、UInt16、UInt32、UInt64

一元朔号操作符 Unary Plus Operator

使用 + 操作符,将会回来原值,而且对原值不会发生此外影响
<pre><code>
let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix equals -6
</code></pre>

虽然 + 操作符没有做其他工作,不过在代码中,对正数使用 +
操作符和对负数使用 - 操作符能使代码看起来比较整齐

平头边界 Integer Bounds

应用各种整数类型,可以得到该品种的最大值(max)与最小值(min)属性:
<pre><code>
let minValue = UInt8.min // minValue is equal to 0, and is of type
UInt8
let maxValue = UInt8.max // maxValue is equal to 255, and is of type
UInt8
</code></pre>

组合赋值操作符 Compound Assignment Operators


像 C 一样,斯威夫特(Swift)(Swift)提供了咬合赋值操作符,将 =
与其他操作符组合在联合使用:
<pre><code>
var a = 1
a += 2
// a is now equal to 3
</code></pre>

表达式 a += 2 使 a = a + 2
的简写。将加法与赋值组合进一个操作符,这多少个操作将同时施行。

注:组合赋值操作符不重返值。这一点与地点提及的 ++--不同

要翻开所有的构成赋值操作符,请看Swift Language Reference 之
表达式

浮点数 Floating-Point Numbers


  • Double 表示一个 64-bit 浮点数,15位数字精度
  • Float 表示一个 32-bit 浮点数,6位数字精度

正如操作符 Comparison Operators


斯威夫特(Swift) 补助具备专业 C 比较操作符:

  • 等于 (a == b)
  • 不等于 (a != b)
  • 大于 (a > b)
  • 小于 (a < b)
  • 过量等于 (a >= b)
  • 小于等于 (a <= b)

注:Swift还提供了六个辨识操作符(===!==),用来相比多少个目的引用是否是指向同一个对象实例,更多音信请参见类与协会

每个相比较操作符都回来 Bool 值,指示语句是否为 true:
<pre><code>
1 == 1 // true, because 1 is equal to 1
2 != 1 // true, because 2 is not equal to 1
2 > 1 // true, because 2 is greater than 1
1 < 2 // true, because 1 is less than 2
1 >= 1 // true, because 1 is greater than or equal to 1
2 <= 1 // false, because 2 is not less than or equal to 1
</code></pre>

相比较操作符通常用在口径语句中,比如 if 语句:
<pre><code>
let name = “world”
if name == “world” {
print(“hello, world”)
} else {
print(“I’m sorry (name), but I don’t recognize you”)
}
// prints “hello, world”, because name is indeed equal to “world”
</code></pre>

想询问更多关于 if
的信息,请参考控制流

类别安全与类型揣摸


斯威夫特(Swift)是连串安全的,在编译时将开展项目检查并表示出不配合的代码。
体系检查并不表示需要您在宣称时指定每个变量或常量的品类。假如不指定,斯威夫特(Swift)将利用品种估计(type
inferrence)
因此可知出极度的品种

由于有了项目臆度,斯维夫特(Swift)在注解时索要的类型信息要远点儿 C 和
Objective-C。
在宣称变量或常量并给予起先值时,类型推断尤其有用。

如下,如若给阐明常量meaningOfLife并赋值42,不过从未类型音讯,斯维夫特(Swift)(Swift)会臆度出常量的档次为Int,因为42看起来更像一个整数。
<pre><code>
let meaningOfLife = 42
// meaningOfLife is inferred to be of type Int
</code></pre>

一致地,假如指定一个浮点数,Swift揣度为Double
<pre><code>
let pi = 3.14159
// pi is inferred to be of type Double
</code></pre>

对此浮点数,斯威夫特(Swift)(Swift)总是接纳Double,如果需要Float,则利用
<pre><code>
let pi = Float(3.14159)
// pi is inferred to be of type Float
</code></pre>

只要构成使用整数和浮点数,最后Swift(Swift)会估摸为Double
<pre><code>
let anotherPi = 3 + 0.14159
// anotherPi is also inferred to be of type Double
</code></pre>

在那边,3会遵照表明式揣度为Double

大年终一条件操作符 Ternary Conditional Operator


三元条件操作符有五个操作数,是相比较优良的一个操作符,它是如此的花样:question ? answer1 : answer2。它根据
question 是 true 还是 false,能快捷的盘算两个表明式之一的值。如果为
true,总括并回到 answer1 的值;false 总结并赶回 answer2 的值

三元条件操作符是之类代码的简写:
<pre><code>
if question {
answer1
} else {
answer2
}
</code></pre>

事实上应用时,参考下例:
<pre><code>
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90
</code></pre>

起始展开后,是之类代码
<pre><code>
let contentHeight = 40
let hasHeader = true
var rowHeight = contentHeight
if hasHeader {
rowHeight = rowHeight + 50
} else {
rowHeight = rowHeight + 20
}
// rowHeight is equal to 90
</code></pre>

设若过多使用三元标准操作符,会导致代码可读性变坏。
避免嵌套使用三元标准操作符。

数字 Numeric Literals


平头有以下的写法

  • 十进制:十进制数字 (0123456789),没有前缀
  • 二进制:二进制数字(01),前缀为0b
  • 八进制:八进制数字(01234567),前缀为0o
  • 十六进制:十六进制数字(0123456789abcdef),前缀为0x

<pre><code>以下所有值在十进制中都是17
let decimalInteger = 17
let binaryInteger = 0b10001 // 17 in binary notation
let octalInteger = 0o21 // 17 in octal notation
let hexadecimalInteger = 0x11 // 17 in hexadecimal notation
</code></pre>

浮点数能够行使十进制数(没有前缀)和十六进制拼写,中间必须有个小数点;同时能够有指数模式的写法:十进制用e/E,十六进制用p/P,前边跟指数。

  • 十进制指数,使用基数乘以10exp
    1.25e2 表示 1.25 x 102, or 125.0
    1.25e-2 表示 1.25 x 10-2, or 0.0125.
  • 十六进制指数,使用基数乘以2exp
    0xFp2 means 15 x 22, or 60.0.
    0xFp-2 means 15 x 2-2, or 3.75.

<pre><code>以下所有值在十进制中都是12.1875
let decimalDouble = 12.1875
let exponentDouble = 1.21875e1
let hexadecimalDouble = 0xC.3p0
</code></pre>

数字可以分包格式符号_(下划线)以增长阅读性
<pre><code>
let paddedDouble = 000123.456
let oneMillion = 1_000_000
let justOverOneMillion = 1_000_000.000_000_1
</code></pre>
<pre><code>写成这样也不失误,不过小数点前边得跟数组,最前头(除符号)只好由前导0
let paddedDouble = -000123.456___e1__0___
let oneMillion = 0000000000000001_0_0_0_0_0_0______
let justOverOneMillion =
1_000_000______.0____0__0_000_1______
</code></pre>

Nil合并操作符 Nil Coalescing Operator


nil coalescing operator (a ?? b),如果 Optional a 有值,就解包
a,否则一经 anil 返回 ba 必须是 Optional 类型,b
a 存储的类别必须一致。

nil coalescing operator 是之类使用三元标准操作符的代码的简写:
<pre><code>
a != nil ? a! : b
</code></pre>

注:假若 a 不为 nil ,b 的值不会统计,即:短路总结(short-circuit)

举例如下:
<pre><code>
let defaultColorName = “red”
var userDefinedColorName: String? // defaults to nil

var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is nil, so colorNameToUse is set to the default
of “red”
</code></pre>

如果给 userDefinedColorName 赋值,则如下:
<pre><code>
userDefinedColorName = “green”
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is not nil, so colorNameToUse is set to
“green”
</code></pre>

数值类型转换 Numberic Type Conversion


写整数时相似选用Int(在XCode7beta上是32位)类型,对非负数也援引这样用。
只有在需要的时候,才使用其它整数类型。例如:明确存储空间尺寸的表面数据、性能、内存或其他的优化

范围操作符 Range Operators


斯维夫特(Swift)(Swift) 有三种限制操作符,用来简化一个限量内值的表示方法

平头转换 Integer Conversion

各类整数类型都有必然的数值范围,超出范围的数在编译时将报错
<pre><code>
let cannotBeNegative: UInt8 = -1
// UInt8 cannot store negative numbers, and so this will report an
error
let tooBig: Int8 = Int8.max + 1
// Int8 cannot store a number larger than its maximum value,
// and so this will also report an error
</code></pre>

要把一个平头转换为另一个项目,需要基于整数数值先河化一个新的靶子项目整数。如下:不同类型的平头不可能直接运算,要转换为同样档次后才能相加。
<pre><code>
let twoThousand: UInt16 = 2_000
let one: UInt8 = 1
let twoThousandAndOne = twoThousand + UInt16(one)
</code></pre>

SomeType(ofInitialValue)是基于传入值起首化类型数据的默认方法。在偷偷摸摸,UInt16有个开始化方法接收UInt8类型数据作为开端化参数,所有UInt16才能按照UInt8数据变动新的UInt16数据。

封闭范围操作符 Closed Range Operator

(a...b) 定义一个从 ab 的范围内的值,包括 aba
的值一定不得以高于 b

诚如在遍历范围内所有值的时候使用,例如for-in 循环:
<pre><code>
for index in 1…5 {
print(“(index) times 5 is (index * 5)”)
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25
</code></pre>

平头-浮点数转换 Integer and Floating-Point Conversion

平头与浮点数之间的更换必须了然项目
<pre><code>
let three = 3
let pointOneFourOneFiveNine = 0.14159
let pi = Double(three) + pointOneFourOneFiveNine
// pi equals 3.14159, and is inferred to be of type Double
</code></pre>

浮点数在转移为整数时,将去掉小数部分,例如:4.75改为整数为4-3.9成为整数位-3

半开范围操作符 哈尔(Hal)f-Open Range Operator

(a..<b) 定义一个从 ab 的限制内的值,包括 a 但不包括 ba
的值一定不得以超越 b。如果 a 等于 b,则范围为空

对于遍历从 0 开首的列表有其实用:
<pre><code>
let names = [“Anna”, “Alex”, “Brian”, “Jack”]
let count = names.count
for i in 0..< count {
//这里小于号与count要链接在共同,但因为与html争论问题未缓解,所以加了空格
print(“Person (i + 1) is called (names[i])”)
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack
</code></pre>

项目别名 Type Aliases


使用typealias要害字可以给一个一度存在的类型定义一个别名
在按照上下文,给品种起一个更适用的名字,这多亏类型别名点用武之地,如:
<pre><code>
typealias AudioSample = UInt16
</code></pre>

倘若定义了别名,就足以想利用原始类型一样采用别名:
<pre><code>
var maxAmplitudeFound = AudioSample.min
// maxAmplitudeFound is now 0
</code></pre>

逻辑操作符 Logical Operators


逻辑操作符修改或组合 Boolean 逻辑值 true 和
false。斯威夫特(Swift)(Swift)有两个逻辑操作符,都可以在基于C的编程语言中找到:

  • 逻辑非 NOT (!a)
  • 逻辑与 AND (a && b)
  • 逻辑或 OR (a || b)

布尔类型 Booleans


斯维夫特的布尔类型为Bool,布尔值是逻辑值,只有 true、false 四个常量值
<pre><code>
let orangesAreOrange = true
let turnipsAreDelicious = false
</code></pre>

Swift的Type Inference机制会揣摸出她们是Bool类型的多寡

布尔值首要用在标准化语句中,比如if语句:
<pre><code>
if turnipsAreDelicious {
print(“Mmm, tasty turnips!”)
} else {
print(“Eww, turnips are horrible.”)
}
// prints “Eww, turnips are horrible.”
</code></pre>

斯维夫特(Swift)的品类安全机制会堵住使用非布尔值替代Bool,下例在编译时将会报错:
<pre><code>
let i = 1
if i {
// this example will not compile, and will report an error
}
</code></pre>

然则,这样使用就是毋庸置疑的了
<pre><code>
let i = 1
if i == 1 {
// this example will compile successfully
}
</code></pre>
i == 1的结果是Bool类型

Logical NOT Operator

逻辑非(!a)操作符将 Boolean 值取反,即 true 变为 false,false 变为 true

逻辑非是前缀操作符,并且要紧挨在操作数在此之前,之间不可能有空白:
<pre><code>
let allowedEntry = false
if !allowedEntry {
print(“ACCESS DENIED”)
}
// prints “ACCESS DENIED”
</code></pre>

只顾在给常量或变量起名时,保持代码的可读性。幸免再一次否定或混乱的逻辑语句

元组 Tuples


元组是一个复合值,由五个值组成,每个组成元组的值可以是随意档次,不必都是同一个项目的值
例如(404, "Not Found"),这一个元组描述一个 HTTP
状态值,状态码404意味资源未找到
<pre><code>
let http404Error = (404, “Not Found”)
// http404Error is of type (Int, String), and equals (404, “Not
Found”)
</code></pre>

元组(404, "Not Found")带有一个Int和一个String,类型可以作为是(Int, String)

可以运用任意一组项目标排列创设元组,例如:(Int, Int, Int),或者(String, Bool),或者其他你想要的类型排列情势

使用如下模式利用元组内数据
<pre><code>
let (statusCode, statusMessage) = http404Error
print(“The status code is (statusCode)”)
// prints “The status code is 404”
print(“The status message is (statusMessage)”)
// prints “The status message is Not Found”
</code></pre>

假若只关心元组内的一有些数据,可以拔取下划线(_)忽略不想要的一部分
<pre><code>
let (justTheStatusCode, _) = http404Error
print(“The status code is (justTheStatusCode)”)
// prints “The status code is 404”
</code></pre>

如故,可以动用索引(从0开头)的点子访问元组内容
<pre><code>
print(“The status code is (http404Error.0)”)
// prints “The status code is 404”
print(“The status message is (http404Error.1)”)
// prints “The status message is Not Found”
</code></pre>

也足以给元组内的值起个名字,这样就足以由此名字来做客了(给某个值起名,其他不起名也得以,我在playground中测了刹那间)
<pre><code>
let http200Status = (statusCode: 200, description: “OK”)
<br />
print(“The status code is (http200Status.statusCode)”)
// prints “The status code is 200”
print(“The status message is (http200Status.description)”)
// prints “The status message is OK”
</code></pre>

Logical AND Operator

逻辑与操作符 (a && b),需要五个操作数都为 true 时,才回来
true,其他情况都回去 false

虽然第一个操作数为 false, 第二个操作数就不会再总计了,即:短路统计
<pre><code>
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
print(“Welcome!”)
} else {
print(“ACCESS DENIED”)
}
// prints “ACCESS DENIED”
</code></pre>

Optionals (这多少个怎么翻译好?)


扬言一个变量、重临结果、属性等可能处于有值、没有值两种境况:

  • 没有值,在objc里就是nil
  • 有值,就是她的内容

在 C 和
Objective-C中,不设有这多少个概念。相比较像样的是在Objective-C中,一个主意可能回到nil,也可能回到一个目的。nil就表示没有有效值。然而在Objective-C中,基础项目、结构、枚举作为艺术再次来到值时就无法回去nil,只好回去特定的值(如NSNotFound)表示从没回到有效值。

下例就显得Optional在拍卖无效值时的利用办法
<pre><code>
et possibleNumber = “123”
let convertedNumber = Int(possibleNumber)
let unconvertNumber = Int(“Hello World!”)
// convertedNumber is inferred to be of type “Int?”, or “optional Int”,
value is 123
// unconvertNumber is inferred to be of type “Int?”, value is nil
</code></pre>

Logical OR Operator

逻辑或操作符 (a || b),需要五个操作数都为 false 时,才回去
false,其他情状都回来 true

设若第一个操作数为 true, 第二个操作数就不会再总括了,即:短路总结
<pre><code>
let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
print(“Welcome!”)
} else {
print(“ACCESS DENIED”)
}
// prints “Welcome!”

</code></pre>

nil

可以给Optional变量赋值为nil,表示无值
<pre><code>
var serverResponseCode: Int? = 404
// serverResponseCode contains an actual Int value of 404
serverResponseCode = nil
// serverResponseCode now contains no value
</code></pre>

nil
无法用在非Optional的变量和常量上,倘若想采纳无值的变量或常量,这就把她声称为Optional

万一定义了一个Optional变量可是尚未开头化,那么变量自动为nil
<pre><code>
var surveyAnswer: String?
// surveyAnswer is automatically set to nil
</code></pre>

注:Swift的nil 与
Objective-C的nil是不同的。在Objective-C中,nil表示一个对准不设有对象的指针;在斯威夫特(Swift)(Swift)中,nil不是指针,他表示某一类其它值没有现身(没赋值)。任意Optional类型都得以赋值nil,而不仅仅是目的类型。

结合使用逻辑操作符 Combining Logical Operators

可以动用六个逻辑操作符构成一个复合表明式:
<pre><code>
if enteredDoorCode && passedRetinaScan || hasDoorKey ||
knowsOverridePassword {
print(“Welcome!”)
} else {
print(“ACCESS DENIED”)
}
// prints “Welcome!”
</code></pre>

该例将三个逻辑操作符(&&||)组合使用。不过,因为(&&
||)都是二元操作符,所以这里其实是两个小的表明式链在一块儿,解读:

固然输入了无可非议的进门编码并且通过了视网膜扫描,或者有门钥匙,或者了然紧急一级密码,都足以访问。

注:斯威夫特 的逻辑操作符 &&||
都是左关联,即六个逻辑操作符组成复合表明式时,起首从左侧起始总结子表明式的值

If Statements and Forced Unwrapping

使用if语句与nil正如能断定一个Optional
是否有值。可以利用至极操作符== 或 不等于操作符!=执行判断

一经Optional没有值,那么就与nil不相等
<pre><code>
if convertedNumber != nil {
print(“convertedNumber contains some integer value.”)
}
// prints “convertedNumber contains some integer value.”
</code></pre>

只要确定Optional有值,就可以在名称前面紧跟叹号(!)来拜访他的值。这一个就叫forced
unwrapping
(强制解包?)
<pre><code>
if convertedNumber != nil {
print(“convertedNumber has an integer value of (convertedNumber!).”)
}
// prints “convertedNumber has an integer value of 123.”
</code></pre>

注:假若对无值的Optional使用!,将会掀起运行时不当。所以在拔取!前必定要保管Optional
含有非nil

来得采取括号 Explicit Parentheses

在逻辑表明式中追加括号,即便不是严厉需要时,也会推向扩张代码到可读性。在上例中动用括号,如下:
<pre><code>
if (enteredDoorCode && passedRetinaScan) || hasDoorKey ||
knowsOverridePassword {
print(“Welcome!”)
} else {
print(“ACCESS DENIED”)
}
// prints “Welcome!”
</code></pre>

就会使逻辑语句变得关系清晰,易于阅读,并且不改动表明式的结果

参考:The Swift Programming
Language

Optional Binding

使用Optional
Binding
自我批评Optional是否有值,如若有,可以创建一个临时的变量或常量来利用该值。可以用来ifwhile说话,检查Optional是否有值,并领取该值到一个变量或常量中

if语句中应用Optional Binding,如下:
<pre><code>
if let constantName = someOptional {
statements
}
</code></pre>

在Optional一节中possibleNumber的事例,可以利用Optional
Binding
的不二法门重写,而不利用Forced Unwrapping
<pre><code>
if let actualNumber = Int(possibleNumber) {
print(“‘(possibleNumber)’ has an integer value of (actualNumber)”)
} else {
print(“‘(possibleNumber)’ could not be converted to an integer”)
}
// prints “‘123’ has an integer value of 123”
</code></pre>

上例可以解读为:假诺Int(possibleNumber)再次回到的Optional
Int有值,就将值赋值给常量actualNumber

若果转换成功,常量actualNumberif讲话的首个分支中变为可用。由于actualNumber曾经使用Optional的值先导化,所以这边就不需再选择!后缀来访问其值。

Optional
Binding
时可以应用常量或变量。如若想改变actualNumber的值,则使用if var actualNumber =代替上例中的if let actualNumber =

比方有四个Optional需要Optional
Binding
,可以把它们都写在一起(一行或多行),用逗号分隔。
<pre><code>
if let [constantName] = [someOptional],
[anotherConstantName] = [someOtherOptional] {
[statements]
}
</code></pre>

Implicitly Unwrapped Optionals

总的来说,Optional代表变量或常量可以为“无值”。Optional可以采用if语句检查是否有值;如若有值,也足以利用Optional
Binding
有原则的拓展来做客其值

偶然,从程序结构上来看Optional总是有值。这种景观下,因为可以安全地假定Optional一直有值,那么撤废检查与解包Optional的值,对于每一次访问以来是有益处的。

这种Optional就足以定义为implicitly unwrapping
optionals
,将问号(String?)替换为叹号(String!),此前的Optional就改成了implicitly
unwrapping optionals

implicitly unwrapping
optionals
在这种情形下有用:在optional第一次定义时就能即时强烈其有值,并可确信此之后间接有值。在斯威夫特(Swift)中,implicitly
unwrapping optionals
重点用以类伊始化的时候。

implicitly unwrapping
optionals
事实上就是一个无独有偶的Optional,但是可以当做非Optional值来利用,并且永不在历次访问都时候都对其解包。接下来的例证将申明,在以explicit
String的情势访问optional String 与 implicitly unwrapping optionals
String时中的值时,在作为上有什么不同:
<pre><code>
let possibleString: String? = “An optional string.”
let forcedString: String = possibleString! // requires an exclamation
mark
<br />
let assumedString: String! = “An implicitly unwrapped optional
string.”
let implicitString: String = assumedString // no need for an exclamation
mark
</code></pre>

可以认为implicitly unwrapping
optionals
是被准许在接纳时自动解包的Optional。与历次使用Optional时将叹号!座落名称前边不同的是:implicitly
unwrapping optionals
务求将叹号!坐落阐明时的类型前边

注:假设访问无值的implicitly unwrapping
optionals
,将会引发运行时不当(runtime
error),这与走访无值Optional时将叹号!位于名称后边同样,都会引发的周转时不当。

implicitly unwrapping
optionals
能够与普通的Optional一样,在if语句中检查是不是为有值:
<pre><code>
if assumedString != nil {
print(assumedString)
}
// prints “An implicitly unwrapped optional string.”
</code></pre>

implicitly unwrapping optionals也足以用于Optional
Binding
,检查并解包其值:
<pre><code>
if let definiteString = assumedString {
print(definiteString)
}
// prints “An implicitly unwrapped optional string.”
</code></pre>

注:假使变量在其后某刻可能为nil,就毫无接纳implicitly unwrapping
optionals
,而是利用普通的Optional类型,用于检查其是否有值。

错误处理 Error Handling


使用错误处理(Error Handling)应对在程序运行时遇见的突发的不当情形

对照于选用Optional可以在函数成功或失利时再次回到有值或无值,错误处理让您有空子判断引发错误的原故,倘使有必要,还是可以够将错误继续传递到程序的任何一些去处理

当函数暴发错误,就会抛出一个error,函数调用中得以捕获这多少个荒唐并展开恰当处理
<pre><code>
func canThrowAnError() throws {
// this function may or may not throw an error
}
</code></pre>

宣称函数时,在括号后紧跟throws第一字。当调用一个恐怕抛出荒谬的函数时,必须在函数前应用try关键字。

Swift会自动将error从其眼前的功效域向外传递,直到遭遇有catch处理那个荒唐
<pre><code>
do {
try canThrowAnError()
// no error was thrown
} catch {
// an error was thrown
}
</code></pre>

do言语创制了一个效率域,可以使错误传递给一个或六个catch处理

下例将显示错误处理怎么着响应不同境况的错误
<pre><code>
func makeASandwich() throws {
// …
}
<br />
do {
try makeASandwich()
eatASandwich()
} catch Error.OutOfCleanDishes {
washDishes()
} catch Error.MissingIngredients(let ingredients) {
buyGroceries(ingredients)
}
</code></pre>

本例中,makeASandwich()函数会在未曾根本盘子或尚未食材不全时抛出荒谬。因为makeASandwich()声明为throws,所以要动用try来调用。将调研放倒do言语里,有不当爆发时将会被传送到对应的catch语句中处理

一经没有错误爆发,eatASandwich()函数将被调用;借使抛出了Error.OutOfCleanDishes错误,washDishes()函数将被调用;假诺抛出了Error.MissingIngredients错误,buyGroceries(_:)函数将被调用,同时在catch中会得到缺失的食材数组[String]

其后会有单章来更详细地介绍throwing, catching, and propagating errors

断言 Assertions


有时,当特定的规范得不到满意时,程序将不能继续执行。碰着这种状态,就足以抓住一个assertion来终止程序执行,使debug有机会去看清暴发assertion案由(无效值或无值)。

Debugging with Assertions

Assertion虽然在运作时检查其论理条件评估后是否为true。从字面来讲,断言断定条件为true。可以动用Assertion担保在运转之后的代码时,必要的尺度现已得到知足。

倘使在Debug时,代码引发了assertion,比如您正在选拔XCode生成运行app,你就足以精确地找到无效状态的职务,并询问暴发assertion时先后的意况。Assertion还允许你提供合适的新闻用于描述引发assertion的原因

使用全局函数assert(_:_:)来描述一个预言。它有六个参数,其一是一个表达式用以评估其结果为true
false,另一个是预言的叙说信息,当表明式结果为false时将会显示。
<pre><code>
let age = -3
assert(age >= 0, “A person’s age cannot be less than zero”)
// this causes the assertion to trigger, because age is not >= 0
</code></pre>

本例中,如果age >= 0true,即:age为非负数,就继续执行;如若age是负数,就会抓住断言,停止程序执行。

只要不想要断言描述消息,可以运用如下情势调用
<pre><code>
assert(age >= 0)
</code></pre>

When to Use Assertions

预言用于当规则有可能不树立,可是必须树立刻先后才能继续执行的地点。使用断言的适龄的意况:

  • 传给自定义下标函数的下标值是否在不利范围内
  • 传给函数一个无效值,导致不可以不辱使命其坚守
  • 当前Optional是nil,然而随着的代码需要其非nil是才能进行成功

注:断言会导致程序终止,并且计划代码时不太可能出现的不算条件最好永不使用断言。虽然如此,在先后公布前的开发阶段,假设不行条件可能现身,断言也是意识行不通条件的有效性形式

参考:The Swift Programming
Language

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图