swift笔记二（基本运算符）

赋值运算符

赋值运算 a = b, 表示用 b 的值来初始化或更新 a 的值.

let b = 10 
var a = 5 
a = b 
// a 现在等于 10 

如果赋值的右边是一个多元组, 它的元素可以马上被分解多个变量或变量

let (x, y) = (1, 2) 
// 现在 x 等于 1, y 等于 2 

数值运算

Swift让所有数值类型都支持了基本的四则运算:

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

1 + 2       // 等于 3 
5 - 3       // 等于 2 
2 * 3       // 等于 6 
10.0 / 2.5  // 等于 4.0 

加法操作 + 也用于字符串的拼接:
"hello, " + "world" // 等于 "hello, world"
两个字符类型或一个字符类型和一个字符串类型, 相加会生成一个新的字符串类型:

let dog: Character = "d" 
let cow: Character = "c" 
let dogCow = dog + cow 
// 译者注: 原来的引号内是很可爱的小狗和小牛, 但win os下不支持表情字符, 所以改成了普通字符 
// dogCow 现在是 "dc" 

求余运算

求余运算 a % b 是计算 b 的多少倍刚刚好可以容入 a , 多出来的那部分叫余数.
注意：求余运算(%)在其他语言也叫取模运算. 然而严格说来, 我们看该运算符对负数的操作结果, 求余 比 取模 更合适些.

在Swift中这么来表达
9 % 4 // 等于 1
为了得到 a % b 的结果, %计算了以下等式, 并输出余数作为结果:
a = (b × 倍数) + 余数
把 9 和 4 代入等式中, 我们得 1:
9 = (4 × 2) + 1
同样的方法, 我来们计算 -9 % 4 :
-9 % 4 // 等于 -1
把 -9 和 4 代入等式, -2 是取到的最大整数:
-9 = (4 × -2) + -1
在对负数 -b 求余时, -b的符号会被忽略. 这意味着 a % b 和 a % -b的结果是相同的.

浮点数求余计算

不同于C和Objective-C, Swift中是可以对浮点数进行求余的.
8 % 2.5 // 等于 0.5 //这个例子中, 8除于2.5等于3余0.5, 所以结果是0.5.

复合赋值

Swift也提供把其他运算符和赋值运算 = 组合的复合赋值运算符, 加赋运算 += 是其中一个

var a = 1 
a += 2 // a 现在是 3 

表达式 a += 2 是 a = a + 2 的简写, 一个加赋运算就把加法和赋值两件事完成了.
注意：复合赋值运算没有返回值, let b = a += 2 这类代码是错误. 这不同于上面提到的自增和自减运算符.

比较运算

所有标准C中的比较运算都可以在Swift中使用.
等于 a == b
不等于 a != b
大于 a > b
小于 a < b
大于等于 a >= b
小于等于 a <= b

注意: Swift也提供恒等 === 和不恒等 !== 这两个比较符来判断两个对象是否引用同一个对象实例. 更多细节在 类与结构.

每个比较运算都返回了一个标识表达式是否成立的布尔值:

1 == 1   // true, 因为 1 等于 1 
2 != 1   // true, 因为 2 不等于 1 
2 > 1    // true, 因为 2 大于 1 
1 < 2    // true, 因为 1 小于2 
1 >= 1   // true, 因为 1 大于等于 1 
2 <= 1   // false, 因为 2 并不小于等于 1 

比较运算多用于条件语句, 如 if 条件:

let name = "world" 
if name == "world" { 
    println("hello, world") 
} else { 
    println("对不起, \(name), 我不认识你!") 
} 
// 输出 "hello, world", 因为 `name` 就是等于 "world" 

三目条件运算

三目条件运算的特殊在于它是有三个操作数的运算符, 它的原型是 问题 ? 答案1 : 答案2. 它简洁地表达根据 问题 成立与否作出二选一的操作. 如果 问题 成立, 返回 答案1 的结果; 如果不成立, 返回 答案2 的结果.

举个🌰
这里有个计算表格行高的例子. 如果有表头, 那行高应比内容高度要高出50像素; 如果没有表头, 只需高出20像素.

let contentHeight = 40 
let hasHeader = true 
let rowHeight = contentHeight + (hasHeader ? 50 : 20) 
// rowHeight 现在是 90 

区间运算符

闭区间运算符

for index in 1...5 { 
  println("\(index) * 5 = \(index * 5)") 
} 

半闭区间

定义一个从 a 到 b 但不包括 b 的区间. 之所以称为半闭区间

let names = ["Anna", "Alex", "Brian", "Jack"] 
let count = names.count 
for i in 0..<count { 
    println("第 \(i + 1) 个人叫 \(names[i])") 
} 

逻辑运算

逻辑运算的操作对象是逻辑布尔值. Swift支持基于C语言的三个标准逻辑运算.
逻辑非 !a
逻辑与 a && b
逻辑或 a || b

逻辑非

逻辑非运算 !a 对一个布尔值取反, 使得 true 变 false, false 变 true.

let allowedEntry = false 
if !allowedEntry { 
    println("ACCESS DENIED") 
} 
// prints "ACCESS DENIED" 

逻辑与

逻辑与 a && b 表达了只有 a 和 b 的值都为 true 时, 整个表达式的值才会是 true .

let enteredDoorCode = true 
let passedRetinaScan = false 
if enteredDoorCode && passedRetinaScan { 
    println("Welcome!") 
} else { 
    println("ACCESS DENIED") 
} 
// 输出 "ACCESS DENIED 

逻辑或

逻辑或 a || b 是一个由两个连续的 | 组成的中置运算符. 它表示了两个逻辑表达式的其中一个为 true, 整个表达式就为 true.

let hasDoorKey = false 
let knowsOverridePassword = true 
if hasDoorKey || knowsOverridePassword { 
    println("Welcome!") 
} else { 
    println("ACCESS DENIED") 
} 
// 输出 "Welcome!" 

组合逻辑

if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword { 
    println("Welcome!") 
} else { 
    println("ACCESS DENIED") 
} 
// 输出 "Welcome!" 
//这个例子使用了含多个 && 和 || 的复合逻辑. 但无论怎样, && 和 || 始终只能操作两个值. 所以这实际是三个简单逻辑连续操作的结果. 我们来解读一下:
 
//如果我们输入了正确的密码并通过了视网膜扫描; 或者我们有一把有效的钥匙; 又或者我们知道紧急情况下重置的密码, 我们就能把门打开进入.
 
//前两种情况, 我们都不满足, 所以前两个简单逻辑的结果是 false, 但是我们是知道紧急情况下重置的密码的, 所以整个复杂表达式的值还是 true.

使用括号来明确优先级

为了一个复杂表达式更容易读懂, 在合适的地方使用括号来明确优先级是很有效的, 虽然它并非必要的. 在上个关于门的权限的例子中, 我们给第一个部分加个括号, 使用它看起来逻辑更明确.

if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword { 
    println("Welcome!") 
} else { 
    println("ACCESS DENIED") 
} 

这括号使得前两个值被看成整个逻辑表达中独立的一个部分. 虽然有括号和没括号的输出结果是一样的, 但对于读代码的人来说有括号的代码更清晰.