表达式
Swift 中存在四种表达式:前缀表达式,二元表达式,基本表达式和后缀表达式。表达式在返回一个值的同时还可以引发副作用。
通过前缀表达式和二元表达式可以对简单表达式使用各种运算符。基本表达式从概念上讲是最简单的一种表达式,它是一种访问值的方式。后缀表达式则允许你建立复杂的表达式,例如函数调用和成员访问。每种表达式都在下面有详细论述。
表达式语法

expression

expression-list

表达式列表表达式 | 表达式 , 表达式列表

前缀表达式

前缀表达式由可选的前缀运算符和表达式组成。前缀运算符只接收一个参数,表达式则紧随其后。
关于这些运算符的更多信息,请参阅 基本运算符高级运算符
关于 Swift 标准库提供的运算符的更多信息,请参阅 Operators Declarations
除了标准库运算符,你也可以对某个变量使用 & 运算符,从而将其传递给函数的输入输出参数。更多信息,请参阅 输入输出参数
前缀表达式语法

prefix-expression

前缀表达式前缀运算符可选 后缀表达式
前缀表达式输入输出表达式

输入输出表达式

输入输出表达式 将函数调用表达式传入的变量标记为输入输出实参。
&表达式
更多关于输入输出形参的信息和例子,请参阅 输入输出形参
输入输出表达式也可以用于将非指针实参传入到需要指针的上下文中,如 指针类型的隐式转换 中所述。

in-out-expression

输入输出表达式& 标识符

Try 运算符

try 表达式try 运算符加上紧随其后的可抛出错误的表达式组成,形式如下:
try 表达式
try 表达式的返回值是该表达式的值。
可选 try 表达式try? 运算符加上紧随其后的可抛出错误的表达式组成,形式如下:
try? 表达式
如果表达式没有抛出错误,可选 try 表达式的返回值是可选的该表达式的值,否则,返回值为 nil
强制 try 表达式try! 运算符加上紧随其后的可抛出错误的表达式组成,形式如下:
try! 表达式
强制 try 表达式的返回值是该表达式的值。如果该表达式抛出了错误,将会引发运行时错误。
在二元运算符左侧的表达式被标记上 trytry? 或者 try! 时,这个运算符对整个二元表达式都产生作用。也就是说,你可以使用括号来明确运算符的作用范围。
1
// try 对两个函数调用都产生作用
2
sum = try someThrowingFunction() + anotherThrowingFunction()
3
4
// try 对两个函数调用都产生作用
5
sum = try (someThrowingFunction() + anotherThrowingFunction())
6
7
// 错误:try 只对第一个函数调用产生作用
8
sum = (try someThrowingFunction()) + anotherThrowingFunction()
Copied!
try 表达式不能出现在二元运算符的的右侧,除非二元运算符是赋值运算符或者 try 表达式是被圆括号括起来的。
如果表达式中同时包含 tryawait 运算符,try 运算符必须在前面。
更多关于 trytry?try! 的信息,以及该如何使用的例子,请参阅 错误处理
Try 表达式语法

try-operator

try 运算符try | try? | try!

Await 运算符

await 表达式await 运算符加上紧随其后的异步操作结果的表达式。形式如下:
await 表达式
await 表达式返回值就是该表达式的值。
await 标记的表达式被称为潜在的暂停点
异步函数的执行可以在每个标记 await 的表达式的位置暂停。除此之外,并发代码的执行永远不会在其他位置暂停。这意味着在潜在暂停点之间的代码可以暂时打破不变量的状态进行安全更新,只要更新在下一个潜在暂停点之前完成。
await 表达式只能在异步的上下文中出现,比如传入 async(priority:operation:) 函数的尾随闭包中。它不能在 defer 语句的闭包中,或者在同步函数的自动闭包中出现。
在二元运算符左侧的表达式被标记上 await 运算符时,这个运算符对整个二元表达式都产生作用。也就是说,你可以使用括号来明确运算符的作用范围。
1
// await 对两个函数调用都产生作用
2
sum = await someAsyncFunction() + anotherAsyncFunction()
3
4
// await 对两个函数调用都产生作用
5
sum = await (someAsyncFunction() + anotherAsyncFunction())
6
7
// 错误:await 只对第一个函数调用产生作用
8
sum = (await someAsyncFunction()) + anotherAsyncFunction()
Copied!
await 表达式不能出现在二元运算符的的右侧,除非二元运算符是赋值运算符或者 await 表达式是被圆括号括起来的。
如果表达式中同时包含 tryawait 运算符,try 运算符必须在前面。
Await 表达式语法

await-operator

await 运算符await

二元表达式

二元表达式由中缀运算符和左右参数表达式组成。形式如下:
左侧参数 二元运算符 右侧参数
关于这些运算符的更多信息,请参阅 基本运算符高级运算符
关于 Swift 标准库提供的运算符的更多信息,请参阅 Swift Standard Library Operators Reference
注意
在解析时,一个二元表达式将作为一个扁平列表表示,然后根据运算符的优先级,再进一步进行组合。例如,2 + 3 * 5 首先被看作具有五个元素的列表,即 2+3*5,随后根据运算符优先级组合为 (2 + (3 * 5))

