表達(dá)式（Expressions）

1.0 翻譯：sg552 校對(duì)：numbbbbb, stanzhai

2.0 翻譯+校對(duì)：EudeMorgen

2.1 翻譯：mmoaay

2.2 校對(duì)：175

3.0 翻譯+校對(duì)：chenmingjia

本頁包含內(nèi)容：

前綴表達(dá)式
- try 運(yùn)算符
二元表達(dá)式
基本表達(dá)式
后綴表達(dá)式

Swift 中存在四種表達(dá)式：前綴表達(dá)式，二元表達(dá)式，基本表達(dá)式和后綴表達(dá)式。表達(dá)式在返回一個(gè)值的同時(shí)還可以引發(fā)副作用。

通過前綴表達(dá)式和二元表達(dá)式可以對(duì)簡單表達(dá)式使用各種運(yùn)算符?；颈磉_(dá)式從概念上講是最簡單的一種表達(dá)式，它是一種訪問值的方式。后綴表達(dá)式則允許你建立復(fù)雜的表達(dá)式，例如函數(shù)調(diào)用和成員訪問。每種表達(dá)式都在下面有詳細(xì)論述。

表達(dá)式語法
</a> 表達(dá)式 → try運(yùn)算符_可選 前綴表達(dá)式 二元表達(dá)式列表_可選
表達(dá)式列表 → 表達(dá)式 | 表達(dá)式 , 表達(dá)式列表

前綴表達(dá)式

前綴表達(dá)式由可選的前綴運(yùn)算符和表達(dá)式組成。前綴運(yùn)算符只接收一個(gè)參數(shù)，表達(dá)式則緊隨其后。

關(guān)于這些運(yùn)算符的更多信息，請參閱基本運(yùn)算符和高級(jí)運(yùn)算符。

關(guān)于 Swift 標(biāo)準(zhǔn)庫提供的運(yùn)算符的更多信息，請參閱 Swift Standard Library Operators Reference。

除了標(biāo)準(zhǔn)庫運(yùn)算符，你也可以對(duì)某個(gè)變量使用 & 運(yùn)算符，從而將其傳遞給函數(shù)的輸入輸出參數(shù)。更多信息，請參閱輸入輸出參數(shù)。

前綴表達(dá)式語法
</a> 前綴表達(dá)式 → 前綴運(yùn)算符_可選 后綴表達(dá)式
前綴表達(dá)式 → 輸入輸出表達(dá)式
輸入輸出表達(dá)式 → & 標(biāo)識(shí)符

try 運(yùn)算符

try 表達(dá)式由 try 運(yùn)算符加上緊隨其后的可拋出錯(cuò)誤的表達(dá)式組成，形式如下：

try 可拋出錯(cuò)誤的表達(dá)式

可選的 try 表達(dá)式由 try? 運(yùn)算符加上緊隨其后的可拋出錯(cuò)誤的表達(dá)式組成，形式如下：

try? 可拋出錯(cuò)誤的表達(dá)式

如果可拋出錯(cuò)誤的表達(dá)式?jīng)]有拋出錯(cuò)誤，整個(gè)表達(dá)式返回的可選值將包含可拋出錯(cuò)誤的表達(dá)式的返回值，否則，該可選值為 nil。

強(qiáng)制的 try 表達(dá)式由 try! 運(yùn)算符加上緊隨其后的可拋出錯(cuò)誤的表達(dá)式組成，形式如下：

try! 可拋出錯(cuò)誤的表達(dá)式

如果可拋出錯(cuò)誤的表達(dá)式拋出了錯(cuò)誤，將會(huì)引發(fā)運(yùn)行時(shí)錯(cuò)誤。

在二進(jìn)制運(yùn)算符左側(cè)的表達(dá)式被標(biāo)記上 try、try? 或者 try! 時(shí)，這個(gè)運(yùn)算符對(duì)整個(gè)二進(jìn)制表達(dá)式都產(chǎn)生作用。也就是說，你可以使用括號(hào)來明確運(yùn)算符的作用范圍。

sum = try someThrowingFunction() + anotherThrowingFunction()   // try 對(duì)兩個(gè)函數(shù)調(diào)用都產(chǎn)生作用
sum = try (someThrowingFunction() + anotherThrowingFunction()) // try 對(duì)兩個(gè)函數(shù)調(diào)用都產(chǎn)生作用
sum = (try someThrowingFunction()) + anotherThrowingFunction() // 錯(cuò)誤：try 只對(duì)第一個(gè)函數(shù)調(diào)用產(chǎn)生作用

try 表達(dá)式不能出現(xiàn)在二進(jìn)制運(yùn)算符的的右側(cè)，除非二進(jìn)制運(yùn)算符是賦值運(yùn)算符或者 try 表達(dá)式是被圓括號(hào)括起來的。

關(guān)于 try、try? 和 try! 的更多信息，以及該如何使用的例子，請參閱錯(cuò)誤處理。

try 表達(dá)式語法
try 運(yùn)算符 → try | try? | try!

二元表達(dá)式

二元表達(dá)式由中綴運(yùn)算符和左右參數(shù)表達(dá)式組成。形式如下：

左側(cè)參數(shù) 二元運(yùn)算符 右側(cè)參數(shù)

