ios swift学习日记3-基本运算符

近期ios的swift语言好像火了起来，本人没有objectc的基础。但之前是有c跟java的基础的。从这几天開始学习ios的swift语言，后期以博客形式公布。这里提供一本翻译的英文版的swif书籍。

还是非常好地。

本人分享资源从来不要积分哦。仅仅求给大家提供帮助

http://download.csdn.net/detail/a358763471/8009171


运算符是检查。改变，合并值的特殊符号或短语。

比如。加号+将两个数相加（如let i = 1 + 2）。

复杂些的执行算比如逻辑与运算符&&（如if enteredDoorCode && passedRetinaScan），又或让 i 值加1的便捷运算符自增运算符++i等。

Swift 支持大部分标准 C 语言的运算符。且改进很多特性来降低常规编码错误。如，赋值符（=）不返回值，以防止把想要推断相等运算符（==）的地方写成赋值符导致的错误。

数值运算符（+，-，*，/，%等）会检測并不同意值溢出。以此来避免保存变量时因为变量大于或小于其类型所能承载的范围时导致的异常结果。当然同意你使用 Swift 的溢出运算符来实现溢出。详情參见溢出运算符。

差别于 C 语言，在 Swift 中你能够对浮点数进行取余运算（%），Swift 还提供了 C 语言没有的表达两数之间的值的区间运算符。（a..b和a...b），这方便我们表达一个区间内的数值。

本章节仅仅描写叙述了 Swift 中的基本运算符，高级运算符包括了高级运算符，及怎样自己定义运算符。及怎样进行自己定义类型的运算符重载。

术语

运算符有一元，二元和三元运算符。

  • 一元运算符对单一操作对象操作（如-a）。一元运算符分前置符和后置运算符。前置运算符需紧排操作对象之前（如!b），后置运算符需紧跟操作对象之后（如i++）。

  • 二元运算符操作两个操作对象（如2 + 3）。是中置的。由于它们出如今两个操作对象之间。
  • 三元运算符操作三个操作对象。和 C 语言一样。Swift 仅仅有一个三元运算符，就是三元条件运算符（a ? b : c）。

受运算符影响的值叫操作数，在表达式1 + 2中，加号+是二元运算符。它的两个操作数是值1和2。

赋值运算符

赋值运算（a = b）。表示用b的值来初始化或更新a的值：

let b = 10
var a = 5
a = b
// a 如今等于 10

假设赋值的右边是一个多元组，它的元素能够立即被分解多个变量或变量：

let (x, y) = (1, 2)
// 如今 x 等于 1, y 等于 2

与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回不论什么值。所以下面代码是错误的：

if x = y {
    // 此句错误, 由于 x = y 并不返回不论什么值
}

这个特性使得你无法把（==）错写成（=）了。因为if x = y是错误代码，Swift 从底层帮你避免了这些代码错误。

数值运算

Swift 让全部数值类型都支持了主要的四则运算：

  • 加法（+）
  • 减法（-）
  • 乘法（*）
  • 除法（/）
1 + 2       // 等于 3
5 - 3       // 等于 2
2 * 3       // 等于 6
10.0 / 2.5  // 等于 4.0

与 C 语言和 Objective-C 不同的是。Swift 默认不同意在数值运算中出现溢出情况。

但你能够使用 Swift 的溢出运算符来达到你有目的的溢出（如a &+ b）。详情參见溢出运算符。

加法运算符也用于String的拼接：

"hello, " + "world"  // 等于 "hello, world"

两个Character值或一个String和一个Character值，相加会生成一个新的String值：

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

详情參见字符。字符串的拼接。

求余运算

求余运算（a % b）是计算b的多少倍刚刚好能够容入a。返回多出来的那部分（余数）。

注意：

求余运算（%）在其它语言也叫取模运算。然而严格说来，我们看该运算符对负数的操作结果。"求余"比"取模"更合适些。

我们来谈谈取余是怎么回事。计算9 % 4，你先计算出4的多少倍会刚好能够容入9中：

Art/remainderInteger_2x.png

2倍，很好。那余数是1（用橙色标出）

在 Swift 中这么来表达：

9 % 4    // 等于 1

为了得到a % b的结果。%计算了下面等式，并输出余数作为结果：

a = (b × 倍数) + 余数

当倍数取最大值的时候。就会刚好能够容入a中。

把9和4代入等式中。我们得1：

9 = (4 × 2) + 1

相同的方法。我来们计算 -9 % 4：

-9 % 4   // 等于 -1

把-9和4代入等式。-2是取到的最大整数：

-9 = (4 × -2) + -1

余数是-1。

在对负数b求余时，b的符号会被忽略。

这意味着 a % b 和 a % -b的结果是同样的。

浮点数求余计算

不同于 C 语言和 Objective-C。Swift 中是能够对浮点数进行求余的。

8 % 2.5 // 等于 0.5

这个样例中，8除于2.5等于3余0.5。所以结果是一个Double值0.5。

Art/remainderFloat_2x.png

自增和自增运算

