Swift主表达式

发布于 2015-06-14 01:51:20 | 82 次阅读 | 评论: 0 | 来源: 网络整理

主表达式(Primary Expressions)

主表达式是最基本的表达式。 它们可以跟 前缀表达式，二元表达式，后缀表达式以及其他主要表达式组合使用。

主表达式语法
主表达式 → 标识符 泛型参数子句 可选
主表达式 → 字面量表达式
主表达式 → self表达式
主表达式 → 超类表达式
主表达式 → 闭包表达式
主表达式 → 圆括号表达式
主表达式 → 隐式成员表达式
主表达式 → 通配符表达式
 

字符型表达式(Literal Expression)

由这些内容组成：普通的字符(string, number) , 一个字符的字典或者数组，或者下面列表中的特殊字符。

在某个函数(function)中，__FUNCTION__ 会 返回当前函数的名字。 在某个方法(method)中，它会返回当前方法的名字。 在某个property 的getter/setter中会返回这个属性的名字。 在init/subscript中 只有的特殊成员(member)中会返回这个keyword的名字，在某个文件的顶端(the top level of a file)，它返回的是当前module的名字。

一个array literal，是一个有序的值的集合。 它的形式是：

[value 1, value 2, ...]

数 组中的最后一个表达式可以紧跟一个逗号(','). []表示空数组 。 array literal的type是 T[], 这个T就是数组中元素的type. 如果该数组中有多种type, T则是跟这些type的公共supertype最接近的type.(closest common supertype)

一个dictionary literal 是一个包含无序的键值对(key-value pairs)的集合，它的形式是:

[key 1: value 1, key 2: value 2, ...]

dictionary 的最后一个表达式可以是一个逗号(','). [:] 表示一个空的dictionary. 它的type是 Dictionary (这里KeyType表示 key的type, ValueType表示 value的type) 如果这个dictionary 中包含多种 types, 那么KeyType, Value 则对应着它们的公共supertype最接近的type( closest common supertype).

字面量表达式语法
字面量表达式 → 字面量
字面量表达式 → 数组字面量 | 字典字面量
字面量表达式 → __FILE__ | __LINE__ | __COLUMN__ | __FUNCTION__
数组字面量 → [ 数组字面量项列表 可选 ]
数组字面量项列表 → 数组字面量项 , 可选 | 数组字面量项 , 数组字面量项列表
数组字面量项 → 表达式
字典字面量 → [ 字典字面量项列表 ] | [ : ]
字典字面量项列表 → 字典字面量项 , 可选 | 字典字面量项 , 字典字面量项列表
字典字面量项 → 表达式 : 表达式
 

self表达式(Self Expression)

self表达式是对 当前type 或者当前instance的引用。它的形式如下：

self
self.member name
self[subscript index]
self(initializer arguments)
self.init(initializer arguments)

如果在 initializer, subscript, instance method中，self等同于当前type的instance. 在一个静态方法(static method), 类方法(class method)中， self等同于当前的type.

当访问 member(成员变量时)， self 用来区分重名变量(例如函数的参数). 例如， (下面的 self.greeting 指的是 var greeting: String, 而不是 init(greeting: String) )

class SomeClass {
    var greeting: String
    init(greeting: String) {
        self.greeting = greeting
    }
}

在mutating 方法中， 你可以使用self 对 该instance进行赋值。

struct Point {
    var x = 0.0, y = 0.0
    mutating func moveByX(deltaX: Double, y deltaY: Double) {
        self = Point(x: x + deltaX, y: y + deltaY)
    }
}

Self 表达式语法
self表达式 → self
self表达式 → self . 标识符
self表达式 → self [ 表达式 ]
self表达式 → self . init

超类表达式(Superclass Expression)

超类表达式可以使我们在某个class中访问它的超类. 它有如下形式：

super.member name
super[subscript index]
super.init(initializer arguments)

形式1 用来访问超类的某个成员(member). 形式2 用来访问该超类的 subscript 实现。 形式3 用来访问该超类的 initializer.

子类(subclass)可以通过超类(superclass)表达式在它们的 member, subscripting 和 initializers 中来利用它们超类中的某些实现(既有的方法或者逻辑)。

超类(superclass)表达式语法
超类表达式 → 超类方法表达式 | 超类下标表达式 | 超类构造器表达式
超类方法表达式 → super . 标识符
超类下标表达式 → super [ 表达式 ]
超类构造器表达式 → super . init
 

