发布于 2015-06-14 01:45:50 | 136 次阅读 | 评论: 0 | 来源: 网络整理
后缀表达式就是在某个表达式的后面加上 操作符。 严格的讲，每个主要表达式(primary expression)都是一个后缀表达式
Swift 标准库提供了下列后缀表达式：
对于这些操作符的使用，请参见： Basic Operators and Advanced Operators
后置表达式语法
后置表达式 → 主表达式
后置表达式 → 后置表达式 后置运算符
后置表达式 → 函数调用表达式
后置表达式 → 构造器表达式
后置表达式 → 显示成员表达式
后置表达式 → 后置self表达式
后置表达式 → 动态类型表达式
后置表达式 → 下标表达式
后置表达式 → 强制取值(Forced Value)表达式
后置表达式 → 可选链(Optional Chaining)表达式
函数调用表达式由函数名和参数列表组成。它的形式如下：
function name(argument value 1,argument value 2)
The function name can be any expression whose value is of a function type. (不用翻译了, 太罗嗦)
如果该function 的声明中指定了参数的名字，那么在调用的时候也必须得写出来. 例如：
function name(argument name 1:argument value 1,argument name 2:argument value 2)
可以在 函数调用表达式的尾部(最后一个参数之后)加上 一个闭包(closure) ， 该闭包会被目标函数理解并执行。它具有如下两种写法：
// someFunction takes an integer and a closure as its arguments
someFunction(x, {$0 == 13})
someFunction(x) {$0 == 13}
如果闭包是该函数的唯一参数，那么圆括号可以省略。
// someFunction takes a closure as its only argument
myData.someMethod() {$0 == 13}
myData.someMethod {$0 == 13}
函数调用表达式语法
函数调用表达式 → 后置表达式 圆括号表达式
函数调用表达式 → 后置表达式 圆括号表达式 可选 后置闭包(Trailing Closure)
后置闭包(Trailing Closure) → 闭包表达式
Initializer表达式用来给某个Type初始化。 它的形式如下：
expression.init(initializer arguments)
(Initializer表达式用来给某个Type初始化。) 跟函数(function)不同， initializer 不能返回值。
var x = SomeClass.someClassFunction // ok
var y = SomeClass.init // error
可以通过 initializer 表达式来委托调用(delegate to )到superclass的initializers.
class SomeSubClass: SomeSuperClass {
init() {
// subclass initialization goes here
super.init()
}
}
构造器表达式语法
构造器表达式 → 后置表达式 . init
显示成员表达式允许我们访问type, tuple, module的成员变量。它的形式如下：
expression.member name
该member 就是某个type在声明时候所定义(declaration or extension) 的变量, 例如：
class SomeClass {
var someProperty = 42
}
let c = SomeClass()
let y = c.someProperty // Member access
对于tuple, 要根据它们出现的顺序(0, 1, 2...)来使用:
var t = (10, 20, 30)
t.0 = t.1
// Now t is (20, 20, 30)
The members of a module access the top-level declarations of that module. (不确定：对于某个module的member的调用，只能调用在top-level声明中的member.)
显式成员表达式语法
显示成员表达式 → 后置表达式 . 十进制数字
显示成员表达式 → 后置表达式 . 标识符 泛型参数子句 可选
后缀表达式由 某个表达式 + '.self' 组成. 形式如下：
expression.self
type.self
形式1 表示会返回 expression 的值。例如： x.self 返回 x
形式2：返回对应的type。我们可以用它来动态的获取某个instance的type。
后置Self 表达式语法
后置self表达式 → 后置表达式 . self
(因为dynamicType是一个独有的方法，所以这里保留了英文单词，未作翻译, --- 类似与self expression)
dynamicType 表达式由 某个表达式 + '.dynamicType' 组成。
expression.dynamicType
上面的形式中， expression 不能是某type的名字(当然了，如果我都知道它的名字了还需要动态来获取它吗)。动态类型表达式会返回"运行时"某个instance的type, 具体请看下面的列子：
class SomeBaseClass {
class func printClassName() {
println("SomeBaseClass")
}
}
class SomeSubClass: SomeBaseClass {
override class func printClassName() {
println("SomeSubClass")
}
}
let someInstance: SomeBaseClass = SomeSubClass()
// someInstance is of type SomeBaseClass at compile time, but
// someInstance is of type SomeSubClass at runtime
someInstance.dynamicType.printClassName()
// prints "SomeSubClass"
动态类型表达式语法
动态类型表达式 → 后置表达式 . dynamicType
下标脚本表达式提供了通过下标脚本访问getter/setter 的方法。它的形式是：
expression[index expressions]
可以通过下标脚本表达式通过getter获取某个值，或者通过setter赋予某个值.
关于subscript的声明，请参见： Protocol Subscript Declaration.
强制取值表达式用来获取某个目标表达式的值(该目标表达式的值必须不是nil )。它的形式如下：
expression!
如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误(runtime error)。
强制取值(Forced Value)语法
强制取值(Forced Value)表达式 → 后置表达式 !
可选链表达式由目标表达式 + '?' 组成，形式如下：
expression?
后缀'?' 返回目标表达式的值，把它做为可选的参数传递给后续的表达式
如 果某个后缀表达式包含了可选链表达式，那么它的执行过程就比较特殊： 首先先判断该可选链表达式的值，如果是 nil, 整个后缀表达式都返回 nil, 如果该可选链的值不是nil, 则正常返回该后缀表达式的值(依次执行它的各个子表达式)。在这两种情况下，该后缀表达式仍然是一个optional type(In either case, the value of the postfix expression is still of an optional type)
如果某个"后缀表达式"的"子表达式"中包含了"可选链表达式"，那么只有最外层的表达式返回的才是一个 optional type. 例如，在下面的例子中， 如果c 不是nil, 那么 c?.property.performAction() 这句代码在执行时，就会先获得c 的property方法，然后调用 performAction()方法。 然后对于 "c?.property.performAction()" 这个整体，它的返回值是一个optional type.
var c: SomeClass?
var result: Bool? = c?.property.performAction()
如果不使用可选链表达式，那么 上面例子的代码跟下面例子等价：
if let unwrappedC = c {
result = unwrappedC.property.performAction()
}
可选链表达式语法
可选链表达式 → 后置表达式 ?