和 C 语言一样，Swift 也提供了方便对变量本身加1或减1的自增（++）和自减（--）的运算符。其操作对象能够是整形和浮点型。

‌

var i = 0
++i      // 如今 i = 1

每调用一次++i，i的值就会加1。实际上。++i是i = i + 1的简写，而--i是i = i - 1的简写。

++和--既是前置又是后置运算。

++i。i++。--i和i--都是有效的写法。

我们须要注意的是这些运算符改动了i后有一个返回值。假设你仅仅想改动i的值。那你就能够忽略这个返回值。但假设你想使用返回值。你就须要留意前置和后置操作的返回值是不同的。

  • 当++前置的时候，先自増再返回。

  • 当++后置的时候，先返回再自增。

比如：

var a = 0
let b = ++a // a 和 b 如今都是 1
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和--i。由于先改动后返回这种行为更符合我们的逻辑。

一元负号

数值的正负号能够使用前缀-（即一元负号）来切换：

let three = 3
let minusThree = -three       // minusThree 等于 -3
let plusThree = -minusThree   // plusThree 等于 3, 或 "负负3"

一元负号（-）写在操作数之前，中间没有空格。

一元正号

一元正号（+）不做不论什么改变地返回操作数的值。

let minusSix = -6
let alsoMinusSix = +minusSix  // alsoMinusSix 等于 -6

尽管一元+做无用功，但当你在使用一元负号来表达负数时，你能够使用一元正号来表达正数，如此你的代码会具有对称美。

复合赋值（Compound Assignment Operators）

如同强大的 C 语言，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("I'm sorry (name), but I don't recognize you")
}
// 输出 "hello, world", 由于 `name` 就是等于 "world"

关于if语句，请看控制流。

三元条件运算(Ternary Conditional Operator)

三元条件运算的特殊在于它是有三个操作数的运算符，它的原型是问题？答案1：答案2。它简洁地表达依据问题成立与否作出二选一的操作。假设问题成立，返回答案1的结果; 假设不成立，返回答案2的结果。

使用三元条件运算简化了下面代码：

if question: {
    answer1
}
else {
    answer2
}

这里有个计算表格行高的样例。假设有表头。那行高应比内容高度要高出50像素; 假设没有表头。仅仅需高出20像素。

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

这样写会比以下的代码简洁：

let contentHeight = 40
let hasHeader = true
var rowHeight = contentHeight
if hasHeader {
    rowHeight = rowHeight + 50
} else {
    rowHeight = rowHeight + 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

关于for-in，请看控制流。

半闭区间

半闭区间（a..b）定义一个从a到b但不包含b的区间。

之所以称为半闭区间，是由于该区间包含第一个值而不包含最后的值。

半闭区间的有用性在于当你使用一个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")
}
// 输出 "ACCESS DENIED"

if！allowedEntry语句能够读作 "假设 非 alowed entry。"。接下一行代码仅仅有在假设 "非 allow entry" 为true，即allowEntry为false时被运行。

在演示样例代码中。小心地选择布尔常量或变量有助于代码的可读性，而且避免使用双重逻辑非运算，或混乱的逻辑语句。

逻辑与

逻辑与（a && b）表达了仅仅有a和b的值都为true时。整个表达式的值才会是true。

仅仅要随意一个值为false，整个表达式的值就为false。其实。假设第一个值为false，那么是不去计算第二个值的，由于它已经不可能影响整个表达式的结果了。这被称做 "短路计算（short-circuit evaluation）"。

下面样例，仅仅有两个Bool值都为true值的时候才同意进入：

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

逻辑或

逻辑或（a || b）是一个由两个连续的|组成的中置运算符。它表示了两个逻辑表达式的当中一个为true，整个表达式就为true。

同逻辑与运算类似。逻辑或也是"短路计算"的，当左端的表达式为true时，将不计算右边的表达式了，由于它不可能改变整个表达式的值了。

下面演示样例代码中。第一个布尔值（hasDoorKey）为false，但第二个值（knowsOverridePassword）为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!"

这个样例使用了含多个&&和||的复合逻辑。但不管如何，&&和||始终仅仅能操作两个值。

所以这实际是三个简单逻辑连续操作的结果。我们来解读一下：

假设我们输入了正确的password并通过了视网膜扫描; 或者我们有一把有效的钥匙; 又或者我们知道紧急情况下重置的password，我们就能把门打开进入。

前两种情况。我们都不满足。所曾经两个简单逻辑的结果是false，可是我们是知道紧急情况下重置的password的，所以整个复杂表达式的值还是true。

使用括号来明白优先级

为了一个复杂表达式更easy读懂，在合适的地方使用括号来明白优先级是非常有效的，尽管它并不是必要的。在上个关于门的权限的样例中。我们给第一个部分加个括号，使用它看起来逻辑更明白：

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

这括号使得前两个值被看成整个逻辑表达中独立的一个部分。尽管有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要。请在能够让你代码变清晰地地方加个括号吧！

【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/wgwyanfs/p/6946854.html