關(guān)于這些運(yùn)算符的更多信息，請參閱基本運(yùn)算符和高級(jí)運(yùn)算符。

關(guān)于 Swift 標(biāo)準(zhǔn)庫提供的運(yùn)算符的更多信息，請參閱 Swift Standard Library Operators Reference。

注意
在解析時(shí)，一個(gè)二元表達(dá)式將作為一個(gè)扁平列表表示，然后根據(jù)運(yùn)算符的優(yōu)先級(jí)，再進(jìn)一步進(jìn)行組合。例如，2 + 3 * 5 首先被看作具有五個(gè)元素的列表，即 2、+、3、*、5，隨后根據(jù)運(yùn)算符優(yōu)先級(jí)組合為 (2 + (3 * 5))。

二元表達(dá)式語法
二元表達(dá)式 → 二元運(yùn)算符 前綴表達(dá)式
二元表達(dá)式 → 賦值運(yùn)算符 try運(yùn)算符_可選 前綴表達(dá)式
二元表達(dá)式 → 條件運(yùn)算符 try運(yùn)算符_可選 前綴表達(dá)式
二元表達(dá)式 → 類型轉(zhuǎn)換運(yùn)算符
二元表達(dá)式列表 → 二元表達(dá)式 二元表達(dá)式列表_可選

賦值表達(dá)式

賦值表達(dá)式會(huì)為某個(gè)給定的表達(dá)式賦值，形式如下；

表達(dá)式 = 值

右邊的值會(huì)被賦值給左邊的表達(dá)式。如果左邊表達(dá)式是一個(gè)元組，那么右邊必須是一個(gè)具有同樣元素個(gè)數(shù)的元組。（嵌套元組也是允許的。）右邊的值中的每一部分都會(huì)被賦值給左邊的表達(dá)式中的相應(yīng)部分。例如：

(a, _, (b, c)) = ("test", 9.45, (12, 3))
// a 為 "test"，b 為 12，c 為 3，9.45 會(huì)被忽略

賦值運(yùn)算符不返回任何值。

賦值運(yùn)算符語法
賦值運(yùn)算符 → =

三元條件運(yùn)算符

三元條件運(yùn)算符會(huì)根據(jù)條件來對(duì)兩個(gè)給定表達(dá)式中的一個(gè)進(jìn)行求值，形式如下：

條件 ? 表達(dá)式（條件為真則使用） : 表達(dá)式（條件為假則使用）

如果條件為真，那么對(duì)第一個(gè)表達(dá)式進(jìn)行求值并返回結(jié)果。否則，對(duì)第二個(gè)表達(dá)式進(jìn)行求值并返回結(jié)果。未使用的表達(dá)式不會(huì)進(jìn)行求值。

關(guān)于使用三元條件運(yùn)算符的例子，請參閱三元條件運(yùn)算符。

三元條件運(yùn)算符語法
三元條件運(yùn)算符 → ? try運(yùn)算符_可選 表達(dá)式 :

類型轉(zhuǎn)換運(yùn)算符

有 4 種類型轉(zhuǎn)換運(yùn)算符：is、as、as?和as!。它們有如下的形式：

表達(dá)式 is 類型
表達(dá)式 as 類型
表達(dá)式 as? 類型
表達(dá)式 as! 類型

is 運(yùn)算符在運(yùn)行時(shí)檢查表達(dá)式能否向下轉(zhuǎn)化為指定的類型，如果可以則返回 ture，否則返回 false。

as 運(yùn)算符在編譯時(shí)執(zhí)行向上轉(zhuǎn)換和橋接。向上轉(zhuǎn)換可將表達(dá)式轉(zhuǎn)換成超類的實(shí)例而無需使用任何中間變量。以下表達(dá)式是等價(jià)的：

func f(any: Any) { print("Function for Any") }
func f(int: Int) { print("Function for Int") }
let x = 10
f(x)
// 打印 “Function for Int”

let y: Any = x
f(y)
// 打印 “Function for Any”

f(x as Any)
// 打印 “Function for Any”

橋接可將 Swift 標(biāo)準(zhǔn)庫中的類型（例如 String）作為一個(gè)與之相關(guān)的 Foundation 類型（例如 NSString）來使用，而不需要新建一個(gè)實(shí)例。關(guān)于橋接的更多信息，請參閱 Using Swift with Cocoa and Objective-C (Swift2.2) 中的 Working with Cocoa Data Types。

as? 運(yùn)算符有條件地執(zhí)行類型轉(zhuǎn)換，返回目標(biāo)類型的可選值。在運(yùn)行時(shí)，如果轉(zhuǎn)換成功，返回的可選值將包含轉(zhuǎn)換后的值，否則返回 nil。如果在編譯時(shí)就能確定轉(zhuǎn)換一定會(huì)成功或是失敗，則會(huì)導(dǎo)致編譯報(bào)錯(cuò)。

as! 運(yùn)算符執(zhí)行強(qiáng)制類型轉(zhuǎn)換，返回目標(biāo)類型的非可選值。如果轉(zhuǎn)換失敗，則會(huì)導(dǎo)致運(yùn)行時(shí)錯(cuò)誤。表達(dá)式 x as! T 效果等同于 (x as? T)!。

關(guān)于類型轉(zhuǎn)換的更多內(nèi)容和例子，請參閱類型轉(zhuǎn)換。

