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

表達(dá)式語法

表達(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)算符和高級運(yùn)算符。

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

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

前綴表達(dá)式語法

前綴表達(dá)式 → 前綴運(yùn)算符_可選 后綴表達(dá)式 前綴表達(dá)式 → 輸入輸出表達(dá)式 輸入輸出表達(dá)式 → & 標(biāo)識符

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ò)誤，將會引發(fā)運(yùn)行時(shí)錯(cuò)誤。

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

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

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

關(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)算符和高級運(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ìn)一步進(jìn)行組合。例如，2 + 3 * 5 首先被看作具有五個(gè)元素的列表，即 2、+、3、*、5，隨后根據(jù)運(yùn)算符優(yōu)先級組合為 (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á)式會為某個(gè)給定的表達(dá)式賦值，形式如下；

表達(dá)式 = 值

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

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

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

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

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

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

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

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

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

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

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

三元條件運(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 (Swift4.1) 中的 Working with Cocoa Data Types。

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

as! 運(yùn)算符執(zhí)行強(qiáng)制類型轉(zhuǎn)換，返回目標(biāo)類型的非可選值。如果轉(zhuǎn)換失敗，則會導(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í)參子句_可選 基本表達(dá)式 → 字面量表達(dá)式 基本表達(dá)式 → self 表達(dá)式 基本表達(dá)式 → 超類表達(dá)式 基本表達(dá)式 → 閉包表達(dá)式 基本表達(dá)式 → 圓括號表達(dá)式 基本表達(dá)式 → 隱式成員表達(dá)式 基本表達(dá)式 → 通配符表達(dá)式 基本表達(dá)式 → 選擇器表達(dá)式 基本表達(dá)式 → key-path字符串表達(dá)式

字面量表達(dá)式

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

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

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

當(dāng)其作為函數(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è)逗號。數(shù)組字面量的類型是 [T]，這個(gè) T 就是數(shù)組中元素的類型。如果數(shù)組中包含多種類型，T 則是跟這些類型最近的的公共父類型?？諗?shù)組字面量由一組方括號定義，可用來創(chuàng)建特定類型的空數(shù)組。

var emptyArray: [Double] = []

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

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

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

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

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

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

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

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

Self 表達(dá)式

self 表達(dá)式是對當(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 方法中，你可以對 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á)式

self 方法表達(dá)式 → self . 標(biāo)識符 self 下標(biāo)表達(dá)式 → self [ 函數(shù)調(diào)用參數(shù)表 ] 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á)式語法

超類表達(dá)式 → 超類方法表達(dá)式 | 超類下標(biāo)表達(dá)式 | 超類構(gòu)造器表達(dá)式

超類方法表達(dá)式 → super . 標(biāo)識符 超類下標(biāo)表達(dá)式 → super [函數(shù)調(diào)用參數(shù)表 ] 超類構(gòu)造器表達(dá)式 → super . init

閉包表達(dá)式

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

{ (parameters) -> return type in
    statements
}

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

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

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

下面幾個(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á)式。

關(guān)于逃逸閉包的內(nèi)容，請參閱逃逸閉包

捕獲列表

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

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

捕獲列表中的項(xiàng)會在閉包創(chuàng)建時(shí)被初始化。每一項(xiàng)都會用閉包附近作用域中的同名常量或者變量的值初始化。例如下面的代碼示例中，捕獲列表包含 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 會在閉包創(chuàng)建時(shí)用閉包外的變量 a 的值來初始化，除此之外它們并無其他聯(lián)系。這意味著在閉包創(chuàng)建后，改變某個(gè) a 的值都不會對另一個(gè) a 的值造成任何影響。與此相反，閉包內(nèi)外都是同一個(gè)變量 b，因此在閉包外改變其值，閉包內(nèi)的值也會受影響。