binary-expression

二元表达式语法
二元表达式二元运算符 前缀表达式
二元表达式赋值运算符 try 运算符可选 前缀表达式
二元表达式条件运算符 try 运算符可选 前缀表达式
二元表达式类型转换运算符

binary-expressions

二元表达式列表二元表达式 二元表达式列表可选

赋值表达式

赋值表达式会为某个给定的表达式赋值,形式如下;
表达式 =
右边的值会被赋值给左边的表达式。如果左边表达式是一个元组,那么右边必须是一个具有同样元素个数的元组。(嵌套元组也是允许的。)右边的值中的每一部分都会被赋值给左边的表达式中的相应部分。例如:
1
(a, _, (b, c)) = ("test", 9.45, (12, 3))
2
// a 为 "test",b 为 12,c 为 3,9.45 会被忽略
Copied!
赋值运算符不返回任何值。
赋值运算符语法

assignment-operator

赋值运算符=

三元条件运算符

三元条件运算符会根据条件来对两个给定表达式中的一个进行求值,形式如下:
条件 ? 表达式(条件为真则使用) : 表达式(条件为假则使用)
如果条件为真,那么对第一个表达式进行求值并返回结果。否则,对第二个表达式进行求值并返回结果。未使用的表达式不会进行求值。
关于使用三元条件运算符的例子,请参阅 三元条件运算符
三元条件运算符语法

conditional-operator

三元条件运算符? 表达式 :

类型转换运算符

有 4 种类型转换运算符:isasas?as!。它们有如下的形式:
表达式 is 类型
表达式 as 类型
表达式 as? 类型
表达式 as! 类型
is 运算符在运行时检查表达式能否向下转化为指定的类型,如果可以则返回 ture,否则返回 false
as 运算符在编译时执行向上转换和桥接。向上转换可将表达式转换成父类的实例而无需使用任何中间变量。以下表达式是等价的:
1
func f(any: Any) { print("Function for Any") }
2
func f(int: Int) { print("Function for Int") }
3
let x = 10
4
f(x)
5
// 打印“Function for Int”
6
7
let y: Any = x
8
f(y)
9
// 打印“Function for Any”
10
11
f(x as Any)
12
// 打印“Function for Any”
Copied!
桥接可将 Swift 标准库中的类型(例如 String)作为一个与之相关的 Foundation 类型(例如 NSString)来使用,而不需要新建一个实例。关于桥接的更多信息,请参阅 Working with Foundation Types
as? 运算符有条件地执行类型转换,返回目标类型的可选值。在运行时,如果转换成功,返回的可选值将包含转换后的值,否则返回 nil。如果在编译时就能确定转换一定会成功或是失败,则会导致编译报错。
as! 运算符执行强制类型转换,返回目标类型的非可选值。如果转换失败,则会导致运行时错误。表达式 x as! T 效果等同于 (x as? T)!
关于类型转换的更多内容和例子,请参阅 类型转换

type-casting-operator

类型转换运算符语法
类型转换运算符is 类型
类型转换运算符as 类型
类型转换运算符as ? 类型
类型转换运算符as ! 类型

基本表达式

基本表达式是最基本的表达式。它们可以单独使用,也可以跟前缀表达式、二元表达式、后缀表达式组合使用。
基本表达式语法

primary-expression

基本表达式标识符 泛型实参子句可选
基本表达式字面量表达式
基本表达式self 表达式
基本表达式父类表达式
基本表达式闭包表达式
基本表达式圆括号表达式
基本表达式隐式成员表达式
基本表达式通配符表达式
基本表达式选择器表达式
基本表达式key-path字符串表达式

字面量表达式