類型轉(zhuǎn)換運(yùn)算符語法
類型轉(zhuǎn)換運(yùn)算符 → is 類型
類型轉(zhuǎn)換運(yùn)算符 → as 類型
類型轉(zhuǎn)換運(yùn)算符 → as ? 類型
類型轉(zhuǎn)換運(yùn)算符 → as ! 類型

基本表達(dá)式

基本表達(dá)式是最基本的表達(dá)式。它們可以單獨(dú)使用，也可以跟前綴表達(dá)式、二元表達(dá)式、后綴表達(dá)式組合使用。

基本表達(dá)式語法
基本表達(dá)式 → 標(biāo)識(shí)符 泛型實(shí)參子句_可選
基本表達(dá)式 → 字面量表達(dá)式
基本表達(dá)式 → self表達(dá)式
基本表達(dá)式 → 超類表達(dá)式
基本表達(dá)式 → 閉包表達(dá)式
基本表達(dá)式 → 圓括號(hào)表達(dá)式
基本表達(dá)式 → 隱式成員表達(dá)式
基本表達(dá)式 → 通配符表達(dá)式
基本表達(dá)式 → 選擇器表達(dá)式

字面量表達(dá)式

字面量表達(dá)式可由普通字面量（例如字符串或者數(shù)字），字典或者數(shù)組字面量，或者下面列表中的特殊字面量組成：

字面量	類型	值
`#file`	`String`	所在的文件名
`#line`	`Int`	所在的行數(shù)
`#column`	`Int`	所在的列數(shù)
`#function`	`String`	所在的聲明的名字

#line除了上述含義外，還有另一種含義。當(dāng)它出現(xiàn)在單獨(dú)一行時(shí)，會(huì)被理解成行控制語句，請參閱線路控制語句。

對(duì)于 ＃function，在函數(shù)中會(huì)返回當(dāng)前函數(shù)的名字，在方法中會(huì)返回當(dāng)前方法的名字，在屬性的存取器中會(huì)返回屬性的名字，在特殊的成員如 init 或 subscript 中會(huì)返回這個(gè)關(guān)鍵字的名字，在某個(gè)文件中會(huì)返回當(dāng)前模塊的名字。

#function 作為函數(shù)或者方法的默認(rèn)參數(shù)值時(shí)，該字面量的值取決于函數(shù)或方法的調(diào)用環(huán)境。

func logFunctionName(string: String = #function) {
    print(string)
}
func myFunction() {
    logFunctionName() 
}
myFunction() // 打印 “myFunction()”

數(shù)組字面量是值的有序集合，形式如下：

[值 1, 值 2, ...]

數(shù)組中的最后一個(gè)表達(dá)式可以緊跟一個(gè)逗號(hào)。數(shù)組字面量的類型是 [T]，這個(gè) T 就是數(shù)組中元素的類型。如果數(shù)組中包含多種類型，T 則是跟這些類型最近的的公共父類型?？諗?shù)組字面量由一組方括號(hào)定義，可用來創(chuàng)建特定類型的空數(shù)組。

var emptyArray: [Double] = []

字典字面量是一個(gè)包含無序鍵值對(duì)的集合，形式如下：

[鍵 1 : 值 1, 鍵 2 : 值 2, ...]

字典中的最后一個(gè)表達(dá)式可以緊跟一個(gè)逗號(hào)。字典字面量的類型是 [Key : Value]，Key 表示鍵的類型，Value 表示值的類型。如果字典中包含多種類型，那么 Key 表示的類型則為所有鍵最接近的公共父類型，Value 與之相似。一個(gè)空的字典字面量由方括號(hào)中加一個(gè)冒號(hào)組成（[:]），從而與空數(shù)組字面量區(qū)分開，可以使用空字典字面量來創(chuàng)建特定類型的字典。

var emptyDictionary: [String : Double] = [:]

字面量表達(dá)式語法

字面量表達(dá)式 → 字面量
字面量表達(dá)式 → 數(shù)組字面量 | 字典字面量
字面量表達(dá)式 → #file | #line | #column | #function

數(shù)組字面量 → [ 數(shù)組字面量項(xiàng)列表_可選 ]
</a> 數(shù)組字面量項(xiàng)列表 → 數(shù)組字面量項(xiàng) ,_可選 | 數(shù)組字面量項(xiàng) , 數(shù)組字面量項(xiàng)列表
數(shù)組字面量項(xiàng) → 表達(dá)式

字典字面量 → [ 字典字面量項(xiàng)列表 ] | [ : ]
</a> 字典字面量項(xiàng)列表 → 字典字面量項(xiàng) ,_可選 | 字典字面量項(xiàng) , 字典字面量項(xiàng)列表
字典字面量項(xiàng) → 表達(dá)式 : 表達(dá)式

self 表達(dá)式

self 表達(dá)式是對(duì)當(dāng)前類型或者當(dāng)前實(shí)例的顯式引用，它有如下形式：

self
self.成員名稱
self[下標(biāo)索引]
self(構(gòu)造器參數(shù))
self.init(構(gòu)造器參數(shù))

如果在構(gòu)造器、下標(biāo)、實(shí)例方法中，self 引用的是當(dāng)前類型的實(shí)例。在一個(gè)類型方法中，self 引用的是當(dāng)前的類型。