如果閉包捕獲的值具有引用語義則有所不同。例如，下面示例中，有兩個(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 來修飾它，閉包會分別用弱引用和無主引用來捕獲該值。

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

在捕獲列表中，也可以將任意表達(dá)式的值綁定到一個(gè)常量上。該表達(dá)式會在閉包被創(chuàng)建時(shí)進(jìn)行求值，閉包會按照指定的引用類型來捕獲表達(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ù)結(jié)果_可選 in 閉包簽名 → 捕獲列表 參數(shù)子句 函數(shù)結(jié)果_可選 in 閉包簽名 → 捕獲列表 標(biāo)識符列表 函數(shù)結(jié)果_可選 in 閉包簽名 → 捕獲列表 in

捕獲列表 → [ 捕獲列表項(xiàng)列表 ] 捕獲列表項(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)識符

圓括號表達(dá)式

圓括號表達(dá)式是由圓括號包圍的表達(dá)式。你可以用圓括號說明成組的表達(dá)式的先后操作。成組的圓括號不會改變表達(dá)式的類型 - 例如 (1) 的類型就是簡單的 Int。

圓括號表達(dá)式語法

圓括號表達(dá)式 → ( 表達(dá)式 )

元組表達(dá)式

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

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

元組表達(dá)式可以一個(gè)表達(dá)式都沒有，也可以包含兩個(gè)或是更多的表達(dá)式。單個(gè)表達(dá)式用括號括起來就是括號表達(dá)式了。

元組表達(dá)式語法

元組表達(dá)式 → ( ) | (元組元素， 元組元素列表 ) 元組元素列表 → 元組元素 | 元組元素 , 元組元素列表 元組元素 → 表達(dá)式 | 標(biāo)識符 : 表達(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í)，屬性名只可以是對變量屬性的引用。

方法名稱可以包含圓括號來進(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á)式，但是它不會被求值。

更多關(guān)于如何在 Swift 代碼中使用選擇器來與 Objective-C API 進(jìn)行交互的信息，請參閱 Using Swift with Cocoa and Objective-C (Swift 4.1) 中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)算符和高級運(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á)式的尾部（右圓括號之后）加上一個(gè)閉包，該閉包會作為函數(shù)的最后一個(gè)參數(shù)。如下兩種寫法是等價(jià)的：

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

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

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

函數(shù)調(diào)用表達(dá)式語法 函數(shù)調(diào)用表達(dá)式 → 后綴表達(dá)式 圓括號表達(dá)式 函數(shù)調(diào)用表達(dá)式 → 后綴表達(dá)式 圓括號表達(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 // 訪問成員

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

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

對于模塊的成員來說，只能直接訪問頂級聲明中的成員。

為了區(qū)分只有參數(shù)名有所不同的方法或構(gòu)造器，在圓括號中寫出參數(shù)名，參數(shù)名后緊跟一個(gè)冒號，對于沒有參數(shù)名的參數(shù)，使用下劃線代替參數(shù)名。而對于重載方法，則需使用類型標(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)號（.）出現(xiàn)在行首，它會被視為顯式成員表達(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ù)字] (02_Lexical_Structure.html#decimal-digit) 顯式成員表達(dá)式 → 后綴表達(dá)式 . 標(biāo)識符 上一篇：下標(biāo)下一篇：可選鏈?zhǔn)秸{(diào)用

在线观看不卡亚洲电影_亚洲妓女99综合网_91青青青亚洲娱乐在线观看_日韩无码高清综合久久

表達(dá)式（Expressions）

前綴表達(dá)式

Try 運(yùn)算符

二元表達(dá)式

賦值表達(dá)式

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

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

基本表達(dá)式

字面量表達(dá)式

Self 表達(dá)式

父類表達(dá)式

閉包表達(dá)式

捕獲列表

隱式成員表達(dá)式

圓括號表達(dá)式

元組表達(dá)式

通配符表達(dá)式

選擇器表達(dá)式

后綴表達(dá)式

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

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

顯式成員表達(dá)式