字面量表达式可由普通字面量(例如字符串或者数字),字典或者数组字面量,或者下面列表中的特殊字面量组成:
字面量
类型
#file
String
所在的文件名及模块
#filePath
String
所在的文件路径
#line
Int
所在的行数
#column
Int
所在的列数
#function
String
所在的声明的名字
#dsohandle
UnsafeRawPointer
所使用的 DSO(动态共享对象)句柄
#file 表达式的值的格式是 module/filefile 是表达式所在的文件名,module 是文件所所在的模块名。#filePath 表达式的字符串值是表达式所在的文件在整个文件系统里的路径。所有这些值可以被 #sourceLocation 改变,详见 行控制语句
注意
要解析 #file 表达式,第一个斜杠(/)之前的文本作为模块名,最后一个斜杠之后的文本作为文件名。将来,该字符串可能包含多个斜杠,例如 MyModule/some/disambiguation/MyFile.swift
对于 #function,在函数中会返回当前函数的名字,在方法中会返回当前方法的名字,在属性的存取器中会返回属性的名字,在特殊的成员如 initsubscript 中会返回这个关键字的名字,在某个文件中会返回当前模块的名字。
当其作为函数或者方法的默认参数值时,该字面量的值取决于函数或方法的调用环境。
1
func logFunctionName(string: String = #function) {
2
print(string)
3
}
4
func myFunction() {
5
logFunctionName()
6
}
7
myFunction() // 打印“myFunction()”
Copied!
数组字面量是值的有序集合,形式如下:
[值 1, 值 2, ...]
数组中的最后一个表达式可以紧跟一个逗号。数组字面量的类型是 [T],这个 T 就是数组中元素的类型。如果数组中包含多种类型,T 则是跟这些类型最近的的公共父类型。空数组字面量由一组方括号定义,可用来创建特定类型的空数组。
1
var emptyArray: [Double] = []
Copied!
字典字面量是一个包含无序键值对的集合,形式如下:
[键 1 : 值 1, 键 2 : 值 2, ...]
字典中的最后一个表达式可以紧跟一个逗号。字典字面量的类型是 [Key : Value]Key 表示键的类型,Value 表示值的类型。如果字典中包含多种类型,那么 Key 表示的类型则为所有键最接近的公共父类型,Value 与之相似。一个空的字典字面量由方括号中加一个冒号组成([:]),从而与空数组字面量区分开,可以使用空字典字面量来创建特定类型的字典。
1
var emptyDictionary: [String : Double] = [:]
Copied!
Xcode 使用 playground 字面量对程序编辑器中的颜色、文件或者图片创建可交互的展示。在 Xcode 之外的空白文本中,playground 字面量使用一种特殊的字面量语法来展示。
更多关于在 Xcode 中使用 playground 字面量的信息,请参阅 添加颜色、文件或图片字面量
字面量表达式语法

literal-expression

字面量表达式字面量
字面量表达式数组字面量 | 字典字面量 | 练习场字面量
字面量表达式#file#filePath | #line | #column | #function

array-literal

数组字面量 → [数组字面量项列表可选 ]

array-literal-items

数组字面量项列表数组字面量项 ,可选 | 数组字面量项 , 数组字面量项列表

array-literal-item

数组字面量项表达式

dictionary-literal

字典字面量 → [字典字面量项列表 ] | [ : ]

dictionary-literal-items

字典字面量项列表字典字面量项 ,可选 | 字典字面量项 , 字典字面量项列表

dictionary-literal-item

字典字面量项表达式 : 表达式

playground-literal

playground 字面量#colorLiteral ( red : 表达式 , green :表达式 [表达式](#e表达式 xpression) , blue :表达式 , alpha : 表达式 )
playground 字面量#fileLiteral ( resourceName : 表达式 )

playground 字面量 → *#imageLiteral ( resourceName : 表达式 )self-expression

Self 表达式

self 表达式是对当前类型或者当前实例的显式引用,它有如下形式:
self
self.成员名称
self[下标索引]
self(构造器参数)
self.init(构造器参数)
如果在构造器、下标、实例方法中,self 引用的是当前类型的实例。在一个类型方法中,self 引用的是当前的类型。
当访问成员时,self 可用来区分重名变量,例如函数的参数:
1
class SomeClass {
2
var greeting: String
3
init(greeting: String) {
4
self.greeting = greeting
5
}
6
}
Copied!
mutating 方法中,你可以对 self 重新赋值:
1
struct Point {
2
var x = 0.0, y = 0.0
3
mutating func moveByX(deltaX: Double, y deltaY: Double) {
4
self = Point(x: x + deltaX, y: y + deltaY)
5
}
6
}
Copied!
Self 表达式语法

self-expression

self-method-expression

self 方法表达式self . 标识符

self-subscript-expression

self 下标表达式self [ 函数调用参数表 ]

self-initializer-expression

self 构造器表达式self . init

父类表达式

父类表达式可以使我们在某个类中访问它的父类,它有如下形式:
super.成员名称
super[下标索引]
super.init(构造器参数)
第一种形式用来访问父类的某个成员,第二种形式用来访问父类的下标,第三种形式用来访问父类的构造器。
子类可以通过父类表达式在它们的成员、下标和构造器中使用父类中的实现。
父类表达式语法

superclass-expression

superclass-method-expression

父类方法表达式super . 标识符

superclass-subscript-expression

父类下标表达式super [函数调用参数表 ]

superclass-initializer-expression

父类构造器表达式super . init

闭包表达式

闭包表达式会创建一个闭包,在其他语言中也叫 lambda匿名函数。跟函数一样,闭包包含了待执行的代码,不同的是闭包还会捕获所在环境中的常量和变量。它的形式如下:
1
{ (parameters) -> return type in
2
statements
3
}
Copied!
闭包的参数声明形式跟函数一样,请参阅 函数声明
闭包还有几种特殊的形式,能让闭包使用起来更加简洁:
  • 闭包可以省略它的参数和返回值的类型。如果省略了参数名和所有的类型,也要省略 in 关键字。如果被省略的类型无法被编译器推断,那么就会导致编译错误。
  • 闭包可以省略参数名,参数会被隐式命名为 $ 加上其索引位置,例如 $0$1$2 分别表示第一个、第二个、第三个参数,以此类推。
  • 如果闭包中只包含一个表达式,那么该表达式的结果就会被视为闭包的返回值。表达式结果的类型也会被推断为闭包的返回类型。
