后缀表达式(Postfix Expressions)

后缀表达式就是在某个表达式的后面加上 操作符。 严格的讲，每个主要表达式(primary expression)都是一个后缀表达式

Swift 标准库提供了下列后缀表达式：

• ++ Increment
• -- Decrement

对于这些操作符的使用，请参见： Basic Operators and Advanced Operators

后置表达式语法
后置表达式 → 主表达式
后置表达式 → 后置表达式 后置运算符
后置表达式 → 函数调用表达式
后置表达式 → 构造器表达式
后置表达式 → 显示成员表达式
后置表达式 → 后置self表达式
后置表达式 → 动态类型表达式
后置表达式 → 下标表达式
后置表达式 → 强制取值(Forced Value)表达式
后置表达式 → 可选链(Optional Chaining)表达式
 

函数调用表达式(Function Call Expression)

函数调用表达式由函数名和参数列表组成。它的形式如下：

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 Expression)

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
 

显式成员表达式(Explicit Member Expression)

显示成员表达式允许我们访问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表达式(Postfix Self Expression)

后缀表达式由 某个表达式 + '.self' 组成. 形式如下：

expression.self
type.self

形式1 表示会返回 expression 的值。例如： x.self 返回 x

形式2：返回对应的type。我们可以用它来动态的获取某个instance的type。

后置Self 表达式语法
后置self表达式 → 后置表达式 . self
 

dynamic表达式(Dynamic Type Expression)

(因为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
 

下标脚本表达式(Subscript Expression)

下标脚本表达式提供了通过下标脚本访问getter/setter 的方法。它的形式是：

expression[index expressions]

可以通过下标脚本表达式通过getter获取某个值，或者通过setter赋予某个值.

关于subscript的声明，请参见： Protocol Subscript Declaration.

附属脚本表达式语法
附属脚本表达式 → 后置表达式 [ 表达式列表 ]
 

强制取值表达式(Forced-Value Expression)

强制取值表达式用来获取某个目标表达式的值(该目标表达式的值必须不是nil )。它的形式如下：

expression!

如果该表达式的值不是nil, 则返回对应的值。 否则，抛出运行时错误(runtime error)。

强制取值(Forced Value)语法
强制取值(Forced Value)表达式 → 后置表达式 !
 

可选链表达式(Optional-Chaining Expression)

可选链表达式由目标表达式 + '?' 组成，形式如下：

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()
}

可选链表达式语法
可选链表达式 → 后置表达式 ?