ACCESS斯维夫特学习:基本运算符(Basic Operators)

  运算符是反省、改变、合并值的特殊符号或短语。例如,加号( +
)将多少个数相加(如 let i = 1 + 2)。 更复杂的运算例子包蕴逻辑与运算符 &&
(如 if enteredDoorCode && passedRetinaScan )。

  斯维夫特 辅助半数以上正经 C
语言的运算符,且立异许多特色来压缩常规编码错误。如:赋值符( =
)不再次来到值,以 防止把想要判断相等运算符( ==
)的地方写成赋值符导致的一无可取。算术运算符( + , – , * , / , % 等)会
检测并不允许值溢出,以此来防止保存变量时出于变量大于或低于其系列所能承载的限量时造成的分外结果。当然允许你使用
斯维夫特 的溢出运算符来完结溢出。

  斯维夫特 还提供了 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 

  假设赋值的右侧是1个多元组,它的因素得以即刻被分解成七个常量或变量:

  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

  }

  三目运算符提供有效用且方便的法子来发挥二选一的取舍。须要专注的事,过度使用三目运算符会使简洁的代码变的难懂。我们应幸免在3个组成语句中行使五个三目运算符。

  空合运算符

  空合运算符(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 变量被定义为2个可选的 String 类型,暗中认同值为
nil。由于 userDefinedColorName
是三个可选类型,大家能够动用空合运算符去判断其值。在上1个例证中,通过空合运算符为多个名为
colorNameToUse 的变量赋予多个字符串类型伊始值。由于 userDefinedColorName
值为空,因而表明式 userDefinedColorName ?? defaultColorName 返回defaultColorName 的值,即 red。

  另一景况,分配3个非空值(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)定义3个从 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。

  它是1个停放运算符,需紧跟在操作数以前,且不加空格。读作 非a,
例子如下:

  let allowedEntry = false

  if !allowedEntry {

    print(“ACCESS DENIED”)

  }

  if !allowedEntry 语句可以读作 若是 非 allowedEntry
,接下一行代码唯有在 非allowedEntry 为 true, 即 allowEntry 为 false
时被实践。

  在实例代码中,小心地采用布尔常量或变量有助于代码的可读性,并且防止拔取重复逻辑非运算,或混乱的逻辑语句。

  逻辑与运算

  逻辑与运算符(a && b)表明了唯有 a 和 b 的值都为 true
时,整个表明式的值才会是 true。

  只要随意三个值为 false,整个表明式的值就为
false。事实上,如若第3个值为
false,那么是不去计算第四个值的。因为它早已不容许影响总体表明式的结果了。那种被称作短路运算(short-circuit
evaluation)。

  逻辑或运算符

  逻辑或运算符(a || b)是多个由三个 ||
组成的中置运算符。它表示了多个逻辑表明式的中间两个为 true
,整个表明式就为 true。

  同逻辑与运算符类似,逻辑或也是 短路统计 的,当左端的表明式为 true
时,将不合算右侧的表达式了,因为它不容许改变一切表明式的值了。

  逻辑运算符组合总括

  大家可以组成多少个逻辑运算符来表明1个复合逻辑:

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

    print(“Welcome!”)

  } else {

    print(“ACCESS DENIED”)

  }

  那些事例使用了含八个 && 和 || 的复合逻辑。但无论怎么着,&& 和 ||
始终只可以操作多少个值。所以那其实是八个简易逻辑一而再操作的结果。

  swift 逻辑操作符 && 和 ||
是左结合的,那意味全体一种类逻辑操作符的复合表明式优先统计最左边的子表达式。

  使用括号来明显优先级

  为了二个犬牙相制表达式更便于读懂,在适用的地点使用括号来鲜明优先级是很得力的,固然它并非须要的,在上个关于门的权力的事例中,大家给第四个部分加个括号,使它看起来逻辑更简明:

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

    print(“Welcome!”)

  } else {

    print(“ACCESS DENIED”)

  }

  那括号使得前七个值被当作整个逻辑表明中单独的三个有个别。尽管有括号和没括号的出口结果是一律的,但对于读代码的人的话有括号的代码更显然。可读性比简洁性更器重。

END

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  

  

 

 

 

 

 

 

 

 

 

 

 

 

 

 

  

  

 

相关文章