下面几个闭包表达式是等价的:
1
myFunction {
2
(x: Int, y: Int) -> Int in
3
return x + y
4
}
5
6
myFunction {
7
(x, y) in
8
return x + y
9
}
10
11
myFunction { return $0 + $1 }
12
13
myFunction { $0 + $1 }
Copied!
关于如何将闭包作为参数来传递的内容,请参阅 函数调用表达式
使用闭包表达式时,可以不必将其存储在一个变量或常量中,例如作为函数调用的一部分来立即使用一个闭包。在上面的例子中,传入 myFunction 的闭包表达式就是这种立即使用类型的闭包。因此,一个闭包是否逃逸与其使用时的上下文相关。一个会被立即调用或者作为函数的非逃逸参数传递的闭包表达式是非逃逸的,否则,这个闭包表达式是逃逸的。
关于逃逸闭包的内容,请参阅 逃逸闭包

捕获列表

默认情况下,闭包会捕获附近作用域中的常量和变量,并使用强引用指向它们。你可以通过一个捕获列表来显式指定它的捕获行为。
捕获列表在参数列表之前,由中括号括起来,里面是由逗号分隔的一系列表达式。一旦使用了捕获列表,就必须使用 in 关键字,即使省略了参数名、参数类型和返回类型。
捕获列表中的项会在闭包创建时被初始化。每一项都会用闭包附近作用域中的同名常量或者变量的值初始化。例如下面的代码示例中,捕获列表包含 a 而不包含 b,这将导致这两个变量具有不同的行为。
1
var a = 0
2
var b = 0
3
let closure = { [a] in
4
print(a, b)
5
}
6
7
a = 10
8
b = 10
9
closure()
10
// 打印“0 10”
Copied!
在示例中,变量 b 只有一个,然而,变量 a 有两个,一个在闭包外,一个在闭包内。闭包内的变量 a 会在闭包创建时用闭包外的变量 a 的值来初始化,除此之外它们并无其他联系。这意味着在闭包创建后,改变某个 a 的值都不会对另一个 a 的值造成任何影响。与此相反,闭包内外都是同一个变量 b,因此在闭包外改变其值,闭包内的值也会受影响。
如果闭包捕获的值具有引用语义则有所不同。例如,下面示例中,有两个变量 x,一个在闭包外,一个在闭包内,由于它们的值是引用语义,虽然这是两个不同的变量,它们却都引用着同一实例。
1
class SimpleClass {
2
var value: Int = 0
3
}
4
var x = SimpleClass()
5
var y = SimpleClass()
6
let closure = { [x] in
7
print(x.value, y.value)
8
}
9
10
x.value = 10
11
y.value = 10
12
closure()
13
// 打印“10 10”
Copied!
如果捕获列表中的值是类类型,你可以使用 weak 或者 unowned 来修饰它,闭包会分别用弱引用和无主引用来捕获该值。
1
myFunction { print(self.title) } // 隐式强引用捕获
2
myFunction { [self] in print(self.title) } // 显式强引用捕获
3
myFunction { [weak self] in print(self!.title) } // 弱引用捕获
4
myFunction { [unowned self] in print(self.title) } // 无主引用捕获
Copied!
在捕获列表中,也可以将任意表达式的值绑定到一个常量上。该表达式会在闭包被创建时进行求值,闭包会按照指定的引用类型来捕获表达式的值。例如:
1
// 以弱引用捕获 self.parent 并赋值给 parent
2
myFunction { [weak parent = self.parent] in print(parent!.title) }
Copied!
关于闭包表达式的更多信息和例子,请参阅 闭包表达式。关于捕获列表的更多信息和例子,请参阅 解决闭包引起的循环强引用
闭包表达式语法

closure-expression

闭包表达式{ 闭包签名可选 语句 }

closure-signature

闭包签名捕获列表可选 闭包形参子句 throws可选 函数结果可选 in
闭包签名捕获列表 in

closure-parameter-clause

闭包形参子句( )闭包形参列表)|标识符列表

closure-parameter-list

闭包形参列表闭包形参闭包形参 , 闭包形参列表

closure-parameter

闭包形参闭包形参名字 类型注解可选
闭包形参闭包形参名字 类型注解 ...

closure-parameter-name

闭包形参名字标识符

closure-list

捕获列表[ 捕获列表项列表 ]

capture-list-items

捕获列表项列表捕获列表项 | 捕获列表项 , 捕获列表项列表

capture-list-item

捕获列表项捕获说明符可选 标识符
捕获列表项捕获说明符可选 标识符 = 表达式
捕获列表项捕获说明符可选 标识符 Self 表达式

capture-specifier

捕获说明符weak | unowned | unowned(safe) | unowned(unsafe)

隐式成员表达式

