Swift学习:基本运算符(Basic Operators)

  运算符是检查、改变、合并值的特殊符号或短语。例如,加号( +
)将片独数相加(如 let i = 1 + 2)。 更扑朔迷离的演算例子包括逻辑和运算符 &&
(如 if enteredDoorCode && passedRetinaScan )。

  Swift 支持大部分标准 C
语言的运算符,且改进许多表征来减常规编码错误。如:赋值符( =
)不回去值,以 防止将想如果认清等运算符( ==
)的地方写成赋值符导致的不当。算术运算符( + , – , * , / , % 等)会
检测并无同意值溢起,以这个来避免保存变量时由变量大于或低于其色所能承载的范围时造成的百般结果。当然允许而利用
Swift 的溢出起运算符来实现溢起。

  Swift 还提供了 C
语言没有底表述两频以内的价值的距离运算符( a..<b 和 a…b),这便于我们表达一个间距内的数值。

  本章节仅仅描述了 Swift 中之为主运算符,高级运算符这回会包含 Swift
中之高等运算符,及如何由定义运算符,及如何开展自定义类型的演算符重载。

  术语

  运算符分为平头条、二元和三元运算符:

  一头运算符对单一操作对象操作(如
-a)。一首运算符分别放到运算符和后置运算符,前置运算符需紧跟以操作对象之前(如
!b),后置运算符需紧跟以操作对象下(如 c!)。

  二首先运算符操作对象有星星点点独操作对象(如 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 语句被采取是左的:

  if x = y {

  // 此句错误,因为x = y 并无返外价值

  }

  这个特点使你无法把(==)错写成(=),由于 if x = y 是错误代码,swift
能帮您免此类错误有。

  算数运算符

  swift 中具有数值类且支持了骨干的季虽说算术运算符:

  加法(+)

  减法(-)

  乘法(*)

  除法(/)

  以及 C 语言和 Objective-C 不同之是,swift
默认情况下未允许在数值运算被出现溢起状况。但是你得下 swift
的溢出起运算符来实现溢起运算(如 a &+ b)。

  加法运算符也可是用来 string 的拼接:

  ”hello, ” + “world” // 等于 “hello,world”

  求余运算符

  求余运算符(a % b)是测算 b 的粗倍正好得容入 a,
返回多出去的那片(余数)。

  注意:

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

  来谈谈取余是怎么回事,计算 9 % 4 ,你先计算出 4
的有些倍会刚好可以容入 9 中:

  可以以 9 中放入两单 4 ,那余数是 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
的结果是均等的。

  一首先负号运算符

  数值的正负号可以下前缀 – (即同状元因号符)来切换:

  let three = 3

  let minusThree = -three // minusThree 等于 -3

  let plusThree = -minusThree // plusThree 等于 3,或 “负负3”

  一初次负号符(-) 写于操纵数之前,中间没有空格。

  一元正号运算符

  一元正号符(+)不开另外变动的回操作数的值:

  let minusSix = -6

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

  虽然一元正号符什么都未会见变动,但当你在应用相同首负号来发挥负数时,你得采取一元正号来表述正数。

  组合赋值运算符

  如同 C 语言,swift
也供把任何运算符和赋值运算符(=)组合的做赋值运算符,组合加运算(+=)是中间一个例子:

  var a = 1

  a += 2

  // a 现在是 3

  表达式 a += 2 是 a = a + 2
的简写,一个重组加运算就是管加法运算和赋值运算组合成进一个运算符里,同时到位两单运算任务。

  注意:

  复合赋值运算没有返回值,let b = a += 2
这类似代码来荒唐。这不一让地方提到的自增和于减运算符。

  比较运算符(comparison Operators)

  所有正式 C 语言中的较运算符都可以当 swift 中采用:

  等于(==)

  不等于(!=)

  大于(>)

  小于(<)

  大于等于(>=)

  小于等于(<=)

  注意:

  swift
也供恒等(===)和未固定等(!==)这点儿只比符类判断两独对象是否引用和一个目标实例。

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

  1 == 1 // true

  2 != 1 // true

  2 < 1 // false 

  …

  比较运算符多用于规范语句被,如 if 条件:

  let name = “world”

  if name == “world” {

    print(“hello,world”)

  } else {

    print(“I’m sorry \(name), but I don’t recognize you”)

  }

  // 输出 “hello, world”, 因为 ‘name’ 就是相等 “world”

  当元组中的值好比常,你啊得使这些运算符来比较它们的深浅。例如,因为
Int 和 String 类型的值好比,所以种也(Int,
String)的元组也得以较。相反,Bool
不可知吃于,也表示在发生布尔型的元组不克于比较。

  比较元组大小会按照从漏洞百出至右、逐值比较的不二法门,直到发现出少个例外时停下。如果有的价值都相当,那么这同样对准元组我们就算称其是当的。例如:

  (1, “zebra”)< (2, “apple”) // ture 2 > 1

  (3, “apple”) < (3, “bird”) // true apple < bird

  (4, “dog”) == (4, “dog”) // ture

  以地方的例证中,你可以见见,在首先实行被起左到右的比较行为。因为 1
小于 2,所以(1, “zebra”)小于 (2,”apple”),
不管元组剩下的值怎么。所以 “zebra” 小于 “apple”
没有外影响,因为元组的较就深受第一只因素决定了。不过,当元组的率先个要素相同时候,第二单元素将见面用作比,第二推行与老三履行代码就发了这般的于。

  注意:

  swift
标准库只能于七独以内元素的元组比较函数。如果您的元组元素超过七单时,你得协调实现比较运算符。

  三瞧运算符(Ternary Conditional Operator)

  三相运算符的与众不同在于其是起三个操作数的运算符,它的形式是
问题?答案1: 答案2。它简洁地发挥根据 问题
成立为作出二选一的操作。如果问题建立,返回答案1之结果,反的归回 答案2
底结果。

  三见到运算符是以下代码的缩写形式:

  if question {

    answer1

  } else {

    answer2

  }

  三观展运算符提供有效率且方便的办法来发表二选一的挑。需要注意的从事,过度施用三目运算符会使简洁的代码变的难懂。我们应避免以一个组合语句被利用多单三目运算符。

  空合运算符

  空合运算符(a ?? b)将针对可选类型 a 进行空判断,如果 a
包含一个价值就进展解封,否则就回来一个默认值 b。表达式 a 必须是 Optional
类型。默认值 b 的类必须要和 a 存储值的路保持一致。

  空合运算符是对以下代码的简短表达方法:

  a != nil? a!: b

  上述代码应用了三看来运算符。当可选类型 a
的价值不呢空时,进行强制解封(a!),访问 a 中之价值;反的归回默认值
b。无疑空合运算(??)提供了扳平栽更加优雅的艺术去包条件判断与解封两种表现,显得简洁和重新兼具可读性。

  注意:

  如果 a 为非空值(non-nil),那么值 b
将非会见于算。这吗就算是所谓的围堵求值。

  下文例子采用空合运算符,实现了于默认颜色名和而选取自定义颜色名之间选择:

  let defaultColorName = “red”

  var userDefinedColorName: String? // 默认值是 nil

  var colorNameToUse = userDefinedColorName ?? defaultColorName

  // userDefinedColorName 的价值吗空,所以 colorNameToUse 的值为 “red”

  userDefinedColorName 变量被定义也一个可选的 String 类型,默认值为
nil。由于 userDefinedColorName
是一个可选类型,我们得以用空合运算符去判断该价。在达到一个事例中,通过空合运算符为一个叫也
colorNameToUse 的变量赋予一个字符串类型初始值。由于 userDefinedColorName
值为空,因此表达式 userDefinedColorName ?? defaultColorName 返回
defaultColorName 的价值,即 red。

  另一样状,分配一个非空值(non-nil)给
userDefinedColorName,再次实施空合运算,运算结果吗封包在
userDefaultColorName 中的值,而非默认值。

  userDefinedColorName = “green”

  colorNameToUse = userDefinedColorName ?? defaultColorName 

  区间运算符(Range Operators)

  swift 提供了区区个便宜表达一个距离的值的间隔运算符。

  闭区间运算符

  闭区间运算符(a…b)定义了一个从 a 到 b (包括 a 和 b
)的所有值的间距。a 的值未能够跨越
b。闭区间运算符在迭代一个距离的富有值时是不行实用之,如以 for-in
循环中:

  for index in 1…5 {

    print(“\(index) * 5 = \(index * 5)”)

  }

  半初步区间运算符

  半方始区间运算符(a..<b)定义一个起 a 到 b 但未包 b
的区间。之所以称之为半开始区间,是因该距离涵盖第一只价如果非包最后一个值。

  半起来区间的实用性在于当您采取一个于 0
开始之列表(如数组)时,非常便于地自 0 数及列表的长短。

  let names = [“Anna”, “Alex”, “Brian”, “Jack”]

  let count = names.count

  for i in 0..< count {

    print(“第 \(i + 1) 个人叫\(names[i])”)

  }

  数组有 4 独要素,但 0..<count 只反复届 3
(最后一个素的下标),因为它是半初始区间。

  逻辑运算符

  逻辑运算符的操作对象是逻辑布尔值。swift 支持因 C
语言的老三单标准逻辑运算符。

  逻辑非 (!a)

  逻辑与 (a && b)

  逻辑或 (a || b)

  逻辑非运算符

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

  它是一个平放运算符,需紧跟在操作数之前,且无加空格。读作 非a,
例子如下:

  let allowedEntry = false

  if !allowedEntry {

    print(“ACCESS DENIED”)

  }

  if !allowedEntry 语句可以读作 如果 非 allowedEntry
,接下一行代码只有以 非allowedEntry 为 true, 即 allowEntry 为 false
时为实施。

  以实例代码中,小心地挑选布尔常量或变量有助于代码的可读性,并且避免使重复逻辑非运算,或乱的逻辑语句。

  逻辑与运算

  逻辑与运算符(a && b)表达了只有 a 和 b 的价都也 true
时,整个表达式的值才见面是 true。

  只要随便一个值吗 false,整个表达式的价值就为
false。事实上,如果第一单价值也
false,那么是无失算第二只价的。因为其既不容许影响总体表达式的结果了。这种给称作短路运算(short-circuit
evaluation)。

  逻辑或运算符

  逻辑或运算符(a || b)是一个是因为个别单 ||
组成的中置运算符。它象征了片只逻辑表达式的内一个为 true
,整个表达式就为 true。

  同逻辑与运算符类似,逻辑或也是 短路计算 的,当左端的表达式为 true
时,将无计右边的表达式了,因为它不容许更改总体表达式的值了。

  逻辑运算符组合计算

  我们好构成多单逻辑运算符来表达一个复合逻辑:

  if enteredDoorCode && passedRetinaScan || hasDoorKey ||
KnowOverridePassword {

    print(“Welcome!”)

  } else {

    print(“ACCESS DENIED”)

  }

  这个例子使用了带有多单 && 和 || 的复合逻辑。但无论怎样,&& 和 ||
始终只能操作简单独价值。所以马上实质上是三个简单逻辑连续操作的结果。

  swift 逻辑操作符 && 和 ||
是不当结合的,这意味着有一系列逻辑操作符的复合表达式优先计算最左边的子表达式。

  使用括号来家喻户晓优先级

  为了一个错综复杂表达式更爱读懂,在适宜的地方使用括号来明确预级是异常行之,虽然她不用必要的,在直达独有关门的权力的例子中,我们让第一单有加个括号,使她看起逻辑又强烈:

  if (enteredDoorCode && passedRetinaScan) || hasDoorKey ||
knowsOverridePassword {

    print(“Welcome!”)

  } else {

    print(“ACCESS DENIED”)

  }

  这括号让前少独价值为视作整个逻辑表达中独立的一个片。虽然有括号及没括号的出口结果是一致的,但对读代码的人口吧有括号的代码更清晰。可读性比简洁性更要。

END

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  

  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  

  

 

相关文章