iOS开发-Swift4译文Swift4官方文档中文版/ Basic Operators(上)（转载）

原文链接：http://blog.csdn.net/feng2qing/article/details/73864580

该文章翻译自Apple官方文档: The Swift 4 Programming
Language

Guards翻译组 正在翻译Swift 4的全套文档, 这是该文档第二章节《Basic Operators》的上半部分, 第一章节《The Basics》 上半部分请点这里/下半部分请点这里,
原文链接: Basic Operators

翻译 : Stevin三天三夜 (Blog / GitHub)

校对 : Jonhory (简书 / GitHub)

译者心声

我们会不定期的更新翻译文章, Guards翻译组本周内会发布 Basic
Operators下半部分 章节中文版. 如感兴趣,可以关注<我们的简书，获取翻译组更多文章>

我们是一群热爱翻译并且热爱 swift 的人，
希望通过自己的努力让不熟悉英语的程序员也能学习到国外的高质量的文章. 如发现文章中翻译错误之处, 烦请跟我们联系, 我们第一时间更正.

想成为我们中一员? 是的, 我们正在招募对翻译感兴趣的小伙伴, 如果你想提高阅读英语文档的水平, 如果你不甘寂寞, 如果你想为广大开发者做点事. QQ:835087646

本篇包含内容：

基本运算符
术语
赋值运算符
算数运算符
求余运算符
一元减号运算符
一元加号操作符
复合赋值运算符
比较运算符
三元条件运算

基本运算符

运算符是检查，改变或合并值的特殊符号和短语。比如：加号（

+

）是将两个数相加，如 

let i = 1 + 2

,和逻辑

AND

元运算符（

&&

）结合两两个布尔值，比如：

if
enteredDoorCode && passedRetinaScan

。

Swift支持多数标准 C 操作符，并且为了消除常见的编码错误改进了几种特性。例如：赋值运算符（

=

）没有返回值。防止当使用判等运算符（

==

）的地方错误地使用它。算术运算符（

+

，

-

，

*

，

%

等）检测不允许值溢出，来避免保存变量的时候变量取值范围大于或小于其取值范围导致的异常结果。你也可以使用Swift的溢出运算符实现溢出，详见Overflow
Operators。

Swift还提供了 C 没有的区间运算符，比如：

a..<b

和

a...b

,快捷地表达了区间内的数值。

本章描述了Swift常见的运算符，Advanced
Operators这章涵盖了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
2
3
4
1
2
3
4

如果赋值的右边是一个多元组，那它的元素被分成多个常量或变量：

let (x, y) = (1, 2)
// 此时 x 等于 1，y 等于 2

1
2
1
2

Swift的赋值操作符不同于 C 和 Objective-C, 它没有返回值，所以下面的代码是错误的：

if x = y {
// 这是错误的，因为x = y没有返回值
}

1
2
3
1
2
3

这个特性能够防止你使用（

==

）的时候而错误的写成（

=

），因为

if
x = y

是无效的，Swift能够帮助你避免这种类型错误的发生。

算数运算符

Swift支持所有数值类型的常见四则运算
加法（

+

）
减法（

-

）
乘法（

*

）
除法（

/

）

1 + 2           // 等于3
5 - 3           // 等于2
2 * 3           // 等于6
10.0 / 2.5      //等于4.0

1
2
3
4
1
2
3
4

Swift的算数运算符不同于 C 和 objective-c 的是默认情况下不允许溢出。你可以使用Swift的溢出运算符进行溢出运算（如：

a
&+ b

）,详见Overflow
Operators.

加法运算符也支持

String

的拼接

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

1
1

求余运算符

求余运算符（

a % b

）计算出

b

的多少倍恰好合适

a

并且返回剩余的值（称作余数）

NOTE：

在其他语言中求余运算符也叫做取模运算符，然而严格的来说在Swift中它对负数的操作行为，它是一个余数而非取模。

求余计算的方式，计算

9 % 4

，你先计算出多少个

4

恰好适合

9

：



两个

4

恰好适合

9

，余数是

1

（橙色部分显示）

在Swift中表达为：

9 % 4       // 等于1

1
1

为了得到

a % b

的答案，

%

运算符计算了以下等式并且返回余数作为结果：

a = (b * 倍数) + 余数

1
1

当倍数取到最大值的时候乘上

b

就恰好适合

a

把

9

和

4

放入等式中

9 = (4 * 2) + 1

1
1

相同的方法，可以计算负数

-9 % 4      // 等于-1

1
1

把

-9

和

4

放入等式可以得到

-9 = （4 * -2） + -1

1
1

余数是

-1

 

对于负数

b

求余的时候，

b

的符号会被忽略，意味着