若类型可被推断出来,可以使用隐式成员表达式来访问某个类型的成员(例如某个枚举成员或某个类型方法),形式如下:
.成员名称
例如:
1
var x = MyEnumeration.someValue
2
x = .anotherValue
Copied!
如果推断的是可选类型,可以在隐式成员表达式里使用不可选类型的成员。
1
var someOptional: MyEnumeration? = .someValue
Copied!
隐式成员表达式可以跟在后缀运算符或者其他在 后缀表达式 里介绍的语法后面。这被称为 链式隐式成员表达式。尽管链式后缀表达式大多都是相同类型,但其实只需要整个链式成员表达式可以转换为上下文的类型就行了。更具体的,如果隐式类型是可选的,则可以使用非可选类型的值,如果隐式类型是类类型,则可以使用其子类的值。例如:
1
class SomeClass {
2
static var shared = SomeClass()
3
static var sharedSubclass = SomeSubclass()
4
var a = AnotherClass()
5
}
6
class SomeSubclass: SomeClass { }
7
class AnotherClass {
8
static var s = SomeClass()
9
func f() -> SomeClass { return AnotherClass.s }
10
}
11
let x: SomeClass = .shared.a.f()
12
let y: SomeClass? = .shared
13
let z: SomeClass = .sharedSubclass
Copied!
上面的代码中,x 的类型和上下文的隐式类型完全匹配,y 的类型是从 SomeClass 转换成 SomeClass?z 的类型是从 SomeSubclass 转换成 SomeClass
隐式成员表达式语法

implicit-member-expression

隐式成员表达式. 标识符

圆括号表达式

圆括号表达式是由圆括号包围的表达式。你可以用圆括号说明成组的表达式的先后操作。成组的圆括号不会改变表达式的类型 - 例如 (1) 的类型就是简单的 Int
圆括号表达式语法

parenthesized-expression

圆括号表达式( 表达式 )

元组表达式

元组表达式由圆括号和其中多个逗号分隔的子表达式组成。每个子表达式前面可以有一个标识符,用冒号隔开。元组表达式形式如下:
(标识符 1 : 表达式 1, 标识符 2 : 表达式 2, ...)
元组表达式里的每一个标识符在表达式作用域里必须是唯一的。在嵌套的元组表达式中,同嵌套层级里的标识符也必须是唯一的。例如,(a: 10, a: 20) 是不合法的,因为标签 a 在同一层级出现了两次。然而,(a: 10, b: (a: 1, x: 2)) 是合法的,尽管 a 出现了两次,但有一次在外层元组里,一次在内层元组里。
元组表达式可以一个表达式都没有,也可以包含两个或是更多的表达式。单个表达式用括号括起来就是括号表达式了。
注意
在 Swift 中,空的元组表达式和空的元组类型都写作 ()。由于 Void() 的类型别名,因此可以使用它来表示空的元组类型。虽然如此,Void 就像所有的类型别名一样,永远是一个类型——不能表示空的元组表达式。
元组表达式语法

tuple-expression

元组表达式( ) | (元组元素元组元素列表 )

tuple-element-list

元组元素列表元组元素 | 元组元素 , 元组元素列表

tuple-element

元组元素表达式 | 标识符 : 表达式

通配符表达式

通配符表达式可以在赋值过程中显式忽略某个值。例如下面的代码中,10 被赋值给 x,而 20 则被忽略:
1
(x, _) = (10, 20)
2
// x 为 10,20 被忽略
Copied!
通配符表达式语法

wildcard-expression

通配符表达式_

Key-path 表达式