闭包表达式(Closure Expression)

闭 包(closure) 表达式可以建立一个闭包(在其他语言中也叫 lambda, 或者 匿名函数(anonymous function)). 跟函数(function)的声明一样， 闭包(closure)包含了可执行的代码(跟方法主体(statement)类似) 以及接收(capture)的参数。 它的形式如下：

{ (parameters) -> return type in
    statements
}

闭包的参数声明形式跟方法中的声明一样, 请参见：Function Declaration.

闭包还有几种特殊的形式, 让使用更加简洁：

• 闭包可以省略 它的参数的type 和返回值的type. 如果省略了参数和参数类型，就也要省略 'in'关键字。 如果被省略的type 无法被编译器获知(inferred) ，那么就会抛出编译错误。
• 闭包可以省略参数，转而在方法体(statement)中使用 0,1, $2 来引用出现的第一个，第二个，第三个参数。
• 如果闭包中只包含了一个表达式，那么该表达式就会自动成为该闭包的返回值。 在执行 'type inference '时，该表达式也会返回。

下面几个 闭包表达式是 等价的：

myFunction {
    (x: Int, y: Int) -> Int in
    return x + y
}

myFunction {
    (x, y) in
    return x + y
}

myFunction { return $0 + $1 }

myFunction { $0 + $1 }

关于 向闭包中传递参数的内容，参见： Function Call Expression.

闭 包表达式可以通过一个参数列表(capture list) 来显式指定它需要的参数。 参数列表 由中括号 [] 括起来，里面的参数由逗号','分隔。一旦使用了参数列表，就必须使用'in'关键字(在任何情况下都得这样做，包括忽略参数的名字，type, 返回值时等等)。

在闭包的参数列表( capture list)中， 参数可以声明为 'weak' 或者 'unowned' .

myFunction { print(self.title) }                    // strong capture
myFunction { [weak self] in print(self!.title) }    // weak capture
myFunction { [unowned self] in print(self.title) }  // unowned capture

在参数列表中，也可以使用任意表达式来赋值. 该表达式会在 闭包被执行时赋值，然后按照不同的力度来获取(这句话请慎重理解)。(captured with the specified strength. ) 例如：

// Weak capture of "self.parent" as "parent"
myFunction { [weak parent = self.parent] in print(parent!.title) }

关于闭包表达式的更多信息和例子，请参见： Closure Expressions.

闭包表达式语法
闭包表达式 → { 闭包签名(Signational) 可选 多条语句(Statements) }
闭包签名(Signational) → 参数子句 函数结果 可选 in
闭包签名(Signational) → 标识符列表 函数结果 可选 in
闭包签名(Signational) → 捕获(Capature)列表 参数子句 函数结果 可选 in
闭包签名(Signational) → 捕获(Capature)列表 标识符列表 函数结果 可选 in
闭包签名(Signational) → 捕获(Capature)列表 in
捕获(Capature)列表 → [ 捕获(Capature)说明符 表达式 ]

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

隐式成员表达式(Implicit Member Expression)

在可以判断出类型(type)的上下文(context)中，隐式成员表达式是访问某个type的member( 例如 class method, enumeration case) 的简洁方法。 它的形式是：

.member name

例子：

var x = MyEnumeration.SomeValue
x = .AnotherValue

隐式成员表达式语法
隐式成员表达式 → . 标识符
 

圆括号表达式(Parenthesized Expression)

圆括号表达式由多个子表达式和逗号','组成。 每个子表达式前面可以有 identifier x: 这样的可选前缀。形式如下：

(identifier 1: expression 1, identifier 2: expression 2, ...)

圆括号表达式用来建立tuples ， 然后把它做为参数传递给 function. 如果某个圆括号表达式中只有一个 子表达式，那么它的type就是 子表达式的type。例如： (1)的 type是Int, 而不是(Int)

圆括号表达式(Parenthesized Expression)语法
圆括号表达式 → ( 表达式元素列表 可选 )
表达式元素列表 → 表达式元素 | 表达式元素 , 表达式元素列表
表达式元素 → 表达式 | 标识符 : 表达式
 

通配符表达式(Wildcard Expression)

通配符表达式用来忽略传递进来的某个参数。例如：下面的代码中，10被传递给x, 20被忽略(译注：好奇葩的语法。。。)

(x, _) = (10, 20)
// x is 10, 20 is ignored

通配符表达式语法
通配符表达式 → _