當(dāng)訪問成員時(shí)，self 可用來區(qū)分重名變量，例如函數(shù)的參數(shù)：

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

在 mutating 方法中，你可以對(duì) self 重新賦值：

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 表達(dá)式語法
self 表達(dá)式 → self | self 方法表達(dá)式 ｜ self 下標(biāo)表達(dá)式 | self 構(gòu)造器表達(dá)式

</a> self 方法表達(dá)式 → self . 標(biāo)識(shí)符
self 下標(biāo)表達(dá)式 → self [ 表達(dá)式 ] self 構(gòu)造器表達(dá)式 → self . init

超類表達(dá)式

超類表達(dá)式可以使我們在某個(gè)類中訪問它的超類，它有如下形式：

super.成員名稱
super[下標(biāo)索引]
super.init(構(gòu)造器參數(shù))

第一種形式用來訪問超類的某個(gè)成員，第二種形式用來訪問超類的下標(biāo)，第三種形式用來訪問超類的構(gòu)造器。

子類可以通過超類表達(dá)式在它們的成員、下標(biāo)和構(gòu)造器中使用超類中的實(shí)現(xiàn)。

超類表達(dá)式語法
</a> 超類表達(dá)式 → 超類方法表達(dá)式 | 超類下標(biāo)表達(dá)式 | 超類構(gòu)造器表達(dá)式
超類方法表達(dá)式 → super . 標(biāo)識(shí)符
</a> 超類下標(biāo)表達(dá)式 → super [ 表達(dá)式 ]
超類構(gòu)造器表達(dá)式 → super . init

閉包表達(dá)式

閉包表達(dá)式會(huì)創(chuàng)建一個(gè)閉包，在其他語言中也叫 lambda 或匿名函數(shù)。跟函數(shù)一樣，閉包包含了待執(zhí)行的代碼，不同的是閉包還會(huì)捕獲所在環(huán)境中的常量和變量。它的形式如下：

{ (parameters) -> return type in  
    statements  
}

閉包的參數(shù)聲明形式跟函數(shù)一樣，請參閱函數(shù)聲明。

閉包還有幾種特殊的形式，能讓閉包使用起來更加簡潔：

閉包可以省略它的參數(shù)和返回值的類型。如果省略了參數(shù)名和所有的類型，也要省略 in 關(guān)鍵字。如果被省略的類型無法被編譯器推斷，那么就會(huì)導(dǎo)致編譯錯(cuò)誤。
閉包可以省略參數(shù)名，參數(shù)會(huì)被隱式命名為 $ 加上其索引位置，例如 $0、$1、$2 分別表示第一個(gè)、第二個(gè)、第三個(gè)參數(shù)，以此類推。
如果閉包中只包含一個(gè)表達(dá)式，那么該表達(dá)式的結(jié)果就會(huì)被視為閉包的返回值。表達(dá)式結(jié)果的類型也會(huì)被推斷為閉包的返回類型。

下面幾個(gè)閉包表達(dá)式是等價(jià)的：

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

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

myFunction { return $0 + $1 }

myFunction { $0 + $1 }

關(guān)于如何將閉包作為參數(shù)來傳遞的內(nèi)容，請參閱函數(shù)調(diào)用表達(dá)式。

捕獲列表

默認(rèn)情況下，閉包會(huì)捕獲附近作用域中的常量和變量，并使用強(qiáng)引用指向它們。你可以通過一個(gè)捕獲列表來顯式指定它的捕獲行為。

捕獲列表在參數(shù)列表之前，由中括號(hào)括起來，里面是由逗號(hào)分隔的一系列表達(dá)式。一旦使用了捕獲列表，就必須使用 in 關(guān)鍵字，即使省略了參數(shù)名、參數(shù)類型和返回類型。

捕獲列表中的項(xiàng)會(huì)在閉包創(chuàng)建時(shí)被初始化。每一項(xiàng)都會(huì)用閉包附近作用域中的同名常量或者變量的值初始化。例如下面的代碼示例中，捕獲列表包含 a 而不包含 b，這將導(dǎo)致這兩個(gè)變量具有不同的行為。

var a = 0
var b = 0
let closure = { [a] in
    print(a, b)
}

a = 10
b = 10
closure()
// 打印 “0 10”

在示例中，變量 b 只有一個(gè)，然而，變量 a 有兩個(gè)，一個(gè)在閉包外，一個(gè)在閉包內(nèi)。閉包內(nèi)的變量 a 會(huì)在閉包創(chuàng)建時(shí)用閉包外的變量 a 的值來初始化，除此之外它們并無其他聯(lián)系。這意味著在閉包創(chuàng)建后，改變某個(gè) a 的值都不會(huì)對(duì)另一個(gè) a 的值造成任何影響。與此相反，閉包內(nèi)外都是同一個(gè)變量 b，因此在閉包外改變其值，閉包內(nèi)的值也會(huì)受影響。

如果閉包捕獲的值具有引用語義則有所不同。例如，下面示例中，有兩個(gè)變量 x，一個(gè)在閉包外，一個(gè)在閉包內(nèi)，由于它們的值是引用語義，雖然這是兩個(gè)不同的變量，它們卻都引用著同一實(shí)例。

