第三章.运算符

在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 这类代码是错误. 这不同于上面提到的自增和自减运算符.

 

比较运算

1. 等于      a == b
2. 不等于　a != b
3. 大于      a > b
4. 小于      a < b
5. 大于等于 a >= b
6. 小于等于 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

转载于:https://www.cnblogs.com/huangzx/p/4344980.html