Key-path 表达式引用一个类型的属性或下标。在动态语言中使场景可以使用 Key-path 表达式,例如观察键值对。格式为:
\类型名.路径
类型名是一个具体类型的名称,包含任何泛型参数,例如 String[Int]Set<Int>
路径可由属性名称、下标、可选链表达式或者强制解包表达式组成。以上任意 key-path 组件可以以任何顺序重复多次。
在编译期,key-path 表达式会被一个 KeyPath 类的实例替换。
对于所有类型,都可以通过传递 key-path 参数到下标方法 subscript(keyPath:) 来访问它的值。例如:
1
struct SomeStructure {
2
var someValue: Int
3
}
4
5
let s = SomeStructure(someValue: 12)
6
let pathToProperty = \SomeStructure.someValue
7
8
let value = s[keyPath: pathToProperty]
9
// 值为 12
Copied!
在一些可以通过类型推断来确定所访问的具体类型的上下文中,可以省略 key-path 前的类型名字。下面的代码使用 \.someProperty 代替了 SomeClass.someProperty
1
class SomeClass: NSObject {
2
@objc dynamic var someProperty: Int
3
init(someProperty: Int) {
4
self.someProperty = someProperty
5
}
6
}
7
8
let c = SomeClass(someProperty: 10)
9
c.observe(\.someProperty) { object, change in
10
// ...
11
}
Copied!
使用 self 作为路径可以创建一个恒等 key path (\.self)。恒等 key path 可以作为整个实例的引用,因此你仅需一步操作便可以利用它来访问以及修改其存储的所有数据。例如:
1
var compoundValue = (a: 1, b: 2)
2
// 等价于 compoundValue = (a: 10, b: 20)
3
compoundValue[keyPath: \.self] = (a: 10, b: 20)
Copied!
通过点语法,可以让路径包含多个属性名称,以此来访问某实例的属性的属性。下面的代码使用 key-path 表达式 \OuterStructure.outer.someValue 来访问 OuterStructure 类型中 outer 属性的 someValue 属性。
1
struct OuterStructure {
2
var outer: SomeStructure
3
init(someValue: Int) {
4
self.outer = SomeStructure(someValue: someValue)
5
}
6
}
7
8
let nested = OuterStructure(someValue: 24)
9
let nestedKeyPath = \OuterStructure.outer.someValue
10
11
let nestedValue = nested[keyPath: nestedKeyPath]
12
// nestedValue 的值为 24
Copied!
路径中也可以包含使用中括号的下标访问,只要下标访问的参数类型满足 Hashable 协议即可。下面的例子在 key path 中使用了下标来访问数组的第二个元素。
1
let greetings = ["hello", "hola", "bonjour", "안녕"]
2
let myGreeting = greetings[keyPath: \[String].[1]]
3
// myGreeting 的值为 'hola'
Copied!
下标访问中使用的值可以是一个变量或者字面量,并且 key-path 表达式会使用值语义来捕获此值。下面的代码在 key-path 表达式和闭包中都使用了 index 变量来访问 greetings 数组的第三个元素。当 index 被修改时,key-path 表达式仍旧引用数组第三个元素,而闭包则使用了新的索引值。
1
var index = 2
2
let path = \[String].[index]
3
let fn: ([String]) -> String = { strings in strings[index] }
4
5
print(greetings[keyPath: path])
6
// 打印 "bonjour"
7
print(fn(greetings))
8
// 打印 "bonjour"
9
10
// 将 'index' 设置为一个新的值不会影响到 'path'
11
index += 1
12
print(greetings[keyPath: path])
13
// 打印 "bonjour"
14
15
// 'fn' 闭包使用了新值。
16
print(fn(greetings))
17
// 打印 "안녕"
Copied!
路径可以使用可选链和强制解包。下面的代码在 key path 中使用了可选链来访问可选字符串的属性。
1
let firstGreeting: String? = greetings.first
2
print(firstGreeting?.count as Any)
3
// 打印 "Optional(5)"
4
5
// 使用 key path 实现同样的功能
6
let count = greetings[keyPath: \[String].first?.count]
7
print(count as Any)
8
// 打印 "Optional(5)"
Copied!
可以混合使用各种 key path 组件来访问一些深度嵌套类型的值。下面的代码通过组合不同的组件,使用 key-path 表达式访问了一个字典数组中不同的值和属性。
1
let interestingNumbers = ["prime": [2, 3, 5, 7, 11, 13, 17],
2
"triangular": [1, 3, 6, 10, 15, 21, 28],
3
"hexagonal": [1, 6, 15, 28, 45, 66, 91]]
4
print(interestingNumbers[keyPath: \[String: [Int]].["prime"]] as Any)
5
// 打印 "Optional([2, 3, 5, 7, 11, 13, 17])"
6
print(interestingNumbers[keyPath: \[String: [Int]].["prime"]![0]])
7
// 打印 "2"
8
print(interestingNumbers[keyPath: \[String: [Int]].["hexagonal"]!.count])
9
// 打印 "7"
10
print(interestingNumbers[keyPath: \[String: [Int]].["hexagonal"]!.count.bitWidth])
11
// 打印 "64"
Copied!
你可以在平时提供函数或者闭包的上下文里使用 key path 表达式。特别地,你可以用根类型是 SomeType 和路径产生 Value 类型值的 key path 表达式来替换类型是 (SomeType) -> Value 的函数或者闭包。
1
struct Task {
2
var description: String
3
var completed: Bool
4
}
5
var toDoList = [
6
Task(description: "Practice ping-pong.", completed: false),
7
Task(description: "Buy a pirate costume.", completed: true),
8
Task(description: "Visit Boston in the Fall.", completed: false),
9
]
10
11
// 下面两种写法是等价的。
12
let descriptions = toDoList.filter(\.completed).map(\.description)
13
let descriptions2 = toDoList.filter { $0.completed }.map { $0.description }
Copied!
任何 key path 表达式的副作用发生的关键在于表达式在哪里被执行。例如,如果你在 key path 表达式中的一个下标里使用函数调用,该函数只会在表达式计算的时候调用一次,而不是每次这个 key path 被使用的时候。
1
func makeIndex() -> Int {
2
print("Made an index")
3
return 0
4
}
5
// 下面这行调用 makeIndex()。
6
let taskKeyPath = \[Task][makeIndex()]
7
// 打印 "Made an index"
8
9
// 使用 taskKeyPath 不会再次调用 makeIndex()。
10
let someTask = toDoList[keyPath: taskKeyPath]
Copied!
关于更多如何使用 key path 与 Objective-C APIs 交互的信息,请参阅 在 Swift 中使用 Objective-C 运行时特性。关于更多 key-value 编程和 key-value 观察的信息,请参阅 Key-Value 编程Key-Value 观察编程
key-path 表达式语法