class SimpleClass {
    var value: Int = 0
}
var x = SimpleClass()
var y = SimpleClass()
let closure = { [x] in
    print(x.value, y.value)
}

x.value = 10
y.value = 10
closure()
// 打印 “10 10”

如果捕獲列表中的值是類類型，你可以使用 weak 或者 unowned 來修飾它，閉包會(huì)分別用弱引用和無主引用來捕獲該值。

myFunction { print(self.title) }                   // 以強(qiáng)引用捕獲
myFunction { [weak self] in print(self!.title) }   // 以弱引用捕獲
myFunction { [unowned self] in print(self.title) } // 以無主引用捕獲

在捕獲列表中，也可以將任意表達(dá)式的值綁定到一個(gè)常量上。該表達(dá)式會(huì)在閉包被創(chuàng)建時(shí)進(jìn)行求值，閉包會(huì)按照指定的引用類型來捕獲表達(dá)式的值。例如：

// 以弱引用捕獲 self.parent 并賦值給 parent
myFunction { [weak parent = self.parent] in print(parent!.title) }

關(guān)于閉包表達(dá)式的更多信息和例子，請參閱閉包表達(dá)式。關(guān)于捕獲列表的更多信息和例子，請參閱解決閉包引起的循環(huán)強(qiáng)引用。

閉包表達(dá)式語法

閉包表達(dá)式 → { 閉包簽名_可選語句 }

閉包簽名 → 參數(shù)子句 函數(shù)結(jié)果_可選 in
閉包簽名 → 標(biāo)識(shí)符列表 函數(shù)結(jié)果_可選 in
閉包簽名 → 捕獲列表 參數(shù)子句 函數(shù)結(jié)果_可選 in
閉包簽名 → 捕獲列表 標(biāo)識(shí)符列表 函數(shù)結(jié)果_可選 in
閉包簽名 → 捕獲列表 in

捕獲列表 → [ 捕獲列表項(xiàng)列表 ]
</a> 捕獲列表項(xiàng)列表 → 捕獲列表項(xiàng) | 捕獲列表項(xiàng) , 捕獲列表項(xiàng)列表
捕獲列表項(xiàng) → 捕獲說明符_可選 表達(dá)式
捕獲說明符 → weak | unowned | unowned(safe) | unowned(unsafe)

隱式成員表達(dá)式

若類型可被推斷出來，可以使用隱式成員表達(dá)式來訪問某個(gè)類型的成員（例如某個(gè)枚舉成員或某個(gè)類型方法），形式如下：

.成員名稱

例如：

var x = MyEnumeration.SomeValue
x = .AnotherValue

隱式成員表達(dá)式語法
隱式成員表達(dá)式 → . 標(biāo)識(shí)符

圓括號(hào)表達(dá)式

圓括號(hào)表達(dá)式由圓括號(hào)和其中多個(gè)逗號(hào)分隔的子表達(dá)式組成。每個(gè)子表達(dá)式前面可以有一個(gè)標(biāo)識(shí)符，用冒號(hào)隔開。圓括號(hào)表達(dá)式形式如下：

(標(biāo)識(shí)符 1 : 表達(dá)式 1, 標(biāo)識(shí)符 2 : 表達(dá)式 2, ...)

使用圓括號(hào)表達(dá)式來創(chuàng)建元組，然后將其作為參數(shù)傳遞給函數(shù)。如果某個(gè)圓括號(hào)表達(dá)式中只有一個(gè)子表達(dá)式，那么它的類型就是子表達(dá)式的類型。例如，表達(dá)式 (1) 的類型是 Int，而不是 (Int)。

圓括號(hào)表達(dá)式語法
</a> 圓括號(hào)表達(dá)式 → ( 表達(dá)式元素列表_可選 )
表達(dá)式元素列表 → 表達(dá)式元素 | 表達(dá)式元素 , 表達(dá)式元素列表
表達(dá)式元素 → 表達(dá)式 | 標(biāo)識(shí)符 : 表達(dá)式

通配符表達(dá)式

通配符表達(dá)式可以在賦值過程中顯式忽略某個(gè)值。例如下面的代碼中，10 被賦值給 x，而 20 則被忽略：

(x, _) = (10, 20)
// x 為 10，20 被忽略

通配符表達(dá)式語法
通配符表達(dá)式 → _

選擇器表達(dá)式

選擇器表達(dá)式可以讓你通過選擇器來引用在Objective-C中方法(method)和屬性(property)的setter和getter方法。

#selector(方法名) #selector(getter: 屬性名) #selector(setter: 屬性名)

方法名和屬性名必須是存在于 Objective-C 運(yùn)行時(shí)中的方法和屬性的引用。選擇器表達(dá)式的返回值是一個(gè) Selector 類型的實(shí)例。例如：

class SomeClass: NSObject {
    let property: String
    @objc(doSomethingWithInt:)
    func doSomething(_ x: Int) { }

    init(property: String) {
        self.property = property
    }
}
let selectorForMethod = #selector(SomeClass.doSomething(_:))
let selectorForPropertyGetter = #selector(getter: SomeClass.property)

當(dāng)為屬性的getter創(chuàng)建選擇器時(shí),屬性名可以是變量屬性或者常量屬性的引用。但是當(dāng)為屬性的setter創(chuàng)建選擇器時(shí),屬性名只可以是對(duì)變量屬性的引用。

