在Swift中你可以对浮点数进行取余运算( % )
术语
运算符有一目, 双目和三目运算符.
一目运算符对操作一个对象, 如 -a.
一目运算符分为前置运算符和后置运算符, 前置运算符需紧排操作对象之前, 如 !b, 后置运算符需紧跟操作对象之后,如 i++,
双目运算符操作两个操作对象, 如 2 + 3. 是中置的, 因为它们出现在两个操作对象之间.
三目运算符操作三个操作对象, 和C语言一样, Swift只有一个三目运算符, 就是三目条件运算符 a ? b : c.
受运算符影响的值叫操作数, 在表达式 1 + 2 中, 加号 + 是双目运算符, 它的两个操作数是值 1 和 2.
赋值运算符
赋值运算 a = b, 表示用 b 的值来初始化或更新 a 的值.
1 let b = 10 2 var a = 5 3 a = b 4 // a 现在等于 10
如果赋值的右边是一个多元组, 它的元素可以马上被分解多个变量或变量
1 let (x, y) = (1, 2) 2 // 现在 x 等于 1, y 等于 2
与C语言和Objective-C不同, Swift的赋值操作并不返回任何值. 所以以下代码是错误的:
1 if x = y {
2 // 此句错误, 因为 x = y 并不返回任何值
3 }
数值运算
Swift让所有数值类型都支持了基本的四则运算:
加法 +
减法 -
乘法 *
除法 /
1 1 + 2 // 等于 3 2 5 - 3 // 等于 2 3 2 * 3 // 等于 6 4 10.0 / 2.5 // 等于 4.0
加法操作 + 也用于字符串的拼接:
1 "hello, " + "world" // 等于 "hello, world"
求余运算
1 9 % 4 // 等于 1 2 -9 % 4 // 等于 -1
注意：在对负数求余时, 负数的符号会被忽略. 这意味着 a % b 和 a % -b的结果是相同的.
浮点数求余计算
1 8 % 2.5 // 等于 0.5
这个例子中, 8除于2.5等于3余0.5, 所以结果是0.5.
自增和自减运算
1 var i = 0 2 ++i // 现在 i = 1
每调用一次 ++i, i 的值就会加1.实际上
- ++i 等于 i = i + 1
- - - i 等于 i = i - 1
++ 和 --既是前置又是后置运算. ++i, i++, --i 和 i-- 都是有效的写法.
它们的区别是：
- 当 ++ 前置的时候, 先自増再返回.
- 当 ++ 后置的时候, 先返回再自增.
1 var a = 0 2 let b = ++a // a 和 b 现在都是 1 3 let c = a++ // a 现在 2, 但 c 是 a 自增前的值 1
上述例子, let b = ++a, 先把 a 加1了再返回 a 的值. 所以 a 和 b 都是新值 1.
而 let c = a++, 是先返回了 a 的值, 然后 a 才加1. 所以 c 得到了 a 的旧值1, 而 a 加1后变成2.
推荐你使用 ++i 和 --i, 因为先修改后返回这样的行为更符合我们的逻辑.
单目负号
数值的正负号可以使用前缀 - (即单目负号) 来切换:
1 let three = 3 2 let minusThree = -three // minusThree 等于 -3 3 let plusThree = -minusThree // plusThree 等于 3, 或 "负负3"
注意：单目负号写在操作数之前, 中间没有空格.
单目正号
单目正号 + 不做任何改变地返回操作数的值.
1 let minusSix = -6 2 let alsoMinusSix = +minusSix // alsoMinusSix 等于 -6
虽然单目 + 做无用功, 但当你在使用单目负号来表达负数时, 你可以使用单目正号来表达正数, 如此你的代码会具有对称美.
赋值运算符
Swift也提供把其他运算符和赋值运算 = 组合的复合赋值运算符, 加赋运算 += 是其中一个例子:
var a = 1 a += 2 // a 现在是 3
表达式 a += 2 是 a = a + 2 的简写, 一个加赋运算就把加法和赋值两件事完成了.
注意：复合赋值运算没有返回值, let b = a += 2 这类代码是错误. 这不同于上面提到的自增和自减运算符.
比较运算
- 等于 a == b
- 不等于 a != b
- 大于 a > b
- 小于 a < b
- 大于等于 a >= b
- 小于等于 a <= b
每个比较运算都返回了一个标识表达式是否成立的布尔值:
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"
注意: Swift也提供恒等 === 和不恒等 !== 这两个比较符来判断两个对象是否引用同一个对象实例. 更多细节在 类与结构.
三目条件运算
三目条件运算的特殊在于它是有三个操作数的运算符,它的原型是 问题 ? 答案1 : 答案2.它简洁地表达根据 问题 成立与否作出二选一的操作.
如果 问题 成立, 返回 答案1 的结果;
如果不成立, 返回 答案2 的结果.
这里有个计算表格行高的例子. 如果有表头, 那行高应比内容高度要高出50像素; 如果没有表头, 只需高出20像素.
1 let contentHeight = 40
2 let hasHeader = true
3 var rowHeight = contentHeight
4 if hasHeader {
5 rowHeight = rowHeight + 50
6 } else {
7 rowHeight = rowHeight + 20
8 }
9 // rowHeight 现在是 90
使用三目运算符简化后：
let contentHeight = 40 let hasHeader = true let rowHeight = contentHeight + (hasHeader ? 50 : 20) // rowHeight 现在是 90
第二段代码例子使用了三目条件运算, 所以一行代码就能让我们得到正确答案. 这比第一段代码简洁得多, 无需将 rowHeight 定义成变量, 因为它的值无需在 if 语句中改变.
区间运算符
Swift提供了两个方便表达一个区间的值的运算符.闭区间和半闭区间
闭区间运算符
闭区间运算符 a...b 定义一个包含从 a 到 b (包括 a 和 b)的所有值的区间. 闭区间运算符在迭代一个区间的所有值时是非常有用的, 如在 for-in 循环中:
for index in 1...5 {
println("\(index) * 5 = \(index * 5)")
}
// 1 * 5 = 5
// 2 * 5 = 10
// 3 * 5 = 15
// 4 * 5 = 20
// 5 * 5 = 25
半闭区间
半闭区间的实用性在于当你使用一个0始的列表(如数组)时, 非常方便地从0数到列表的长度.
let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
println("第 \(i + 1) 个人叫 \(names[i])")
}
// 第 1 个人叫 Anna
// 第 2 个人叫 Alex
// 第 3 个人叫 Brian
// 第 4 个人叫 Jack
注意: 数组有4个元素, 但 0..count 只数到 3 (最后一个元素的下标), 因为它是半闭区间
逻辑运算
逻辑运算的操作对象是逻辑布尔值. Swift支持基于C语言的三个标准逻辑运算
逻辑非 !a
逻辑与 a && b
逻辑或 a || b
逻辑非
逻辑非运算 !a 对一个布尔值取反, 使得 true 变 false, false 变 true.
它是一个前置运算符, 需出现在操作数之前, 且不加空格. 读作 非 a,如下:
let allowedEntry = false
if !allowedEntry {
println("ACCESS DENIED")
}
// prints "ACCESS DENIED"
逻辑与
逻辑与 a && b 表达了只有 a 和 b 的值都为 true 时, 整个表达式的值才会是 true .
只要任意一个值为 false, 整个表达式的值就为 false. 事实上, 如果第一个值为 false, 那么是不去计算第二个值的, 因为它已经不可能影响整个表达式的结果了. 这被称做 "短路计算".
只有两个值都为true的时候才允许进入:
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
println("Welcome!")
} else {
println("ACCESS DENIED")
}
// 输出 "ACCESS DENIED
逻辑或
逻辑或 a || b 是一个由两个连续的 | 组成的中置运算符. 它表示了两个逻辑表达式的其中一个为 true, 整个表达式就为 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!"
使用括号来明确优先级
为了一个复杂表达式更容易读懂, 在合适的地方使用括号来明确优先级是很有效的, 虽然它并非必要的. 在上个关于门的权限的例子中, 我们给第一个部分加个括号, 使用它看起来逻辑更明确.
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
println("Welcome!")
} else {
println("ACCESS DENIED")
}
// prints "Welcome!"
这括号使得前两个值被看成整个逻辑表达中独立的一个部分. 虽然有括号和没括号的输出结果是一样的, 但对于读代码的人来说有括号的代码更清晰.可读性比简洁性更重要
原文：http://www.cocoachina.com/ios/20140611/8767.html
2015-03-18
21:46:23