斯维夫特(Swift)(Swift) Basic Operators

操作符就是有些专用的记号或短语,用于值的检讨、更改、合并等。例如加号操作符+
将四个数加起来(as in
let i = 1 + 2)。更复杂的例子如逻辑与AND操作符&& (as in
if enteredDoorCode && passedRetinaScan)和增值操作符++i,方便的给指定变量i
的值加1

斯维夫特(Swift)帮忙大多数专业 C
操作符,并改进了多少个职能用以消除周边的编码错误。赋值操作符 =
不重返值,可避免在应用优秀操作符 ==
时不当地采纳了赋值操作符。数学操作符(+, -, *, / %
等)会检测并拦截溢出,以避免出现超出类型允许存储范围的出人意料结果。使用斯维夫特(Swift)的溢出操作符,能够选取值溢出的一言一行,进一步的新闻请看溢出操作符

与 C 不同的是,Swift(Swift)允许浮点数举行取余(%)运算。还提供了六个 C
没有的限定操作符(a..<ba...b),用于简便地代表范围内的值

这章重点描述斯威夫特(Swift)的常用操作符。其他高档操作符请看高等操作符,在这章里根本讲怎么自定义操作符和为自定义类实现规范操作符

术语 Terminology


操作符分为一元(unary)、二元(binary)、三元(ternary)操作符:

  • 一元操作符只功效于一个目的/操作数(如
    -a)。一元前缀操作符紧挨在操作数前(例如
    !b),一元后缀操作符紧挨在操作数的末端(例如 i++
  • 二元操作符有两个操作数(如
    2 + 3),并在三个操作数中间,是中缀操作符
  • 大年终一操作符有多少个操作数。和 C
    一样,斯威夫特(Swift)(Swift)只有一个三元操作符:条件操作符(a ? b : c

操作符使用的值就叫操作数。在颁布式 1 + 2中,+
加号是二元操作符,而他的五个操作数是 12

赋值操作符 Assignment Operator


赋值操作符(a = b)使用 b 的值初阶化或更新 a 的值
<pre><code>
let b = 10
var a = 5
a = b
// a is now equal to 10
</code></pre>

比方赋值操作符右边是一个有三个值的元组,其元素的值可以解释到六个常量或变量中:
<pre><code>
let (x, y) = (1, 2)
// x is equal to 1, and y is equal to 2
</code></pre>

与 C 和 Objective-C
不同,赋值操作符本身不重返值,所以上边对讲话是行不通的:
<pre><code>
if x = y {
// this is not valid, because x = y does not return a value
}
</code></pre>

这一个特点会防止将非凡操作符(==),意外写成赋值操作符(=)。因为
if x = y 无效,所以斯威夫特(Swift)将援助你制止代码中的此类问题。

算数操作符 Arithmetic Operators


斯威夫特的兼具数字类型都补助4种标准的算数操作符:

  • 加(+
  • 减(-
  • 乘(*
  • 除(/

<pre><code>
1 + 2 // equals 3
5 – 3 // equals 2
2 * 3 // equals 6
10.0 / 2.5 // equals 4.0
</code></pre>

不同于 C 和 Objective-C
的算数操作符,斯威夫特(Swift)算数操作符默认不允许值溢出。可以运用斯威夫特的溢出操作符拔取溢出作为(如
a &+ b)。详情请看溢出操作符

加号操作符同时也支撑 String 连结:
<pre><code>
“hello, ” + “world” // equals “hello, world”
</code></pre>

取余操作符 Remainder Operator

取余操作符(a % b)算出 a 能容纳多少个
b,并回到剩下的值(即:余数)

注:取余操作符在其余语言中也有些叫取模操作符。可是严酷来说,在斯维夫特中对此负数而言是余数而不是模操作

下图演示取余操作符如何总括的。 统计 9 % 4,首先要算出 9 里面有微微个
4

平头总计余数

可以见到,这里有五个 4,最终剩余 1(图中粉红色的一对)

中斯威夫特(Swift)中,取余操作符使用情势如下:
<pre><code>
9 % 4 // equals 1
</code></pre>

要确定 a % b 的答案,% 操作符统计如下等式并回到 remainder
a = (b x some multiplier) + remainder
some multiplier是最大的倍增 b 仍可以兼容于 a 的数

94 代入等式,产出:
9 = (4 x 2) + 1

同等,负数也使用此措施总括余数
<pre><code>
-9 % 4 // equals -1
</code></pre>

-94 代入等式,产出:
-9 = (4 x -2) + -1
余数是 -1

some multiplier倘使是负数,将会忽视其标志。意思是 a % ba % -b
将再次回到相同的结果

浮点数余数总结 Floating-Point Remainder Calculations

不同于 C 和 Objective-C
的取余操作符,斯维夫特(Swift)的取余操作符能够总结浮点数的余数:
<pre><code>
8 % 2.5 // equals 0.5
</code></pre>

浮点数总计余数

增量和减量操作符 Increment and Decrement Operators

与 C
类似,Swift(Swift)也提供了增量操作符(++)和减量操作符(--),方便的对数值进行加/减
1 操作,可以用来整数和浮点数变量
<pre><code>
var i = 0
++i // i now equals 1
</code></pre>

每调用 ++i 一次,i 的值扩充 1,本质上说,++ii = i + 1
的简写。类似地,--i 可以是 i = i - 1 的简写

++-- 即可以当作前缀操作符,也足以当作后缀操作符。++ii++
都可以使 i 的值加 1。类似地,--ii-- 都可以使 i 值减 1

瞩目,那多少个操作符即修改 i 的值,也再次来到值。假使只是想 i 加/减
1,可以忽略重返值。但是,倘若想行使再次回到值,那么前缀和后缀操作符会重返不同的值,规则如下:

  • 假诺操作符在变量前,则先转移变量值,并重回改变后的值
  • 假使操作符中变量后,则先重回变量原值,后变更变量的值

<pre><code>
var a = 0
let b = ++a
// a and b are now both equal to 1
let c = a++
// a is now equal to 2, but c has been set to the pre-increment value of
1
</code></pre>

只有你需要以 i++ 的法门使用操作符,否则推荐在所有的情事下利用 ++i
--i 的款式,因为重返值与实际值是一样的。

一元负号操作符 Unary Minus Operator

使用 - 操作符(前缀操作符)可以每一次切换数值的号子,那就是负号操作符
<pre><code>
let three = 3
let minusThree = -three // minusThree equals -3
let plusThree = -minusThree // plusThree equals 3, or “minus minus
three”
</code></pre>

负号操作符需要紧挨在操作数前面,之间不可能有此外空白字符

一首祚号操作符 Unary Plus Operator

使用 + 操作符,将会回来原值,而且对原值不会生出此外影响
<pre><code>
let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix equals -6
</code></pre>

虽然 + 操作符没有做其他工作,可是在代码中,对正数使用 +
操作符和对负数使用 - 操作符能使代码看起来相比较整齐

组合赋值操作符 Compound Assignment Operators


像 C 一样,斯维夫特(Swift)提供了整合赋值操作符,将 =
与任何操作符组合在一块儿利用:
<pre><code>
var a = 1
a += 2
// a is now equal to 3
</code></pre>

表达式 a += 2 使 a = a + 2
的简写。将加法与赋值组合进一个操作符,这五个操作将同时施行。

注:组合赋值操作符不再次回到值。那点与地点提及的 ++--不同

要查阅所有的咬合赋值操作符,请看斯威夫特 Language Reference 之
表达式

比较操作符 Comparison Operators


斯维夫特(Swift) 帮忙具备正规 C 相比操作符:

  • 等于 (a == b)
  • 不等于 (a != b)
  • 大于 (a > b)
  • 小于 (a < b)
  • 超出等于 (a >= b)
  • 小于等于 (a <= b)

注:斯维夫特(Swift)还提供了三个辨识操作符(===!==),用来相比较六个对象引用是否是指向同一个目标实例,更多音讯请参见类与构造

各类相比操作符都回到 Bool 值,指示语句是否为 true:
<pre><code>
1 == 1 // true, because 1 is equal to 1
2 != 1 // true, because 2 is not equal to 1
2 > 1 // true, because 2 is greater than 1
1 < 2 // true, because 1 is less than 2
1 >= 1 // true, because 1 is greater than or equal to 1
2 <= 1 // false, because 2 is not less than or equal to 1
</code></pre>

正如操作符通常用在尺度语句中,比如 if 语句:
<pre><code>
let name = “world”
if name == “world” {
print(“hello, world”)
} else {
print(“I’m sorry (name), but I don’t recognize you”)
}
// prints “hello, world”, because name is indeed equal to “world”
</code></pre>

想打听更多关于 if
的信息,请参考控制流

元辰条件操作符 Ternary Conditional Operator


大年终一条件操作符有六个操作数,是相比较特其它一个操作符,它是这般的情势:question ? answer1 : answer2。它根据
question 是 true 还是 false,能很快的乘除四个表明式之一的值。假使为
true,总计并再次来到 answer1 的值;false 统计并回到 answer2 的值

大年初一条件操作符是之类代码的简写:
<pre><code>
if question {
answer1
} else {
answer2
}
</code></pre>

实质上行使时,参考下例:
<pre><code>
let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight is equal to 90
</code></pre>

伊始展开后,是之类代码
<pre><code>
let contentHeight = 40
let hasHeader = true
var rowHeight = contentHeight
if hasHeader {
rowHeight = rowHeight + 50
} else {
rowHeight = rowHeight + 20
}
// rowHeight is equal to 90
</code></pre>

假诺过多接纳三元标准操作符,会招致代码可读性变坏。
制止嵌套使用三元标准操作符。

Nil合并操作符 Nil Coalescing Operator


nil coalescing operator (a ?? b),如果 Optional a 有值,就解包
a,否则一经 anil 返回 ba 必须是 Optional 类型,b
a 存储的类型必须一致。

nil coalescing operator 是之类使用三元标准操作符的代码的简写:
<pre><code>
a != nil ? a! : b
</code></pre>

注:就算 a 不为 nil ,b 的值不会总结,即:短路总计(short-circuit)

举例如下:
<pre><code>
let defaultColorName = “red”
var userDefinedColorName: String? // defaults to nil

var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is nil, so colorNameToUse is set to the default
of “red”
</code></pre>

如果给 userDefinedColorName 赋值,则如下:
<pre><code>
userDefinedColorName = “green”
colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName is not nil, so colorNameToUse is set to
“green”
</code></pre>

界定操作符 Range Operators


Swift 有二种范围操作符,用来简化一个限量内值的象征方法

封闭范围操作符 Closed Range Operator

(a...b) 定义一个从 ab 的界定内的值,包括 aba
的值一定不得以超越 b

貌似在遍历范围内所有值的时候利用,例如for-in 循环:
<pre><code>
for index in 1…5 {
print(“(index) times 5 is (index * 5)”)
}
// 1 times 5 is 5
// 2 times 5 is 10
// 3 times 5 is 15
// 4 times 5 is 20
// 5 times 5 is 25
</code></pre>

半开范围操作符 哈尔f-Open Range Operator

(a..<b) 定义一个从 ab 的限定内的值,包括 a 但不包括 ba
的值一定不可以超过 b。如果 a 等于 b,则范围为空

对于遍历从 0 起首的列表有其实用:
<pre><code>
let names = [“Anna”, “Alex”, “Brian”, “Jack”]
let count = names.count
for i in 0..< count {
//那里小于号与count要链接在联合,但因为与html争辨问题未缓解,所以加了空格
print(“Person (i + 1) is called (names[i])”)
}
// Person 1 is called Anna
// Person 2 is called Alex
// Person 3 is called Brian
// Person 4 is called Jack
</code></pre>

逻辑操作符 Logical Operators


逻辑操作符修改或结成 Boolean 逻辑值 true 和
false。斯维夫特(Swift)(Swift)有多少个逻辑操作符,都得以在基于C的编程语言中找到:

  • 逻辑非 NOT (!a)
  • 逻辑与 AND (a && b)
  • 逻辑或 OR (a || b)

Logical NOT Operator

逻辑非(!a)操作符将 Boolean 值取反,即 true 变为 false,false 变为 true

逻辑非是前缀操作符,并且要紧挨在操作数往日,之间不可以有空落落:
<pre><code>
let allowedEntry = false
if !allowedEntry {
print(“ACCESS DENIED”)
}
// prints “ACCESS DENIED”
</code></pre>

留神在给常量或变量起名时,保持代码的可读性。防止重新否定或混乱的逻辑语句

Logical AND Operator

逻辑与操作符 (a && b),需要多少个操作数都为 true 时,才回去
true,其他意况都回来 false

假诺首个操作数为 false, 第二个操作数就不会再总括了,即:短路总计
<pre><code>
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
print(“Welcome!”)
} else {
print(“ACCESS DENIED”)
}
// prints “ACCESS DENIED”
</code></pre>

Logical OR Operator

逻辑或操作符 (a || b),需要五个操作数都为 false 时,才回来
false,其他情状都回到 true

即便第一个操作数为 true, 第二个操作数就不会再总括了,即:短路总括
<pre><code>
let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
print(“Welcome!”)
} else {
print(“ACCESS DENIED”)
}
// prints “Welcome!”

</code></pre>

组合使用逻辑操作符 Combining Logical Operators

可以应用六个逻辑操作符构成一个复合表达式:
<pre><code>
if enteredDoorCode && passedRetinaScan || hasDoorKey ||
knowsOverridePassword {
print(“Welcome!”)
} else {
print(“ACCESS DENIED”)
}
// prints “Welcome!”
</code></pre>

该例将七个逻辑操作符(&&||)组合使用。但是,因为(&&
||)都是二元操作符,所以这边实在是两个小的发表式链在一块,解读:

假使输入了无可非议的进门编码并且经过了视网膜扫描,或者有门钥匙,或者精通紧急一级密码,都足以访问。

注:Swift(Swift) 的逻辑操作符 &&||
都是左关联,即四个逻辑操作符组成复合表明式时,先导从左边先河总结子表明式的值

突显采取括号 Explicit Parentheses

在逻辑表达式中加进括号,虽然不是严谨需要时,也会推动扩展代码到可读性。在上例中采用括号,如下:
<pre><code>
if (enteredDoorCode && passedRetinaScan) || hasDoorKey ||
knowsOverridePassword {
print(“Welcome!”)
} else {
print(“ACCESS DENIED”)
}
// prints “Welcome!”
</code></pre>

就会使逻辑语句变得关系清晰,易于阅读,并且不更改表达式的结果

参考:The Swift Programming
Language

相关文章