方法名稱可以包含圓括號(hào)來進(jìn)行分組,并使用as 操作符來區(qū)分具有相同方法名但類型不同的方法, 例如:

extension SomeClass {
    @objc(doSomethingWithString:)
    func doSomething(_ x: String) { }
}
let anotherSelector = #selector(SomeClass.doSomething(_:) as (SomeClass) -> (String) -> Void)

由于選擇器是在編譯時(shí)創(chuàng)建的，因此編譯器可以檢查方法或者屬性是否存在，以及是否在運(yùn)行時(shí)暴露給了 Objective-C 。

注意
雖然方法名或者屬性名是個(gè)表達(dá)式，但是它不會(huì)被求值。

更多關(guān)于如何在 Swift 代碼中使用選擇器來與 Objective-C API 進(jìn)行交互的信息，請參閱 Using Swift with Cocoa and Objective-C (Swift 3) 中Objective-C Selectors部分。

選擇器表達(dá)式語法
選擇器表達(dá)式 → #selector ( 表達(dá)式 )
選擇器表達(dá)式 → #selector ( getter:表達(dá)式 )
選擇器表達(dá)式 → #selector ( setter:表達(dá)式 )

后綴表達(dá)式

后綴表達(dá)式就是在某個(gè)表達(dá)式的后面運(yùn)用后綴運(yùn)算符或其他后綴語法。從語法構(gòu)成上來看，基本表達(dá)式也是后綴表達(dá)式。

關(guān)于這些運(yùn)算符的更多信息，請參閱基本運(yùn)算符和高級(jí)運(yùn)算符。

關(guān)于 Swift 標(biāo)準(zhǔn)庫提供的運(yùn)算符的更多信息，請參閱 Swift Standard Library Operators Reference。

后綴表達(dá)式語法
后綴表達(dá)式 → 基本表達(dá)式
后綴表達(dá)式 → 后綴表達(dá)式 后綴運(yùn)算符
后綴表達(dá)式 → 函數(shù)調(diào)用表達(dá)式
后綴表達(dá)式 → 構(gòu)造器表達(dá)式
后綴表達(dá)式 → 顯式成員表達(dá)式
后綴表達(dá)式 → 后綴 self 表達(dá)式
后綴表達(dá)式 → dynamicType 表達(dá)式
后綴表達(dá)式 → 下標(biāo)表達(dá)式
后綴表達(dá)式 → 強(qiáng)制取值表達(dá)式
后綴表達(dá)式 → 可選鏈表達(dá)式

函數(shù)調(diào)用表達(dá)式

函數(shù)調(diào)用表達(dá)式由函數(shù)名和參數(shù)列表組成，形式如下：

函數(shù)名(參數(shù) 1, 參數(shù) 2)

函數(shù)名可以是值為函數(shù)類型的任意表達(dá)式。

如果函數(shù)聲明中指定了參數(shù)的名字，那么在調(diào)用的時(shí)候也必須得寫出來。這種函數(shù)調(diào)用表達(dá)式具有以下形式：

函數(shù)名(參數(shù)名 1: 參數(shù) 1, 參數(shù)名 2: 參數(shù) 2)

如果函數(shù)的最后一個(gè)參數(shù)是函數(shù)類型，可以在函數(shù)調(diào)用表達(dá)式的尾部（右圓括號(hào)之后）加上一個(gè)閉包，該閉包會(huì)作為函數(shù)的最后一個(gè)參數(shù)。如下兩種寫法是等價(jià)的：

// someFunction 接受整數(shù)和閉包參數(shù)
someFunction(x, f: {$0 == 13})
someFunction(x) {$0 == 13}

如果閉包是該函數(shù)的唯一參數(shù)，那么圓括號(hào)可以省略。

// someFunction 只接受一個(gè)閉包參數(shù)
myData.someMethod() {$0 == 13}
myData.someMethod {$0 == 13}

函數(shù)調(diào)用表達(dá)式語法
</a> 函數(shù)調(diào)用表達(dá)式 → 后綴表達(dá)式 圓括號(hào)表達(dá)式
函數(shù)調(diào)用表達(dá)式 → 后綴表達(dá)式 圓括號(hào)表達(dá)式_可選 尾隨閉包
尾隨閉包 → 閉包表達(dá)式

構(gòu)造器表達(dá)式

構(gòu)造器表達(dá)式用于訪問某個(gè)類型的構(gòu)造器，形式如下：

表達(dá)式.init(構(gòu)造器參數(shù))

你可以在函數(shù)調(diào)用表達(dá)式中使用構(gòu)造器表達(dá)式來初始化某個(gè)類型的新實(shí)例。也可以使用構(gòu)造器表達(dá)式來代理給超類構(gòu)造器。

class SomeSubClass: SomeSuperClass {
    override init() {
        // 此處為子類構(gòu)造過程
        super.init()
    }
}

和函數(shù)類似，構(gòu)造器表達(dá)式可以作為一個(gè)值。例如：

// 類型注解是必須的，因?yàn)?String 類型有多種構(gòu)造器
let initializer: Int -> String = String.init
let oneTwoThree = [1, 2, 3].map(initializer).reduce("", combine: +)
print(oneTwoThree)
// 打印 “123”