a
% b

和

a % -b

结果是一样的。

一元减号运算符

数值的符号可以切换使用前缀

-

，称为一元减号运算符

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

1
2
3
1
2
3

一元减号（

-

）直接在操作数之前，中间没有任何空格

一元加号操作符

一元加号操作符（

+

）只是简单地返回了操作数的值，没有做任何改变

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

1
2
1
2

尽管一元加号操作符实际上没有做任何事情，但当你使用一元减号操作符的时候可以使用它来为提供代码提供对称性。

复合赋值运算符

想C一样，Swift也提供把赋值运算符（

=

）和其他运算符结合起来的复合赋值运算符，比如说其中的*加法赋值运 

算符*（

+=

）

var a = 1
a += 2
a 现在等于 3

1
2
3
1
2
3

表达式

a += 2

是 

a = a + 2

的简写，有限地将加法和赋值合成一个运算符同时执行两项任务

NOTE 

复合赋值运算符没有返回值，比如说你不能这样写：let b = a += 2

对了,Swift提供的标准库提供的复合赋值操作符完整列表，详见Swift Standard Library Operators Reference。

比较运算符

Swift支持所有标准 C 语言中的比较运算符
等于（

a == b

）
不等于（

a != b

）
大于（

a > b

）
小于（

a < b

）
大于等于（

a >= b

）
小于等于（

a <= b

）

NOTE 

Swift也提供了恒等（

===

）和不恒等（

!==

）两个比较符用于测试两个对象是否引用同一个对象的实例，更多信息详见Classes
and Structures.

每个比较运算符都返回了一个布尔值来标识语句是否为真

1 == 1      //为真，因为1等于1
2 != 1      //为真，因为2不等于1
2 > 1       //为真，因为2大于1
1 < 2       //为真，因为1小于2
1 >= 1      //为真，因为1大于或小于1
2 <= 1      //为假，2并不小于或等于1

1
2
3
4
5
6
1
2
3
4
5
6

比较运算符经常用于条件语句，比如

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”

1
2
3
4
5
6
7
1
2
3
4
5
6
7

更多短语

if

语句，详见Control
Flow 

只要元组中的每个值都相同，你也可以比较相同数量值的元祖。比如：

Int

和

String

都可以比较,这意味着类型

（Int,String）

类型的元组可以比较，相反，布尔值不能比较，这意味着包含布尔值的元祖不能比较。 

元组的比较从左到右，每次比较一个值，直到比较发现两个值不相等，比较完这两个值，比较的结果决定了元组比较的总体结果，如果每个元素都相等，那么元组本身也相等，比如：

(1, "zebra") < (2, "apple")   //为真，因为1小于2;“zebra”和“apple”不比较
(3, "apple") < (3, "bird")    //为真，因为3等于3;“apple”小于“bird”
(4, "dog") == (4, "dog")      //为真, 因为4等于4;"dog"等于"dog"

1
2
3
1
2
3

在上面的示例中，第一行左右比较的行为，因为

1

小于

2

，就决定

(1,
"zebra")

小于

(2, "apple")

，而不去考虑元组中的其它值，

”zebra“

不小于

”apple“

并不重要，因为元祖的第一个元素已经决定了比较结果，然而，当元组的第一个元素相同的时候，就像第二行和第三行一样，比较他们的第二个元素。

NOTE 

Swift标准库包含了少于7个元素的元组比较运算符，七个或更多元素的元祖比较时，你必须自己实现比较运算。

三元条件运算

三元条件运算符的特殊性在于它有三部分操作数，像：

问题

 ？ 

答案1

 : 

答案2

，这个基于

问题

真或假决定两个表达式中选出一个的简洁操作。如果

问题

为真，则返回值为

答案1

,否则，返回值为

答案2

. 

三元条件操作符简短地描述了下面的代码

if question {
answer1
} else {
answer2
}

1
2
3
4
5
1
2
3
4
5

这有一个计算表行高的例子，如果有表头，行高应该高于内容50像素，如果没有表头，高于内容20像素。

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// 行高等于90

1
2
3
4
1
2
3
4

前面的例子要比下面的代码简洁

let contentHeight = 40
let hasHeader = true
let rowHeight: Int
if hasHeader {
rowHeight = contentHeight + 50
} else {
rowHeight = contentHeight + 20
}
// 行高等于90

1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9

第一个例子使用了三元条件运算符一行代码就能算出

rowHeight

,这比第二个例子的代码更简洁。 

三元条件运算符为需要考虑的两个表达式提供了高效的简写，然而，使用三元条件运算符也需要谨慎。过度使用会导致简洁的代码变的很难读懂。避开的一个组合语句中使用多个三元条件运算符的情况。