key-path-expression

key-path 表达式\ 类型可选 . 多个 key-path 组件

key-path-components

多个 key-path 组件key-path 组件 | key-path 组件 . 多个 key-path 组件

key-path-component

key-path-postfixes

多个 key-path 后缀key-path 后缀 多个 key-path 后缀可选 key-path-postfixes

key-path 后缀? | ! | self | [ 函数调用参数表 ]

选择器表达式

选择器表达式可以让你通过选择器来引用在 Objective-C 中方法(method)和属性(property)的 setter 和 getter 方法。
#selector(方法名)
#selector(getter: 属性名) #selector(setter: 属性名)
方法名和属性名必须是存在于 Objective-C 运行时中的方法和属性的引用。选择器表达式的返回值是一个 Selector 类型的实例。例如:
1
class SomeClass: NSObject {
2
let property: String
3
@objc(doSomethingWithInt:)
4
func doSomething(_ x: Int) { }
5
6
init(property: String) {
7
self.property = property
8
}
9
}
10
let selectorForMethod = #selector(SomeClass.doSomething(-:))
11
let selectorForPropertyGetter = #selector(getter: SomeClass.property)
Copied!
当为属性的 getter 创建选择器时,属性名可以是变量属性或者常量属性的引用。但是当为属性的 setter 创建选择器时,属性名只可以是对变量属性的引用。
方法名称可以包含圆括号来进行分组,并使用 as 操作符来区分具有相同方法名但类型不同的方法,例如:
1
extension SomeClass {
2
@objc(doSomethingWithString:)
3
func doSomething(_ x: String) { }
4
}
5
let anotherSelector = #selector(SomeClass.doSomething(-:) as (SomeClass) -> (String) -> Void)
Copied!
由于选择器是在编译时创建的,因此编译器可以检查方法或者属性是否存在,以及是否在运行时暴露给了 Objective-C 。
注意
虽然方法名或者属性名是个表达式,但是它不会被求值。
更多关于如何在 Swift 代码中使用选择器来与 Objective-C API 进行交互的信息,请参阅 在 Swift 中使用 Objective-C 运行时特性
选择器表达式语法

selector-expression

选择器表达式 → __#selector-- ( 表达式 )
选择器表达式 → __#selector-- ( getter:表达式 )
选择器表达式 → __#selector-- ( setter:表达式 )

Key-path 字符串表达式

key-path 字符串表达式可以访问一个引用 Objective-C 属性的字符串,通常在 key-value 编程和 key-value 观察 APIs 中使用。其格式如下:
#keyPath ( 属性名 )
属性名必须是一个可以在 Objective-C 运行时使用的属性的引用。在编译期,key-path 字符串表达式会被一个字符串字面量替换。例如:
1
class SomeClass: NSObject {
2
@objc var someProperty: Int
3
init(someProperty: Int) {
4
self.someProperty = someProperty
5
}
6
}
7
8
let c = SomeClass(someProperty: 12)
9
let keyPath = #keyPath(SomeClass.someProperty)
10
11
if let value = c.value(forKey: keyPath) {
12
print(value)
13
}
14
// 打印 "12"
Copied!
当在一个类中使用 key-path 字符串表达式时,可以省略类名,直接使用属性名来访问这个类的某个属性。
1
extension SomeClass {
2
func getSomeKeyPath() -> String {
3
>
4
return #keyPath(someProperty)
5
}
6
}
7
print(keyPath == c.getSomeKeyPath())
8
// 打印 "true"
Copied!
由于 key-path 字符串表达式在编译期才创建,编译期可以检查属性是否存在,以及属性是否暴露给 Objective-C 运行时。
关于更多如何使用 key path 与 Objective-C APIs 交互的信息,请参阅 在 Swift 中使用 Objective-C 运行时特性。关于更多 key-value 编程和 key-value 观察的信息,请参阅 Key-Value 编程Key-Value 观察编程
注意
尽管属性名是一个表达式,但它永远不会被求值
key-path 字符串表达式语法

key-path-string-expression

key-path 字符串表达式#keyPath ( 表达式 )

后缀表达式

后缀表达式就是在某个表达式的后面运用后缀运算符或其他后缀语法。从语法构成上来看,基本表达式也是后缀表达式。
关于这些运算符的更多信息,请参阅 基本运算符高级运算符
关于 Swift 标准库提供的运算符的更多信息,请参阅 运算符定义
后缀表达式语法

postfix-expression

后缀表达式基本表达式
后缀表达式后缀表达式 后缀运算符
后缀表达式函数调用表达式
后缀表达式构造器表达式
后缀表达式显式成员表达式
后缀表达式后缀 self 表达式
后缀表达式dynamicType 表达式
后缀表达式下标表达式
后缀表达式强制取值表达式
后缀表达式可选链表达式