如果通過名字來指定某個(gè)類型，可以不用構(gòu)造器表達(dá)式而直接使用類型的構(gòu)造器。在其他情況下，你必須使用構(gòu)造器表達(dá)式。

let s1 = SomeType.init(data: 3) // 有效
let s2 = SomeType(data: 1)      // 有效

let s4 = someValue.dynamicType(data: 5)      // 錯(cuò)誤
let s3 = someValue.dynamicType.init(data: 7) // 有效

構(gòu)造器表達(dá)式語法
構(gòu)造器表達(dá)式 → 后綴表達(dá)式 . init
構(gòu)造器表達(dá)式 → 后綴表達(dá)式 . init ( 參數(shù)名稱 )

顯式成員表達(dá)式

顯式成員表達(dá)式允許我們訪問命名類型、元組或者模塊的成員，其形式如下：

表達(dá)式.成員名

命名類型的某個(gè)成員在原始實(shí)現(xiàn)或者擴(kuò)展中定義，例如：

class SomeClass {
    var someProperty = 42
}
let c = SomeClass()
let y = c.someProperty // 訪問成員

元組的成員會(huì)隱式地根據(jù)表示它們出現(xiàn)順序的整數(shù)來命名，以 0 開始，例如：

var t = (10, 20, 30)
t.0 = t.1
// 現(xiàn)在元組 t 為 (20, 20, 30)

對(duì)于模塊的成員來說，只能直接訪問頂級(jí)聲明中的成員。

為了區(qū)分只有參數(shù)名有所不同的方法或構(gòu)造器，在圓括號(hào)中寫出參數(shù)名，參數(shù)名后緊跟一個(gè)冒號(hào)，對(duì)于沒有參數(shù)名的參數(shù)，使用下劃線代替參數(shù)名。而對(duì)于重載方法，則需使用類型標(biāo)注進(jìn)行區(qū)分。例如：

class SomeClass {
    func someMethod(x: Int, y: Int) {}
    func someMethod(x: Int, z: Int) {}
    func overloadedMethod(x: Int, y: Int) {}
    func overloadedMethod(x: Int, y: Bool) {}
}
let instance = SomeClass()

let a = instance.someMethod              // 有歧義
let b = instance.someMethod(_:y:)        // 無歧義

let d = instance.overloadedMethod        // 有歧義
let d = instance.overloadedMethod(_:y:)  // 有歧義
let d: (Int, Bool) -> Void  = instance.overloadedMethod(_:y:)  // 無歧義

如果點(diǎn)號(hào)（.）出現(xiàn)在行首，它會(huì)被視為顯式成員表達(dá)式的一部分，而不是隱式成員表達(dá)式的一部分。例如如下代碼所展示的被分為多行的鏈?zhǔn)椒椒ㄕ{(diào)用：

let x = [10, 3, 20, 15, 4]
    .sort()
    .filter { $0 > 5 }
    .map { $0 * 100 }

顯式成員表達(dá)式語法
顯式成員表達(dá)式 → 后綴表達(dá)式 . 十進(jìn)制數(shù)字
顯式成員表達(dá)式 → 后綴表達(dá)式 . 標(biāo)識(shí)符 泛型實(shí)參子句_可選
顯式成員表達(dá)式 → 后綴表達(dá)式 . 標(biāo)識(shí)符 ( 參數(shù)名稱 )

</a> 參數(shù)名稱 → 參數(shù)名 參數(shù)名稱_可選
參數(shù)名 → 標(biāo)識(shí)符 :

后綴 self 表達(dá)式

后綴 self 表達(dá)式由某個(gè)表達(dá)式或類型名緊跟 .self 組成，其形式如下：

表達(dá)式.self
類型.self

第一種形式返回表達(dá)式的值。例如：x.self 返回 x。

第二種形式返回相應(yīng)的類型。我們可以用它來獲取某個(gè)實(shí)例的類型作為一個(gè)值來使用。例如，SomeClass.self 會(huì)返回 SomeClass 類型本身，你可以將其傳遞給相應(yīng)函數(shù)或者方法作為參數(shù)。

后綴 self 表達(dá)式語法
后綴 self 表達(dá)式 → 后綴表達(dá)式 . self

dynamicType 表達(dá)式

dynamicType 表達(dá)式由類似函數(shù)調(diào)用表達(dá)式(Function Call Expression)的特殊語法表達(dá)式組成,形式如下:

type(of:表達(dá)式)

上述形式中的表達(dá)式不能是類型名。type(of:) 表達(dá)式會(huì)返回某個(gè)實(shí)例在運(yùn)行時(shí)的類型，具體請看下面的例子：

class SomeBaseClass {
    class func printClassName() {
        print("SomeBaseClass")
    }
}
class SomeSubClass: SomeBaseClass {
    override class func printClassName() {
        print("SomeSubClass")
    }
}
let someInstance: SomeBaseClass = SomeSubClass()
// someInstance 在編譯時(shí)的靜態(tài)類型為 SomeBaseClass，
// 在運(yùn)行時(shí)的動(dòng)態(tài)類型為 SomeSubClass
type(of: someInstance).printClassName()
// 打印 “SomeSubClass”

動(dòng)態(tài)類型表達(dá)式語法
動(dòng)態(tài)類型表達(dá)式 → type(of:表達(dá)式) . dynamicType

下標(biāo)表達(dá)式

可通過下標(biāo)表達(dá)式訪問相應(yīng)的下標(biāo)，形式如下：

表達(dá)式[索引表達(dá)式]

要獲取下標(biāo)表達(dá)式的值，可將索引表達(dá)式作為下標(biāo)表達(dá)式的參數(shù)來調(diào)用下標(biāo) getter。下標(biāo) setter 的調(diào)用方式與之一樣。

關(guān)于下標(biāo)的聲明，請參閱協(xié)議下標(biāo)聲明。

下標(biāo)表達(dá)式語法
下標(biāo)表達(dá)式 → 后綴表達(dá)式 [ 表達(dá)式列表 ]

強(qiáng)制取值表達(dá)式

當(dāng)你確定可選值不是 nil 時(shí)，可以使用強(qiáng)制取值表達(dá)式來強(qiáng)制解包，形式如下：

表達(dá)式!

如果該表達(dá)式的值不是 nil，則返回解包后的值。否則，拋出運(yùn)行時(shí)錯(cuò)誤。

返回的值可以被修改，無論是修改值本身，還是修改值的成員。例如：

var x: Int? = 0
x!++
// x 現(xiàn)在是 1

var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]
someDictionary["a"]![0] = 100
// someDictionary 現(xiàn)在是 [b: [10, 20], a: [100, 2, 3]]