函数调用表达式

函数调用表达式由函数名和在括号里以逗号分隔的参数列表组成。函数调用表达式形式如下:
函数名(参数 1, 参数 2)
函数名可以是值为函数类型的任意表达式。
如果函数声明中指定了形参的名字,那么在调用的时候也必须得写出来,并通过冒号(:)分隔。这种函数调用表达式具有以下形式:
函数名(参数名 1: 参数 1, 参数名 2: 参数 2)
函数调用表达式可以在函数调用表达式的尾部(右圆括号之后)加上多个尾随闭包,该闭包会作为函数的实参,在括号中最后一个实参后面添加。第一个闭包表达式时没有实参签名的,其他任意闭包表达式签名都有实参标签。如下两种写法是等价的,区别在是否使用尾随闭包语法:
1
// someFunction 接受整型和闭包的实参
2
someFunction(x, f: {$0 == 13})
3
someFunction(x) {$0 == 13}
4
5
// anotherFunction 接受一个整型和两个闭包的实参
6
anotherFunction(x: x, f: { $0 == 13 }, g: { print(99) })
7
anotherFunction(x: x) { $0 == 13 } g: { print(99) }
Copied!
如果闭包是该函数的唯一实参,那么圆括号可以省略。
1
// someFunction 只接受一个闭包参数
2
myData.someMethod() {$0 == 13}
3
myData.someMethod {$0 == 13}
Copied!
为了支持实参中的尾随闭包,编译器从左到右检查形参列表,如下所示:
尾随闭包
形参
行为
有标签
有标签
如果标签相同,闭包和形参匹配,否则跳过该形参
有标签
无标签
跳过该形参
无标签
有标签或无标签
如果形参在结构上类似于下面定义的函数类型,和闭包匹配,否则跳过该形参
尾随闭包作为其匹配形参的实参传递。
在扫描过程被跳过的形参不传递实参——例如,它们使用的是默认形参。当匹配后,扫描会继续下一个尾随闭包和形参。匹配过程结束后,所有的尾随闭包必须有对应的匹配。
如果形参不是输入输出参数,并且类似下面的情况,则算是结构上类似函数类型:
  • 函数类型的形参,例如 (Bool) -> Int
  • 函数类型表达式的自动闭包形参,例如 @autoclosure () -> ((Bool) -> Int)
  • 元素是函数类型的可变参数,例如 ((Bool) -> Int)...
  • 单层或多层可选类型的形参,例如 Optional<(Bool) -> Int>
  • 由上面这些类型组合而成的形参,例如 (Optional<(Bool) -> Int>)...
尾随闭包和结构上类似函数类型的形参匹配,但它并不是函数,所以闭包会按需包装。例如,如果形参类是是可选类型,闭包会自动包装成 Optional
为了简化 Swift 5.3 之前版本(从右到左匹配)的代码迁移 —— 编译器会同时检查从左到右和从右到左的顺序。如果不同的扫描方向产生了不同的结果,编译器则使用旧的从右到左的顺序,并生成警告。Swift 的未来版本将都使用从左到右的顺序。
1
typealias Callback = (Int) -> Int
2
func someFunction(firstClosure: Callback? = nil,
3
secondClosure: Callback? = nil) {
4
let first = firstClosure?(10)
5
let second = secondClosure?(20)
6
print(first ?? "-", second ?? "-")
7
}
8
9
someFunction() // 打印 "- -"
10
someFunction { return $0 + 100 } // 歧义
11
someFunction { return $0 } secondClosure: { return $0 } // 打印 "10 20"
Copied!
在上面的例子中,Swift 5.3 中被标记为“歧义”的函数调用会打印”- 120“并产生一个编辑器警告。未来版本的 Swift 会打印”110 -“。
特殊名称方法 所述,通过声明几种方法中的一种,类、结构体或枚举类型可以为函数调用语法启用语法糖。

指针类型的隐式转换

在函数调用表达式里,如果实参和形参的类型不一致,编译器会尝试通过下面的规则进行隐式转换来匹配类型:
  • 输入输出的 SomeType 可以转换为 UnsafePointer<SomeType> 或者 UnsafeMutablePointer<SomeType>
  • 输入输出的 Array<SomeType> 可以转换为 UnsafePointer<SomeType> 或者 UnsafeMutablePointer<SomeType>
  • Array<SomeType> 可以转换为 UnsafePointer<SomeType>
  • String 可以转换为 UnsafePointer<CChar>
下面两个函数调用是等价的:
1
func unsafeFunction(pointer: UnsafePointer<Int>) {
2
// ...
3
}
4
var myNumber = 1234
5
6
unsafeFunction(pointer: &myNumber)
7
withUnsafePointer(to: myNumber) { unsafeFunction(pointer: $0) }
Copied!
隐式转换创建的指针仅在函数调用期间有效。为了避免发生未定义行为,确保代码在函数调用结束后没有继续持有这些指针。
注意