強(qiáng)制取值語法
強(qiáng)制取值表達(dá)式 → 后綴表達(dá)式 !

可選鏈表達(dá)式

可選鏈表達(dá)式提供了一種使用可選值的便捷方法，形式如下：

表達(dá)式?

后綴 ? 運(yùn)算符會(huì)根據(jù)表達(dá)式生成可選鏈表達(dá)式而不會(huì)改變表達(dá)式的值。

如果某個(gè)后綴表達(dá)式包含可選鏈表達(dá)式，那么它的執(zhí)行過程會(huì)比較特殊。如果該可選鏈表達(dá)式的值是 nil，整個(gè)后綴表達(dá)式會(huì)直接返回 nil。如果該可選鏈表達(dá)式的值不是 nil，則返回可選鏈表達(dá)式解包后的值，并將該值用于后綴表達(dá)式中剩余的表達(dá)式。在這兩種情況下，整個(gè)后綴表達(dá)式的值都會(huì)是可選類型。

如果某個(gè)后綴表達(dá)式中包含了可選鏈表達(dá)式，那么只有最外層的表達(dá)式會(huì)返回一個(gè)可選類型。例如，在下面的例子中，如果 c 不是 nil，那么它的值會(huì)被解包，然后通過 .property 訪問它的屬性，接著進(jìn)一步通過 .performAction() 調(diào)用相應(yīng)方法。整個(gè) c?.property.performAction() 表達(dá)式返回一個(gè)可選類型的值，而不是多重可選類型。

var c: SomeClass?
var result: Bool? = c?.property.performAction()

上面的例子跟下面的不使用可選鏈表達(dá)式的例子等價(jià)：

var result: Bool? = nil
if let unwrappedC = c {
    result = unwrappedC.property.performAction()
}

可選鏈表達(dá)式解包后的值可以被修改，無論是修改值本身，還是修改值的成員。如果可選鏈表達(dá)式的值為 nil，則表達(dá)式右側(cè)的賦值操作不會(huì)被執(zhí)行。例如：

func someFunctionWithSideEffects() -> Int {
    // 譯者注：為了能看出此函數(shù)是否被執(zhí)行，加上了一句打印
    print("someFunctionWithSideEffects") 
    return 42 
}
var someDictionary = ["a": [1, 2, 3], "b": [10, 20]]

someDictionary["not here"]?[0] = someFunctionWithSideEffects()
// someFunctionWithSideEffects 不會(huì)被執(zhí)行
// someDictionary 依然是 ["b": [10, 20], "a": [1, 2, 3]]

someDictionary["a"]?[0] = someFunctionWithSideEffects()
// someFunctionWithSideEffects 被執(zhí)行并返回 42
// someDictionary 現(xiàn)在是 ["b": [10, 20], "a": [42, 2, 3]]

可選鏈表達(dá)式語法
可選鏈表達(dá)式 → 后綴表達(dá)式 ?

? 類型語句 ?

99热99这里只有精品6国产,亚洲中文字幕在线天天更新,在线观看亚洲精品国产福利片 ,久久久久综合网

表達(dá)式（Expressions）

前綴表達(dá)式

try 運(yùn)算符

二元表達(dá)式

賦值表達(dá)式

三元條件運(yùn)算符

類型轉(zhuǎn)換運(yùn)算符

基本表達(dá)式

字面量表達(dá)式

self 表達(dá)式

超類表達(dá)式

閉包表達(dá)式

捕獲列表

隱式成員表達(dá)式

圓括號(hào)表達(dá)式

通配符表達(dá)式

選擇器表達(dá)式

后綴表達(dá)式

函數(shù)調(diào)用表達(dá)式

構(gòu)造器表達(dá)式

顯式成員表達(dá)式

后綴 self 表達(dá)式

dynamicType 表達(dá)式

下標(biāo)表達(dá)式

強(qiáng)制取值表達(dá)式

可選鏈表達(dá)式