Revise the traditional Chinese translation in mds in the folder souce-tw & Using Swift with Cocoa and ObjectiveC-tw
This commit is contained in:
Roger Chou
38
source-tw/chapter3/01_About_the_Language_Reference.md
Normal file
38
source-tw/chapter3/01_About_the_Language_Reference.md
Normal file
@ -0,0 +1,38 @@
|
||||
> 翻譯：[dabing1022](https://github.com/dabing1022)
|
||||
> 校對：[numbbbbb](https://github.com/numbbbbb)
|
||||
|
||||
|
||||
# 關於語言附註
|
||||
-----------------
|
||||
|
||||
本頁內容包括：
|
||||
|
||||
- [如何閱讀語法](#how_to_read_the_grammar)
|
||||
|
||||
本書的這一節描述了Swift編程語言的形式語法。這裡描述的語法是為了幫助您更詳細的瞭解該語言，而不是讓您直接實現一個解析器或編譯器。
|
||||
|
||||
|
||||
Swift語言相對小點，這是由於在Swift代碼中幾乎無處不在的許多常見的的類型，函數以及運算符都由Swift標準庫來定義。雖然這些類型，函數和運算符不是Swift語言本身的一部分，但是它們被廣泛用於這本書的討論和代碼範例。
|
||||
|
||||
<a name="how_to_read_the_grammar"></a>
|
||||
## 如何閱讀語法
|
||||
|
||||
用來描述Swift編程語言形式語法的記法遵循下面幾個約定：
|
||||
|
||||
-](https://github.com/numbbbbb)箭頭（→）用來標記語法產式，可以被理](https://github.com/numbbbbb)解為「可以包含」。
|
||||
- 句法範疇由*斜體*文字表示，並出現在一個語法產式規則兩側。
|
||||
- 義詞和標點符號由粗體固定寬度的文本顯示和只出現在一個語法產式規則的右邊。
|
||||
- 選擇性的語法產式由豎線（|）分隔。當可選用的語法產式太多時，為了閱讀方便，它們將被拆分為多行語法產式規則。
|
||||
- 在少數情況下，常規字體文字用來描述語法產式規則的右邊。
|
||||
- 可選的句法範疇和文字用尾標`opt`來標記。
|
||||
|
||||
舉個例子，getter-setter的語法塊的定義如下：
|
||||
|
||||
> GRAMMAR OF A GETTER-SETTER BLOCK
|
||||
> *getter-setter-block* → {- [*getter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause) [-*setter-clause*-](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause)*opt* -}- | {- [*setter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause) [-*getter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause)-}-
|
||||
|
||||
這個定義表明，一個getter-setter方法□□塊可以由一個getter子句後跟一個可選的setter子句構成，用大括號括起來，或者由一個setter子句後跟一個getter子句構成，用大括號括起來。上述的文法產生等價於下面的兩個產生，明確闡明如何二中擇一：
|
||||
|
||||
> GRAMMAR OF A GETTER-SETTER BLOCK
|
||||
> getter-setter-block → {- [*getter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause) [*-setter-clause*-](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause)*opt* -}--
|
||||
> getter-setter-block → {- [*setter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/setter-clause) [*-getter-clause*](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/swift/grammar/getter-clause)-}-
|
||||
238
source-tw/chapter3/02_Lexical_Structure.md
Normal file
238
source-tw/chapter3/02_Lexical_Structure.md
Normal file
@ -0,0 +1,238 @@
|
||||
> 翻譯：[superkam](https://github.com/superkam)
|
||||
> 校對：[numbbbbb](https://github.com/numbbbbb)
|
||||
|
||||
# 詞法結構
|
||||
-----------------
|
||||
|
||||
本頁包含內容：
|
||||
|
||||
- [空白與註釋（*Whitespace and Comments*）](#whitespace_and_comments)
|
||||
- [標識符（*Identifiers*）](#identifiers)
|
||||
- [關鍵字（*Keywords*）](#keywords)
|
||||
- [字面量（*Literals*）](#literals)
|
||||
- [運算符（*Operators*）](#operators)
|
||||
|
||||
Swift 的「詞法結構（*lexical structure*）」描述了如何在該語言中用字符序列構建合法標記，組成該語言中最底層的代碼塊，並在之後的章節中用於描述語言的其他部分。
|
||||
|
||||
通常，標記在隨後介紹的語法約束下，由 Swift 源文件的輸入文本中提取可能的最長子串生成。這種方法稱為「最長匹配項（*longest match*）」，或者「最大適合」（*maximal munch*）。
|
||||
|
||||
<a name="whitespace_and_comments"></a>
|
||||
## 空白與註釋
|
||||
|
||||
空白（*whitespace*）有兩個用途：分隔源文件中的標記和區分運算符屬於前綴還是後綴，（參見 [運算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_871)）在其他情況下則會被忽略。以下的字符會被當作空白：空格（*space*）（U+0020）、換行符（*line feed*）（U+000A）、回車符（*carriage return*）（U+000D）、水平 tab（*horizontal tab*）（U+0009）、垂直 tab（*vertical tab*）（U+000B）、換頁符（*form feed*）（U+000C）以及空（*null*）（U+0000）。
|
||||
|
||||
註釋（*comments*）被編譯器當作空白處理。單行註釋由 `//` 開始直到該行結束。多行註釋由 `/*` 開始，以 `*/` 結束。可以嵌套註釋，但注意註釋標記必須匹配。
|
||||
|
||||
<a name="identifiers"></a>
|
||||
## 標識符
|
||||
|
||||
標識符（*identifiers*）可以由以下的字符開始：大寫或小寫的字母 `A` 到 `Z`、下劃線 `_`、基本多語言面（*Basic Multilingual Plane*）中的 Unicode 非組合字符以及基本多語言面以外的非專用區（*Private Use Area*）字符。首字符之後，標識符允許使用數字和 Unicode 字符組合。
|
||||
|
||||
使用保留字（*reserved word*）作為標識符，需要在其前後增加反引號 <code>\`</code>。例如，<code>class</code> 不是合法的標識符，但可以使用 <code>\`class\`</code>。反引號不屬於標識符的一部分，<code>\`x\`</code> 和 `x` 表示同一標識符。
|
||||
|
||||
閉包（*closure*）中如果沒有明確指定參數名稱，參數將被隱式命名為 <code>$0</code>、<code>$1</code>、<code>$2</code>... 這些命名在閉包作用域內是合法的標識符。
|
||||
|
||||
> 標識符語法
|
||||
> *標識符* → [*標識符頭(Head)*](LexicalStructure.html#identifier_head) [*標識符字符列表*](LexicalStructure.html#identifier_characters) _可選_
|
||||
> *標識符* → **`** [*標識符頭(Head)*](LexicalStructure.html#identifier_head) [*標識符字符列表*](LexicalStructure.html#identifier_characters) _可選_ **`**
|
||||
> *標識符* → [*隱式參數名*](LexicalStructure.html#implicit_parameter_name)
|
||||
> *標識符列表* → [*標識符*](LexicalStructure.html#identifier) | [*標識符*](LexicalStructure.html#identifier) **,** [*標識符列表*](LexicalStructure.html#identifier_list)
|
||||
> *標識符頭(Head)* → Upper- or lowercase letter A through Z
|
||||
> *標識符頭(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA
|
||||
> *標識符頭(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF
|
||||
> *標識符頭(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF
|
||||
> *標識符頭(Head)* → U+1E00–U+1FFF
|
||||
> *標識符頭(Head)* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F
|
||||
> *標識符頭(Head)* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793
|
||||
> *標識符頭(Head)* → U+2C00–U+2DFF or U+2E80–U+2FFF
|
||||
> *標識符頭(Head)* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF
|
||||
> *標識符頭(Head)* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44
|
||||
> *標識符頭(Head)* → U+FE47–U+FFFD
|
||||
> *標識符頭(Head)* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD
|
||||
> *標識符頭(Head)* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD
|
||||
> *標識符頭(Head)* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD
|
||||
> *標識符頭(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD
|
||||
> *標識符字符* → 數值 0 到 9
|
||||
> *標識符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F
|
||||
> *標識符字符* → [*標識符頭(Head)*](LexicalStructure.html#identifier_head)
|
||||
> *標識符字符列表* → [*標識符字符*](LexicalStructure.html#identifier_character) [*標識符字符列表*](LexicalStructure.html#identifier_characters) _可選_
|
||||
> *隱式參數名* → **$** [*十進制數字列表*](LexicalStructure.html#decimal_digits)
|
||||
|
||||
<a name="keywords"></a>
|
||||
## 關鍵字
|
||||
|
||||
被保留的關鍵字（*keywords*）不允許用作標識符，除非被反引號轉義，參見 [標識符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_796)。
|
||||
|
||||
* **用作聲明的關鍵字：** *class*、*deinit*、*enum*、*extension*、*func*、*import*、*init*、*let*、*protocol*、*static*、*struct*、*subscript*、*typealias*、*var*
|
||||
* **用作語句的關鍵字：** *break*、*case*、*continue*、*default*、*do*、*else*、*fallthrough*、*if*、*in*、*for*、*return*、*switch*、*where*、*while*
|
||||
* **用作表達和類型的關鍵字：** *as*、*dynamicType*、*is*、*new*、*super*、*self*、*Self*、*Type*、*\_\_COLUMN\_\_*、*\_\_FILE\_\_*、*\_\_FUNCTION\_\_*、*\_\_LINE\_\_*
|
||||
* **特定上下文中被保留的關鍵字：** *associativity*、*didSet*、*get*、*infix*、*inout*、*left*、*mutating*、*none*、*nonmutating*、*operator*、*override*、*postfix*、
|
||||
*precedence*、*prefix*、*right*、*set*、*unowned*、*unowned(safe)*、*unowned(unsafe)*、*weak*、*willSet*，這些關鍵字在特定上下文之外可以被用於標識符。
|
||||
|
||||
<a name="literals"></a>
|
||||
## 字面量
|
||||
|
||||
字面值表示整型、浮點型數字或文本類型的值，舉例如下：
|
||||
|
||||
```swift
|
||||
42 // 整型字面量
|
||||
3.14159 // 浮點型字面量
|
||||
"Hello, world!" // 文本型字面量
|
||||
```
|
||||
|
||||
> 字面量語法
|
||||
> *字面量* → [*整型字面量*](LexicalStructure.html#integer_literal) | [*浮點數字面量*](LexicalStructure.html#floating_point_literal) | [*字符串字面量*](LexicalStructure.html#string_literal)
|
||||
|
||||
### 整型字面量
|
||||
|
||||
整型字面量（*integer literals*）表示未指定精度整型數的值。整型字面量默認用十進製表示，可以加前綴來指定其他的進制，二進制字面量加 `0b`，八進制字面量加 `0o`，十六進制字面量加 `0x`。
|
||||
|
||||
十進制字面量包含數字 `0` 至 `9`。二進制字面量只包含 `0` 或 `1`，八進制字面量包含數字 `0` 至 `7`，十六進制字面量包含數字 `0` 至 `9` 以及字母 `A` 至 `F` （大小寫均可）。
|
||||
|
||||
負整數的字面量在數字前加減號 `-`，比如 `-42`。
|
||||
|
||||
允許使用下劃線 `_` 來增加數字的可讀性，下劃線不會影響字面量的值。整型字面量也可以在數字前加 `0`，同樣不會影響字面量的值。
|
||||
|
||||
```swift
|
||||
1000_000 // 等於 1000000
|
||||
005 // 等於 5
|
||||
```
|
||||
|
||||
除非特殊指定，整型字面量的默認類型為 Swift 標準庫類型中的 `Int`。Swift 標準庫還定義了其他不同長度以及是否帶符號的整數類型，請參考 [整數類型](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_411)。
|
||||
|
||||
> 整型字面量語法
|
||||
> *整型字面量* → [*二進制字面量*](LexicalStructure.html#binary_literal)
|
||||
> *整型字面量* → [*八進制字面量*](LexicalStructure.html#octal_literal)
|
||||
> *整型字面量* → [*十進制字面量*](LexicalStructure.html#decimal_literal)
|
||||
> *整型字面量* → [*十六進制字面量*](LexicalStructure.html#hexadecimal_literal)
|
||||
> *二進制字面量* → **0b** [*二進制數字*](LexicalStructure.html#binary_digit) [*二進制字面量字符列表*](LexicalStructure.html#binary_literal_characters) _可選_
|
||||
> *二進制數字* → 數值 0 到 1
|
||||
> *二進制字面量字符* → [*二進制數字*](LexicalStructure.html#binary_digit) | **_**
|
||||
> *二進制字面量字符列表* → [*二進制字面量字符*](LexicalStructure.html#binary_literal_character) [*二進制字面量字符列表*](LexicalStructure.html#binary_literal_characters) _可選_
|
||||
> *八進制字面量* → **0o** [*八進字數字*](LexicalStructure.html#octal_digit) [*八進制字符列表*](LexicalStructure.html#octal_literal_characters) _可選_
|
||||
> *八進字數字* → 數值 0 到 7
|
||||
> *八進制字符* → [*八進字數字*](LexicalStructure.html#octal_digit) | **_**
|
||||
> *八進制字符列表* → [*八進制字符*](LexicalStructure.html#octal_literal_character) [*八進制字符列表*](LexicalStructure.html#octal_literal_characters) _可選_
|
||||
> *十進制字面量* → [*十進制數字*](LexicalStructure.html#decimal_digit) [*十進制字符列表*](LexicalStructure.html#decimal_literal_characters) _可選_
|
||||
> *十進制數字* → 數值 0 到 9
|
||||
> *十進制數字列表* → [*十進制數字*](LexicalStructure.html#decimal_digit) [*十進制數字列表*](LexicalStructure.html#decimal_digits) _可選_
|
||||
> *十進制字符* → [*十進制數字*](LexicalStructure.html#decimal_digit) | **_**
|
||||
> *十進制字符列表* → [*十進制字符*](LexicalStructure.html#decimal_literal_character) [*十進制字符列表*](LexicalStructure.html#decimal_literal_characters) _可選_
|
||||
> *十六進制字面量* → **0x** [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制字面量字符列表*](LexicalStructure.html#hexadecimal_literal_characters) _可選_
|
||||
> *十六進制數字* → 數值 0 到 9, a through f, or A through F
|
||||
> *十六進制字符* → [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) | **_**
|
||||
> *十六進制字面量字符列表* → [*十六進制字符*](LexicalStructure.html#hexadecimal_literal_character) [*十六進制字面量字符列表*](LexicalStructure.html#hexadecimal_literal_characters) _可選_
|
||||
|
||||
### 浮點型字面量
|
||||
|
||||
浮點型字面量（*floating-point literals*）表示未指定精度浮點數的值。
|
||||
|
||||
浮點型字面量默認用十進製表示（無前綴），也可以用十六進製表示（加前綴 `0x`）。
|
||||
|
||||
十進制浮點型字面量（*decimal floating-point literals*）由十進制數字串後跟小數部分或指數部分（或兩者皆有）組成。十進制小數部分由小數點 `.` 後跟十進制數字串組成。指數部分由大寫或小寫字母 `e` 後跟十進制數字串組成，這串數字表示 `e` 之前的數量乘以 10 的幾次方。例如：`1.25e2` 表示 `1.25 □ 10^2`，也就是 `125.0`；同樣，`1.25e－2` 表示 `1.25 □ 10^－2`，也就是 `0.0125`。
|
||||
|
||||
十六進制浮點型字面量（*hexadecimal floating-point literals*）由前綴 `0x` 後跟可選的十六進制小數部分以及十六進制指數部分組成。十六進制小數部分由小數點後跟十六進制數字串組成。指數部分由大寫或小寫字母 `p` 後跟十進制數字串組成，這串數字表示 `p` 之前的數量乘以 2 的幾次方。例如：`0xFp2` 表示 `15 □ 2^2`，也就是 `60`；同樣，`0xFp-2` 表示 `15 □ 2^-2`，也就是 `3.75`。
|
||||
|
||||
與整型字面量不同，負的浮點型字面量由一元運算符減號 `-` 和浮點型字面量組成，例如 `-42.0`。這代表一個表達式，而不是一個浮點整型字面量。
|
||||
|
||||
允許使用下劃線 `_` 來增強可讀性，下劃線不會影響字面量的值。浮點型字面量也可以在數字前加 `0`，同樣不會影響字面量的值。
|
||||
|
||||
```swift
|
||||
10_000.56 // 等於 10000.56
|
||||
005000.76 // 等於 5000.76
|
||||
```
|
||||
|
||||
除非特殊指定，浮點型字面量的默認類型為 Swift 標準庫類型中的 `Double`，表示64位浮點數。Swift 標準庫也定義 `Float` 類型，表示32位浮點數。
|
||||
|
||||
> 浮點型字面量語法
|
||||
> *浮點數字面量* → [*十進制字面量*](LexicalStructure.html#decimal_literal) [*十進制分數*](LexicalStructure.html#decimal_fraction) _可選_ [*十進制指數*](LexicalStructure.html#decimal_exponent) _可選_
|
||||
> *浮點數字面量* → [*十六進制字面量*](LexicalStructure.html#hexadecimal_literal) [*十六進制分數*](LexicalStructure.html#hexadecimal_fraction) _可選_ [*十六進制指數*](LexicalStructure.html#hexadecimal_exponent)
|
||||
> *十進制分數* → **.** [*十進制字面量*](LexicalStructure.html#decimal_literal)
|
||||
> *十進制指數* → [*浮點數e*](LexicalStructure.html#floating_point_e) [*正負號*](LexicalStructure.html#sign) _可選_ [*十進制字面量*](LexicalStructure.html#decimal_literal)
|
||||
> *十六進制分數* → **.** [*十六進制字面量*](LexicalStructure.html#hexadecimal_literal) _可選_
|
||||
> *十六進制指數* → [*浮點數p*](LexicalStructure.html#floating_point_p) [*正負號*](LexicalStructure.html#sign) _可選_ [*十六進制字面量*](LexicalStructure.html#hexadecimal_literal)
|
||||
> *浮點數e* → **e** | **E**
|
||||
> *浮點數p* → **p** | **P**
|
||||
> *正負號* → **+** | **-**
|
||||
|
||||
### 文本型字面量
|
||||
|
||||
文本型字面量（*string literal*）由雙引號中的字符串組成，形式如下：
|
||||
|
||||
```swift
|
||||
"characters"
|
||||
```
|
||||
|
||||
文本型字面量中不能包含未轉義的雙引號 `"`、未轉義的反斜線`\`、回車符（*carriage return*）或換行符（*line feed*）。
|
||||
|
||||
可以在文本型字面量中使用的轉義特殊符號如下：
|
||||
|
||||
* 空字符（Null Character）`\0`
|
||||
* 反斜線（Backslash）`\\`
|
||||
* 水平 Tab （Horizontal Tab）`\t`
|
||||
* 換行符（Line Feed）`\n`
|
||||
* 回車符（Carriage Return）`\r`
|
||||
* 雙引號（Double Quote）`\"`
|
||||
* 單引號（Single Quote）`\'`
|
||||
|
||||
字符也可以用以下方式表示：
|
||||
|
||||
* `\x` 後跟兩位十六進制數字
|
||||
* `\u` 後跟四位十六進制數字
|
||||
* `\U` 後跟八位十六進制數字
|
||||
|
||||
後跟的數字表示一個 Unicode 碼點。
|
||||
|
||||
文本型字面量允許在反斜線小括號 `\()` 中插入表達式的值。插入表達式（*interpolated expression*）不能包含未轉義的雙引號 `"`、反斜線 `\`、回車符或者換行符。表達式值的類型必須在 *String* 類中有對應的初始化方法。
|
||||
|
||||
例如，以下所有文本型字面量的值相同：
|
||||
|
||||
```swift
|
||||
"1 2 3"
|
||||
"1 2 \(3)"
|
||||
"1 2 \(1 + 2)"
|
||||
var x = 3; "1 2 \(x)"
|
||||
```
|
||||
|
||||
文本型字面量的默認類型為 `String`。組成字符串的字符類型為 `Character`。更多有關 `String` 和 `Character` 的信息請參照 [字符串和字符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/StringsAndCharacters.html#//apple_ref/doc/uid/TP40014097-CH7-XID_368)。
|
||||
|
||||
> 字符型字面量語法
|
||||
> *字符串字面量* → **"** [*引用文本*](LexicalStructure.html#quoted_text) **"**
|
||||
> *引用文本* → [*引用文本條目*](LexicalStructure.html#quoted_text_item) [*引用文本*](LexicalStructure.html#quoted_text) _可選_
|
||||
> *引用文本條目* → [*轉義字符*](LexicalStructure.html#escaped_character)
|
||||
> *引用文本條目* → **\(** [*表達式*](..\chapter3\04_Expressions.html#expression) **)**
|
||||
> *引用文本條目* → 除了"-, \-, U+000A, or U+000D的所有Unicode的字符
|
||||
> *轉義字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**
|
||||
> *轉義字符* → **\x** [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit)
|
||||
> *轉義字符* → **\u** [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit)
|
||||
> *轉義字符* → **\U** [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit) [*十六進制數字*](LexicalStructure.html#hexadecimal_digit)
|
||||
|
||||
<a name="operators"></a>
|
||||
## 運算符
|
||||
|
||||
Swift 標準庫定義了許多可供使用的運算符，其中大部分在 [基礎運算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/BasicOperators.html#//apple_ref/doc/uid/TP40014097-CH6-XID_70) 和 [高級運算符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_28) 中進行了闡述。這裡將描述哪些字符能用作運算符。
|
||||
|
||||
運算符由一個或多個以下字符組成：
|
||||
`/`、`=`、`-`、`+`、`!`、`*`、`%`、`<`、`>`、`&`、`|`、`^`、`~`、`.`。也就是說，標記 `=`, `->`、`//`、`/*`、`*/`、`.` 以及一元前綴運算符 `&` 屬於保留字，這些標記不能被重寫或用於自定義運算符。
|
||||
|
||||
運算符兩側的空白被用來區分該運算符是否為前綴運算符（*prefix operator*）、後綴運算符（*postfix operator*）或二元運算符（*binary operator*）。規則總結如下：
|
||||
|
||||
* 如果運算符兩側都有空白或兩側都無空白，將被看作二元運算符。例如：`a+b` 和 `a + b` 中的運算符 `+` 被看作二元運算符。
|
||||
* 如果運算符只有左側空白，將被看作前綴一元運算符。例如 `a ++b` 中的 `++` 被看作前綴一元運算符。
|
||||
* 如果運算符只有右側空白，將被看作後綴一元運算符。例如 `a++ b` 中的 `++` 被看作後綴一元運算符。
|
||||
* 如果運算符左側沒有空白並緊跟 `.`，將被看作後綴一元運算符。例如 `a++.b` 中的 `++` 被看作後綴一元運算符（同理， `a++ . b` 中的 `++` 是後綴一元運算符而 `a ++ .b` 中的 `++` 不是）.
|
||||
|
||||
鑒於這些規則，運算符前的字符 `(`、`[` 和 `{` ；運算符後的字符 `)`、`]` 和 `}` 以及字符 `,`、`;` 和 `:` 都將用於空白檢測。
|
||||
|
||||
以上規則需注意一點，如果運算符 `!` 或 `?` 左側沒有空白，則不管右側是否有空白都將被看作後綴運算符。如果將 `?` 用作可選類型（*optional type*）修飾，左側必須無空白。如果用於條件運算符 `? :`，必須兩側都有空白。
|
||||
|
||||
在特定構成中 ，以 `<` 或 `>` 開頭的運算符會被分離成兩個或多個標記，剩餘部分以同樣的方式會被再次分離。因此，在 `Dictionary<String, Array<Int>>` 中沒有必要添加空白來消除閉合字符 `>` 的歧義。在這個例子中， 閉合字符 `>` 被看作單字符標記，而不會被誤解為移位運算符 `>>`。
|
||||
|
||||
要學習如何自定義新的運算符，請參考 [自定義操作符](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48) 和 [運算符聲明](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_644)。學習如何重寫現有運算符，請參考 [運算符方法](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_43)。
|
||||
|
||||
> 運算符語法語法
|
||||
> *運算符* → [*運算符字符*](LexicalStructure.html#operator_character) [*運算符*](LexicalStructure.html#operator) _可選_
|
||||
> *運算符字符* → **/** | **=** | **-** | **+** | **!** | ***** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **.**
|
||||
> *二元運算符* → [*運算符*](LexicalStructure.html#operator)
|
||||
> *前置運算符* → [*運算符*](LexicalStructure.html#operator)
|
||||
> *後置運算符* → [*運算符*](LexicalStructure.html#operator)
|
||||
300
source-tw/chapter3/03_Types.md
Normal file
300
source-tw/chapter3/03_Types.md
Normal file
@ -0,0 +1,300 @@
|
||||
> 翻譯：[lyuka](https://github.com/lyuka)
|
||||
> 校對：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
|
||||
|
||||
# 類型（Types）
|
||||
-----------------
|
||||
|
||||
本頁包含內容：
|
||||
|
||||
- [類型註解（Type Annotation）](#type_annotation)
|
||||
- [類型標識符（Type Identifier）](#type_identifier)
|
||||
- [元組類型（Tuple Type）](#tuple_type)
|
||||
- [函數類型（Function Type）](#function_type)
|
||||
- [數組類型（Array Type）](#array_type)
|
||||
- [可選類型（Optional Type）](#optional_type)
|
||||
- [隱式解析可選類型（Implicitly Unwrapped Optional Type）](#implicitly_unwrapped_optional_type)
|
||||
- [協議合成類型（Protocol Composition Type）](#protocol_composition_type)
|
||||
- [元類型（Metatype Type）](#metatype_type)
|
||||
- [類型繼承子句（Type Inheritance Clause）](#type_inheritance_clause)
|
||||
- [類型推斷（Type Inference）](#type_inference)
|
||||
|
||||
Swift 語言存在兩種類型：命名型類型和複合型類型。*命名型類型*是指定義時可以給定名字的類型。命名型類型包括類、結構體、枚舉和協議。比如，一個用戶定義的類`MyClass`的實例擁有類型`MyClass`。除了用戶定義的命名型類型，Swift 標準庫也定義了很多常用的命名型類型，包括那些表示數組、字典和可選值的類型。
|
||||
|
||||
那些通常被其它語言認為是基本或初級的數據型類型（Data types）——比如表示數字、字符和字符串——實際上就是命名型類型，Swift 標準庫是使用結構體定義和實現它們的。因為它們是命名型類型，因此你可以按照「擴展和擴展聲明」章節裡討論的那樣，聲明一個擴展來增加它們的行為以適應你程序的需求。
|
||||
|
||||
*複合型類型*是沒有名字的類型，它由 Swift 本身定義。Swift 存在兩種複合型類型：函數類型和元組類型。一個複合型類型可以包含命名型類型和其它複合型類型。例如，元組類型`(Int, (Int, Int))`包含兩個元素：第一個是命名型類型`Int`，第二個是另一個複合型類型`(Int, Int)`.
|
||||
|
||||
本節討論 Swift 語言本身定義的類型，並描述 Swift 中的類型推斷行為。
|
||||
|
||||
> 類型語法
|
||||
> *類型* → [*數組類型*](..\chapter3\03_Types.html#array_type) | [*函數類型*](..\chapter3\03_Types.html#function_type) | [*類型標識*](..\chapter3\03_Types.html#type_identifier) | [*元組類型*](..\chapter3\03_Types.html#tuple_type) | [*可選類型*](..\chapter3\03_Types.html#optional_type) | [*隱式解析可選類型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*協議合成類型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型類型*](..\chapter3\03_Types.html#metatype_type)
|
||||
|
||||
<a name="type_annotation"></a>
|
||||
##類型註解
|
||||
|
||||
類型註解顯式地指定一個變量或表達式的值。類型註解始於冒號`:`終於類型，比如下面兩個例子：
|
||||
|
||||
```swift
|
||||
let someTuple: (Double, Double) = (3.14159, 2.71828)
|
||||
func someFunction(a: Int){ /* ... */ }
|
||||
```
|
||||
在第一個例子中，表達式`someTuple`的類型被指定為`(Double, Double)`。在第二個例子中，函數`someFunction`的參數`a`的類型被指定為`Int`。
|
||||
|
||||
類型註解可以在類型之前包含一個類型特性（type attributes）的可選列表。
|
||||
|
||||
> 類型註解語法
|
||||
> *類型註解* → **:** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<a name="type_identifier"></a>
|
||||
##類型標識符
|
||||
|
||||
類型標識符引用命名型類型或者是命名型/複合型類型的別名。
|
||||
|
||||
大多數情況下，類型標識符引用的是同名的命名型類型。例如類型標識符`Int`引用命名型類型`Int`，同樣，類型標識符`Dictionary<String, Int>`引用命名型類型`Dictionary<String, Int>`。
|
||||
|
||||
在兩種情況下類型標識符引用的不是同名的類型。情況一，類型標識符引用的是命名型/複合型類型的類型別名。比如，在下面的例子中，類型標識符使用`Point`來引用元組`(Int, Int)`：
|
||||
|
||||
```swift
|
||||
typealias Point = (Int, Int)
|
||||
let origin: Point = (0, 0)
|
||||
```
|
||||
|
||||
情況二，類型標識符使用dot(`.`)語法來表示在其它模塊（modules）或其它類型嵌套內聲明的命名型類型。例如，下面例子中的類型標識符引用在`ExampleModule`模塊中聲明的命名型類型`MyType`：
|
||||
|
||||
```swift
|
||||
var someValue: ExampleModule.MyType
|
||||
```
|
||||
|
||||
> 類型標識語法
|
||||
> *類型標識* → [*類型名稱*](..\chapter3\03_Types.html#type_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_argument_clause) _可選_ | [*類型名稱*](..\chapter3\03_Types.html#type_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_argument_clause) _可選_ **.** [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
> *類名* → [*標識符*](LexicalStructure.html#identifier)
|
||||
|
||||
<a name="tuple_type"></a>
|
||||
##元組類型
|
||||
|
||||
元組類型使用逗號隔開並使用括號括起來的0個或多個類型組成的列表。
|
||||
|
||||
你可以使用元組類型作為一個函數的返回類型，這樣就可以使函數返回多個值。你也可以命名元組類型中的元素，然後用這些名字來引用每個元素的值。元素的名字由一個標識符和`:`組成。「函數和多返回值」章節裡有一個展示上述特性的例子。
|
||||
|
||||
`void`是空元組類型`()`的別名。如果括號內只有一個元素，那麼該類型就是括號內元素的類型。比如，`(Int)`的類型是`Int`而不是`(Int)`。所以，只有當元組類型包含兩個元素以上時才可以標記元組元素。
|
||||
|
||||
> 元組類型語法
|
||||
> *元組類型* → **(** [*元組類型主體*](..\chapter3\03_Types.html#tuple_type_body) _可選_ **)**
|
||||
> *元組類型主體* → [*元組類型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可選_
|
||||
> *元組類型的元素列表* → [*元組類型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元組類型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元組類型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list)
|
||||
> *元組類型的元素* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **inout** _可選_ [*類型*](..\chapter3\03_Types.html#type) | **inout** _可選_ [*元素名*](..\chapter3\03_Types.html#element_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation)
|
||||
> *元素名* → [*標識符*](LexicalStructure.html#identifier)
|
||||
|
||||
<a name="function_type"></a>
|
||||
##函數類型
|
||||
|
||||
函數類型表示一個函數、方法或閉包的類型，它由一個參數類型和返回值類型組成，中間用箭頭`->`隔開：
|
||||
|
||||
- `parameter type` -> `return type`
|
||||
|
||||
由於 *參數類型* 和 *返回值類型* 可以是元組類型，所以函數類型可以讓函數與方法支持多參數與多返回值。
|
||||
|
||||
你可以對函數類型應用帶有參數類型`()`並返回表達式類型的`auto_closure`屬性（見類型屬性章節）。一個自動閉包涵數捕獲特定表達式上的隱式閉包而非表達式本身。下面的例子使用`auto_closure`屬性來定義一個很簡單的assert函數：
|
||||
|
||||
```swift
|
||||
func simpleAssert(condition: @auto_closure () -> Bool, message: String){
|
||||
if !condition(){
|
||||
println(message)
|
||||
}
|
||||
}
|
||||
let testNumber = 5
|
||||
simpleAssert(testNumber % 2 == 0, "testNumber isn't an even number.")
|
||||
// prints "testNumber isn't an even number."
|
||||
```
|
||||
函數類型可以擁有一個可變長參數作為參數類型中的最後一個參數。從語法角度上講，可變長參數由一個基礎類型名字和`...`組成，如`Int...`。可變長參數被認為是一個包含了基礎類型元素的數組。即`Int...`就是`Int[]`。關於使用可變長參數的例子，見章節「可變長參數」。
|
||||
|
||||
為了指定一個`in-out`參數，可以在參數類型前加`inout`前綴。但是你不可以對可變長參數或返回值類型使用`inout`。關於In-Out參數的討論見章節In-Out參數部分。
|
||||
|
||||
柯裡化函數（curried function）的類型相當於一個嵌套函數類型。例如，下面的柯裡化函數`addTwoNumber()()`的類型是`Int -> Int -> Int`：
|
||||
|
||||
```swift
|
||||
func addTwoNumbers(a: Int)(b: Int) -> Int{
|
||||
return a + b
|
||||
}
|
||||
addTwoNumbers(4)(5) // returns 9
|
||||
```
|
||||
|
||||
柯裡化函數的函數類型從右向左組成一組。例如，函數類型`Int -> Int -> Int`可以被理解為`Int -> (Int -> Int)`——也就是說，一個函數傳入一個`Int`然後輸出作為另一個函數的輸入，然後又返回一個`Int`。例如，你可以使用如下嵌套函數來重寫柯裡化函數`addTwoNumbers()()`：
|
||||
|
||||
```swift
|
||||
func addTwoNumbers(a: Int) -> (Int -> Int){
|
||||
func addTheSecondNumber(b: Int) -> Int{
|
||||
return a + b
|
||||
}
|
||||
return addTheSecondNumber
|
||||
}
|
||||
addTwoNumbers(4)(5) // Returns 9
|
||||
```
|
||||
|
||||
> 函數類型語法
|
||||
> *函數類型* → [*類型*](..\chapter3\03_Types.html#type) **->** [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<a name="array_type"></a>
|
||||
##數組類型
|
||||
|
||||
Swift語言使用類型名緊接中括號`[]`來簡化標準庫中定義的命名型類型`Array<T>`。換句話說，下面兩個聲明是等價的：
|
||||
|
||||
```swift
|
||||
let someArray: String[] = ["Alex", "Brian", "Dave"]
|
||||
let someArray: Array<String> = ["Alex", "Brian", "Dave"]
|
||||
```
|
||||
上面兩種情況下，常量`someArray`都被聲明為字符串數組。數組的元素也可以通過`[]`獲取訪問：`someArray[0]`是指第0個元素`「Alex」`。
|
||||
|
||||
上面的例子同時顯示，你可以使用`[]`作為初始值構造數組，空的`[]`則用來來構造指定類型的空數組。
|
||||
|
||||
```swift
|
||||
var emptyArray: Double[] = []
|
||||
```
|
||||
你也可以使用鏈接起來的多個`[]`集合來構造多維數組。例如，下例使用三個`[]`集合來構造三維整型數組：
|
||||
|
||||
```swift
|
||||
var array3D: Int[][][] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
|
||||
```
|
||||
訪問一個多維數組的元素時，最左邊的下標指向最外層數組的相應位置元素。接下來往右的下標指向第一層嵌入的相應位置元素，依次類推。這就意味著，在上面的例子中，`array3D[0]`是指`[[1, 2], [3, 4]]`，`array3D[0][1]`是指`[3, 4]`，`array3D[0][1][1]`則是指值`4`。
|
||||
|
||||
關於Swift標準庫中`Array`類型的細節討論，見章節Arrays。
|
||||
|
||||
> 數組類型語法
|
||||
> *數組類型* → [*類型*](..\chapter3\03_Types.html#type) **[** **]** | [*數組類型*](..\chapter3\03_Types.html#array_type) **[** **]**
|
||||
|
||||
<a name="optional_type"></a>
|
||||
##可選類型
|
||||
|
||||
Swift定義後綴`?`來作為標準庫中的定義的命名型類型`Optional<T>`的簡寫。換句話說，下面兩個聲明是等價的：
|
||||
|
||||
```swift
|
||||
var optionalInteger: Int?
|
||||
var optionalInteger: Optional<Int>
|
||||
```
|
||||
在上述兩種情況下，變量`optionalInteger`都被聲明為可選整型類型。注意在類型和`?`之間沒有空格。
|
||||
|
||||
類型`Optional<T>`是一個枚舉，有兩種形式，`None`和`Some(T)`，又來代表可能出現或可能不出現的值。任意類型都可以被顯式的聲明（或隱式的轉換）為可選類型。當聲明一個可選類型時，確保使用括號給`?`提供合適的作用範圍。比如說，聲明一個整型的可選數組，應寫作`(Int[])?`，寫成`Int[]?`的話則會出錯。
|
||||
|
||||
如果你在聲明或定義可選變量或特性的時候沒有提供初始值，它的值則會自動賦成缺省值`nil`。
|
||||
|
||||
可選符合`LogicValue`協議，因此可以出現在布爾值環境下。此時，如果一個可選類型`T?`實例包含有類型為`T`的值（也就是說值為`Optional.Some(T)`），那麼此可選類型就為`true`，否則為`false`。
|
||||
|
||||
如果一個可選類型的實例包含一個值，那麼你就可以使用後綴操作符`!`來獲取該值，正如下面描述的：
|
||||
|
||||
```swift
|
||||
optionalInteger = 42
|
||||
optionalInteger! // 42
|
||||
```
|
||||
使用`!`操作符獲取值為`nil`的可選項會導致運行錯誤（runtime error）。
|
||||
|
||||
你也可以使用可選鏈和可選綁定來選擇性的執行可選表達式上的操作。如果值為`nil`，不會執行任何操作因此也就沒有運行錯誤產生。
|
||||
|
||||
更多細節以及更多如何使用可選類型的例子，見章節「可選」。
|
||||
|
||||
> 可選類型語法
|
||||
> *可選類型* → [*類型*](..\chapter3\03_Types.html#type) **?**
|
||||
|
||||
<a name="implicitly_unwrapped_optional_type"></a>
|
||||
##隱式解析可選類型
|
||||
|
||||
Swift語言定義後綴`!`作為標準庫中命名類型`ImplicitlyUnwrappedOptional<T>`的簡寫。換句話說，下面兩個聲明等價：
|
||||
|
||||
```swift
|
||||
var implicitlyUnwrappedString: String!
|
||||
var implicitlyUnwrappedString: ImplicitlyUnwrappedOptional<String>
|
||||
```
|
||||
上述兩種情況下，變量`implicitlyUnwrappedString`被聲明為一個隱式解析可選類型的字符串。注意類型與`!`之間沒有空格。
|
||||
|
||||
你可以在使用可選的地方同樣使用隱式解析可選。比如，你可以將隱式解析可選的值賦給變量、常量和可選特性，反之亦然。
|
||||
|
||||
有了可選，你在聲明隱式解析可選變量或特性的時候就不用指定初始值，因為它有缺省值`nil`。
|
||||
|
||||
由於隱式解析可選的值會在使用時自動解析，所以沒必要使用操作符`!`來解析它。也就是說，如果你使用值為`nil`的隱式解析可選，就會導致運行錯誤。
|
||||
|
||||
使用可選鏈會選擇性的執行隱式解析可選表達式上的某一個操作。如果值為`nil`，就不會執行任何操作，因此也不會產生運行錯誤。
|
||||
|
||||
關於隱式解析可選的更多細節，見章節「隱式解析可選」。
|
||||
|
||||
> 隱式解析可選類型(Implicitly Unwrapped Optional Type)語法
|
||||
> *隱式解析可選類型* → [*類型*](..\chapter3\03_Types.html#type) **!**
|
||||
|
||||
<a name="protocol_composition_type"></a>
|
||||
##協議合成類型
|
||||
|
||||
協議合成類型是一種符合每個協議的指定協議列表類型。協議合成類型可能會用在類型註解和泛型參數中。
|
||||
|
||||
協議合成類型的形式如下：
|
||||
|
||||
```swift
|
||||
protocol<Protocol 1, Procotol 2>
|
||||
```
|
||||
|
||||
協議合成類型允許你指定一個值，其類型可以適配多個協議的條件，而且不需要定義一個新的命名型協議來繼承其它想要適配的各個協議。比如，協議合成類型`protocol<Protocol A, Protocol B, Protocol C>`等效於一個從`Protocol A`，`Protocol B`， `Protocol C`繼承而來的新協議`Protocol D`，很顯然這樣做有效率的多，甚至不需引入一個新名字。
|
||||
|
||||
協議合成列表中的每項必須是協議名或協議合成類型的類型別名。如果列表為空，它就會指定一個空協議合成列表，這樣每個類型都能適配。
|
||||
|
||||
> 協議合成類型語法
|
||||
> *協議合成類型* → **protocol** **<** [*協議標識符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可選_ **>**
|
||||
> *協議標識符列表* → [*協議標識符*](..\chapter3\03_Types.html#protocol_identifier) | [*協議標識符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*協議標識符列表*](..\chapter3\03_Types.html#protocol_identifier_list)
|
||||
> *協議標識符* → [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
|
||||
<a name="metatype_type"></a>
|
||||
##元類型
|
||||
|
||||
元類型是指所有類型的類型，包括類、結構體、枚舉和協議。
|
||||
|
||||
類、結構體或枚舉類型的元類型是相應的類型名緊跟`.Type`。協議類型的元類型——並不是運行時適配該協議的具體類型——是該協議名字緊跟`.Protocol`。比如，類`SomeClass`的元類型就是`SomeClass.Type`，協議`SomeProtocol`的元類型就是`SomeProtocal.Protocol`。
|
||||
|
||||
你可以使用後綴`self`表達式來獲取類型。比如，`SomeClass.self`返回`SomeClass`本身，而不是`SomeClass`的一個實例。同樣，`SomeProtocol.self`返回`SomeProtocol`本身，而不是運行時適配`SomeProtocol`的某個類型的實例。還可以對類型的實例使用`dynamicType`表達式來獲取該實例在運行階段的類型，如下所示：
|
||||
|
||||
```swift
|
||||
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
|
||||
```
|
||||
|
||||
> 元(Metatype)類型語法
|
||||
> *元類型* → [*類型*](..\chapter3\03_Types.html#type) **.** **Type** | [*類型*](..\chapter3\03_Types.html#type) **.** **Protocol** x
|
||||
|
||||
<a name="type_inheritance_clause"></a>
|
||||
##類型繼承子句
|
||||
|
||||
類型繼承子句被用來指定一個命名型類型繼承哪個類且適配哪些協議。類型繼承子句開始於冒號`:`，緊跟由`,`隔開的類型標識符列表。
|
||||
|
||||
類可以繼承單個超類，適配任意數量的協議。當定義一個類時，超類的名字必須出現在類型標識符列表首位，然後跟上該類需要適配的任意數量的協議。如果一個類不是從其它類繼承而來，那麼列表可以以協議開頭。關於類繼承更多的討論和例子，見章節「繼承」。
|
||||
|
||||
其它命名型類型可能只繼承或適配一個協議列表。協議類型可能繼承於其它任意數量的協議。當一個協議類型繼承於其它協議時，其它協議的條件集合會被集成在一起，然後其它從當前協議繼承的任意類型必須適配所有這些條件。
|
||||
|
||||
枚舉定義中的類型繼承子句可以是一個協議列表，或是指定原始值的枚舉，一個單獨的指定原始值類型的命名型類型。使用類型繼承子句來指定原始值類型的枚舉定義的例子，見章節「原始值」。
|
||||
|
||||
> 類型繼承子句語法
|
||||
> *類型繼承子句* → **:** [*類型繼承列表*](..\chapter3\03_Types.html#type_inheritance_list)
|
||||
> *類型繼承列表* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) | [*類型標識*](..\chapter3\03_Types.html#type_identifier) **,** [*類型繼承列表*](..\chapter3\03_Types.html#type_inheritance_list)
|
||||
|
||||
<a name="type_inference"></a>
|
||||
##類型推斷
|
||||
|
||||
Swift廣泛的使用類型推斷，從而允許你可以忽略很多變量和表達式的類型或部分類型。比如，對於`var x: Int = 0`，你可以完全忽略類型而簡寫成`var x = 0`——編譯器會正確的推斷出`x`的類型`Int`。類似的，當完整的類型可以從上下文推斷出來時，你也可以忽略類型的一部分。比如，如果你寫了`let dict: Dictionary = ["A": 1]`，編譯提也能推斷出`dict`的類型是`Dictionary<String, Int>`。
|
||||
|
||||
在上面的兩個例子中，類型信息從表達式樹（expression tree）的葉子節點傳向根節點。也就是說，`var x: Int = 0`中`x`的類型首先根據`0`的類型進行推斷，然後將該類型信息傳遞到根節點（變量`x`）。
|
||||
|
||||
在Swift中，類型信息也可以反方向流動——從根節點傳向葉子節點。在下面的例子中，常量`eFloat`上的顯式類型註解（`:Float`）導致數字字面量`2.71828`的類型是`Float`而非`Double`。
|
||||
|
||||
```swift
|
||||
let e = 2.71828 // The type of e is inferred to be Double.
|
||||
let eFloat: Float = 2.71828 // The type of eFloat is Float.
|
||||
```
|
||||
|
||||
Swift中的類型推斷在單獨的表達式或語句水平上進行。這意味著所有用於推斷類型的信息必須可以從表達式或其某個子表達式的類型檢查中獲取。
|
||||
637
source-tw/chapter3/04_Expressions.md
Normal file
637
source-tw/chapter3/04_Expressions.md
Normal file
@ -0,0 +1,637 @@
|
||||
> 翻譯：[sg552](https://github.com/sg552)
|
||||
> 校對：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
|
||||
|
||||
# 表達式（Expressions）
|
||||
-----------------
|
||||
|
||||
本頁包含內容：
|
||||
|
||||
- [前綴表達式（Prefix Expressions）](#prefix_expressions)
|
||||
- [二元表達式（Binary Expressions）](#binary_expressions)
|
||||
- [賦值表達式（Assignment Operator）](#assignment_operator)
|
||||
- [三元條件運算符（Ternary Conditional Operator）](#ternary_conditional_operator)
|
||||
- [類型轉換運算符（Type-Casting Operators）](#type-casting_operators)
|
||||
- [主要表達式（Primary Expressions）](#primary_expressions)
|
||||
- [後綴表達式（Postfix Expressions）](#postfix_expressions)
|
||||
|
||||
Swift 中存在四種表達式： 前綴（prefix）表達式，二元（binary）表達式，主要（primary）表達式和後綴（postfix）表達式。表達式可以返回一個值，以及運行某些邏輯（causes a side effect）。
|
||||
|
||||
前綴表達式和二元表達式就是對某些表達式使用各種運算符（operators）。 主要表達式是最短小的表達式，它提供了獲取（變量的）值的一種途徑。 後綴表達式則允許你建立複雜的表達式，例如配合函數調用和成員訪問。 每種表達式都在下面有詳細論述～
|
||||
|
||||
> 表達式語法
|
||||
> *表達式* → [*前置表達式*](..\chapter3\04_Expressions.html#prefix_expression) [*二元表達式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可選_
|
||||
> *表達式列表* → [*表達式*](..\chapter3\04_Expressions.html#expression) | [*表達式*](..\chapter3\04_Expressions.html#expression) **,** [*表達式列表*](..\chapter3\04_Expressions.html#expression_list)
|
||||
|
||||
<a name="prefix_expressions"></a>
|
||||
## 前綴表達式（Prefix Expressions）
|
||||
|
||||
前綴表達式由 前綴符號和表達式組成。（這個前綴符號只能接收一個參數）
|
||||
|
||||
Swift 標準庫支持如下的前綴操作符：
|
||||
|
||||
- ++ 自增1 （increment）
|
||||
- -- 自減1 （decrement）
|
||||
- ! 邏輯否 （Logical NOT ）
|
||||
- ~ 按位否 （Bitwise NOT ）
|
||||
- \+ 加（Unary plus）
|
||||
- \- 減（Unary minus）
|
||||
|
||||
對於這些操作符的使用，請參見： Basic Operators and Advanced Operators
|
||||
|
||||
作為對上面標準庫運算符的補充，你也可以對 某個函數的參數使用 '&'運算符。 更多信息，請參見： "In-Out parameters".
|
||||
|
||||
> 前置表達式語法
|
||||
> *前置表達式* → [*前置運算符*](LexicalStructure.html#prefix_operator) _可選_ [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression)
|
||||
> *前置表達式* → [*寫入寫出(in-out)表達式*](..\chapter3\04_Expressions.html#in_out_expression)
|
||||
> *寫入寫出(in-out)表達式* → **&** [*標識符*](LexicalStructure.html#identifier)
|
||||
|
||||
<a name="binary_expressions"></a>
|
||||
## 二元表達式（Binary Expressions）
|
||||
|
||||
二元表達式由 "左邊參數" + "二元運算符" + "右邊參數" 組成, 它有如下的形式：
|
||||
|
||||
> `left-hand argument` `operator` `right-hand argument`
|
||||
|
||||
Swift 標準庫提供了如下的二元運算符：
|
||||
|
||||
- 求冪相關（無結合，優先級160）
|
||||
- << 按位左移（Bitwise left shift）
|
||||
- >> 按位右移（Bitwise right shift）
|
||||
- 乘除法相關（左結合，優先級150）
|
||||
- \* 乘
|
||||
- / 除
|
||||
- % 求余
|
||||
- &* 乘法，忽略溢出（ Multiply, ignoring overflow）
|
||||
- &/ 除法，忽略溢出（Divide, ignoring overflow）
|
||||
- &% 求余, 忽略溢出（ Remainder, ignoring overflow）
|
||||
- & 位與（ Bitwise AND）
|
||||
- 加減法相關（左結合, 優先級140）
|
||||
- \+ 加
|
||||
- \- 減
|
||||
- &+ Add with overflow
|
||||
- &- Subtract with overflow
|
||||
- | 按位或（Bitwise OR ）
|
||||
- ^ 按位異或（Bitwise XOR）
|
||||
- Range （無結合,優先級 135）
|
||||
- .. 半閉值域 Half-closed range
|
||||
- ... 全閉值域 Closed range
|
||||
- 類型轉換 （無結合,優先級 132）
|
||||
- is 類型檢查（ type check）
|
||||
- as 類型轉換（ type cast）
|
||||
- Comparative （無結合,優先級 130）
|
||||
- < 小於
|
||||
- <= 小於等於
|
||||
- > 大於
|
||||
- >= 大於等於
|
||||
- == 等於
|
||||
- != 不等
|
||||
- === 恆等於
|
||||
- !== 不恆等
|
||||
- ~= 模式匹配（ Pattern match）
|
||||
- 合取（ Conjunctive） （左結合,優先級 120）
|
||||
- && 邏輯與（Logical AND）
|
||||
- 析取（Disjunctive） （左結合,優先級 110）
|
||||
- || 邏輯或（ Logical OR）
|
||||
- 三元條件（Ternary Conditional ）（右結合,優先級 100）
|
||||
- ?: 三元條件 Ternary conditional
|
||||
- 賦值 （Assignment） （右結合, 優先級 90）
|
||||
- = 賦值（Assign）
|
||||
- *= Multiply and assign
|
||||
- /= Divide and assign
|
||||
- %= Remainder and assign
|
||||
- += Add and assign
|
||||
- -= Subtract and assign
|
||||
- <<= Left bit shift and assign
|
||||
- >>= Right bit shift and assign
|
||||
- &= Bitwise AND and assign
|
||||
- ^= Bitwise XOR and assign
|
||||
- |= Bitwise OR and assign
|
||||
- &&= Logical AND and assign
|
||||
- ||= Logical OR and assign
|
||||
|
||||
關於這些運算符（operators）的更多信息，請參見：Basic Operators and Advanced Operators.
|
||||
|
||||
> 注意
|
||||
> 在解析時, 一個二元表達式表示為一個一級數組（a flat list）, 這個數組（List）根據運算符的先後順序，被轉換成了一個tree. 例如： 2 + 3 * 5 首先被認為是： 2, + , `` 3``, *, 5. 隨後它被轉換成 tree （2 + （3 * 5））
|
||||
|
||||
<p></p>
|
||||
|
||||
> 二元表達式語法
|
||||
> *二元表達式* → [*二元運算符*](LexicalStructure.html#binary_operator) [*前置表達式*](..\chapter3\04_Expressions.html#prefix_expression)
|
||||
> *二元表達式* → [*賦值運算符*](..\chapter3\04_Expressions.html#assignment_operator) [*前置表達式*](..\chapter3\04_Expressions.html#prefix_expression)
|
||||
> *二元表達式* → [*條件運算符*](..\chapter3\04_Expressions.html#conditional_operator) [*前置表達式*](..\chapter3\04_Expressions.html#prefix_expression)
|
||||
> *二元表達式* → [*類型轉換運算符*](..\chapter3\04_Expressions.html#type_casting_operator)
|
||||
> *二元表達式列表* → [*二元表達式*](..\chapter3\04_Expressions.html#binary_expression) [*二元表達式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可選_
|
||||
|
||||
|
||||
<a name="assignment_operator"></a>
|
||||
## 賦值表達式（Assignment Operator）
|
||||
|
||||
賦值表達式會對某個給定的表達式賦值。 它有如下的形式；
|
||||
|
||||
> `expression` = `value`
|
||||
|
||||
就是把右邊的 *value* 賦值給左邊的 *expression*. 如果左邊的*expression* 需要接收多個參數（是一個tuple ），那麼右邊必須也是一個具有同樣數量參數的tuple. （允許嵌套的tuple）
|
||||
|
||||
```swift
|
||||
(a, _, (b, c)) = ("test", 9.45, (12, 3))
|
||||
// a is "test", b is 12, c is 3, and 9.45 is ignored
|
||||
```
|
||||
|
||||
賦值運算符不返回任何值。
|
||||
|
||||
> 賦值運算符語法
|
||||
> *賦值運算符* → **=**
|
||||
|
||||
<a name="ternary_conditional_operator"></a>
|
||||
## 三元條件運算符（Ternary Conditional Operator）
|
||||
|
||||
三元條件運算符 是根據條件來獲取值。 形式如下：
|
||||
|
||||
> `condition` ? `expression used if true` : `expression used if false`
|
||||
|
||||
如果 `condition` 是true, 那麼返回 第一個表達式的值（此時不會調用第二個表達式）， 否則返回第二個表達式的值（此時不會調用第一個表達式）。
|
||||
|
||||
想看三元條件運算符的例子，請參見： Ternary Conditional Operator.
|
||||
|
||||
> 三元條件運算符語法
|
||||
> *三元條件運算符* → **?** [*表達式*](..\chapter3\04_Expressions.html#expression) **:**
|
||||
|
||||
<a name="type-casting_operators"></a>
|
||||
## 類型轉換運算符（Type-Casting Operators）
|
||||
|
||||
有兩種類型轉換操作符： as 和 is. 它們有如下的形式：
|
||||
|
||||
> `expression` as `type`
|
||||
> `expression` as? `type`
|
||||
> `expression` is `type`
|
||||
|
||||
as 運算符會把`目標表達式`轉換成指定的`類型`（specified type），過程如下：
|
||||
|
||||
- 如果類型轉換成功， 那麼目標表達式就會返回指定類型的實例（instance）. 例如：把子類（subclass）變成父類（superclass）時.
|
||||
- 如果轉換失敗，則會拋出編譯錯誤（ compile-time error）。
|
||||
- 如果上述兩個情況都不是（也就是說，編譯器在編譯時期無法確定轉換能否成功，） 那麼目標表達式就會變成指定的類型的optional. （is an optional of the specified type ） 然後在運行時，如果轉換成功， 目標表達式就會作為 optional的一部分來返回， 否則，目標表達式返回nil. 對應的例子是： 把一個 superclass 轉換成一個 subclass.
|
||||
|
||||
```swift
|
||||
class SomeSuperType {}
|
||||
class SomeType: SomeSuperType {}
|
||||
class SomeChildType: SomeType {}
|
||||
let s = SomeType()
|
||||
|
||||
let x = s as SomeSuperType // known to succeed; type is SomeSuperType
|
||||
let y = s as Int // known to fail; compile-time error
|
||||
let z = s as SomeChildType // might fail at runtime; type is SomeChildType?
|
||||
```
|
||||
|
||||
使用'as'做類型轉換跟正常的類型聲明，對於編譯器來說是一樣的。例如：
|
||||
|
||||
```swift
|
||||
let y1 = x as SomeType // Type information from 'as'
|
||||
let y2: SomeType = x // Type information from an annotation
|
||||
```
|
||||
|
||||
'is' 運算符在「運行時（runtime）」會做檢查。 成功會返回true, 否則 false
|
||||
|
||||
上述檢查在「編譯時（compile time）」不能使用。 例如下面的使用是錯誤的：
|
||||
|
||||
```swift
|
||||
"hello" is String
|
||||
"hello" is Int
|
||||
```
|
||||
|
||||
關於類型轉換的更多內容和例子，請參見： Type Casting.
|
||||
|
||||
> 類型轉換運算符(type-casting-operator)語法
|
||||
> *類型轉換運算符* → **is** [*類型*](..\chapter3\03_Types.html#type) | **as** **?** _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<a name="primary_expressions"></a>
|
||||
## 主表達式（Primary Expressions）
|
||||
|
||||
`主表達式`是最基本的表達式。 它們可以跟 前綴表達式，二元表達式，後綴表達式以及其他主要表達式組合使用。
|
||||
|
||||
> 主表達式語法
|
||||
> *主表達式* → [*標識符*](LexicalStructure.html#identifier) [*泛型參數子句*](GenericParametersAndArguments.html#generic_argument_clause) _可選_
|
||||
> *主表達式* → [*字面量表達式*](..\chapter3\04_Expressions.html#literal_expression)
|
||||
> *主表達式* → [*self表達式*](..\chapter3\04_Expressions.html#self_expression)
|
||||
> *主表達式* → [*超類表達式*](..\chapter3\04_Expressions.html#superclass_expression)
|
||||
> *主表達式* → [*閉包表達式*](..\chapter3\04_Expressions.html#closure_expression)
|
||||
> *主表達式* → [*圓括號表達式*](..\chapter3\04_Expressions.html#parenthesized_expression)
|
||||
> *主表達式* → [*隱式成員表達式*](..\chapter3\04_Expressions.html#implicit_member_expression)
|
||||
> *主表達式* → [*通配符表達式*](..\chapter3\04_Expressions.html#wildcard_expression)
|
||||
|
||||
### 字符型表達式（Literal Expression）
|
||||
|
||||
由這些內容組成：普通的字符（string, number） , 一個字符的字典或者數組，或者下面列表中的特殊字符。
|
||||
|
||||
字符（Literal） | 類型（Type） | 值（Value）
|
||||
------------- | ---------- | ----------
|
||||
\__FILE__ | String | 所在的文件名
|
||||
\__LINE__ | Int | 所在的行數
|
||||
\__COLUMN__ | Int | 所在的列數
|
||||
\__FUNCTION__ | String | 所在的function 的名字
|
||||
|
||||
在某個函數（function）中，`__FUNCTION__` 會返回當前函數的名字。 在某個方法（method）中，它會返回當前方法的名字。 在某個property 的getter/setter中會返回這個屬性的名字。 在特殊的成員如init/subscript中 會返回這個關鍵字的名字，在某個文件的頂端（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, ValueType> （這裡KeyType表示 key的type, ValueType表示 value的type） 如果這個dictionary 中包含多種 types, 那麼KeyType, Value 則對應著它們的公共supertype最接近的type（ closest common supertype）.
|
||||
|
||||
> 字面量表達式語法
|
||||
> *字面量表達式* → [*字面量*](LexicalStructure.html#literal)
|
||||
> *字面量表達式* → [*數組字面量*](..\chapter3\04_Expressions.html#array_literal) | [*字典字面量*](..\chapter3\04_Expressions.html#dictionary_literal)
|
||||
> *字面量表達式* → **__FILE__** | **__LINE__** | **__COLUMN__** | **__FUNCTION__**
|
||||
> *數組字面量* → **[** [*數組字面量項列表*](..\chapter3\04_Expressions.html#array_literal_items) _可選_ **]**
|
||||
> *數組字面量項列表* → [*數組字面量項*](..\chapter3\04_Expressions.html#array_literal_item) **,** _可選_ | [*數組字面量項*](..\chapter3\04_Expressions.html#array_literal_item) **,** [*數組字面量項列表*](..\chapter3\04_Expressions.html#array_literal_items)
|
||||
> *數組字面量項* → [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
> *字典字面量* → **[** [*字典字面量項列表*](..\chapter3\04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**
|
||||
> *字典字面量項列表* → [*字典字面量項*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** _可選_ | [*字典字面量項*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** [*字典字面量項列表*](..\chapter3\04_Expressions.html#dictionary_literal_items)
|
||||
> *字典字面量項* → [*表達式*](..\chapter3\04_Expressions.html#expression) **:** [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
### 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） ）
|
||||
|
||||
```swift
|
||||
class SomeClass {
|
||||
var greeting: String
|
||||
init（greeting: String） {
|
||||
self.greeting = greeting
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
在mutating 方法中， 你可以使用self 對 該instance進行賦值。
|
||||
|
||||
```swift
|
||||
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** **.** [*標識符*](LexicalStructure.html#identifier)
|
||||
> *self表達式* → **self** **[** [*表達式*](..\chapter3\04_Expressions.html#expression) **]**
|
||||
> *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)表達式語法
|
||||
> *超類表達式* → [*超類方法表達式*](..\chapter3\04_Expressions.html#superclass_method_expression) | [*超類下標表達式*](..\chapter3\04_Expressions.html#超類下標表達式) | [*超類構造器表達式*](..\chapter3\04_Expressions.html#superclass_initializer_expression)
|
||||
> *超類方法表達式* → **super** **.** [*標識符*](LexicalStructure.html#identifier)
|
||||
> *超類下標表達式* → **super** **[** [*表達式*](..\chapter3\04_Expressions.html#expression) **]**
|
||||
> *超類構造器表達式* → **super** **.** **init**
|
||||
|
||||
### 閉包表達式（Closure Expression）
|
||||
|
||||
閉包（closure） 表達式可以建立一個閉包（在其他語言中也叫 lambda, 或者 匿名函數（anonymous function））. 跟函數（function）的聲明一樣， 閉包（closure）包含了可執行的代碼（跟方法主體（statement）類似） 以及接收（capture）的參數。 它的形式如下：
|
||||
|
||||
```swift
|
||||
{ （parameters） -> return type in
|
||||
statements
|
||||
}
|
||||
```
|
||||
|
||||
閉包的參數聲明形式跟方法中的聲明一樣, 請參見：Function Declaration.
|
||||
|
||||
閉包還有幾種特殊的形式, 讓使用更加簡潔：
|
||||
|
||||
- 閉包可以省略 它的參數的type 和返回值的type. 如果省略了參數和參數類型，就也要省略 'in'關鍵字。 如果被省略的type 無法被編譯器獲知（inferred） ，那麼就會拋出編譯錯誤。
|
||||
- 閉包可以省略參數，轉而在方法體（statement）中使用 $0, $1, $2 來引用出現的第一個，第二個，第三個參數。
|
||||
- 如果閉包中只包含了一個表達式，那麼該表達式就會自動成為該閉包的返回值。 在執行 'type inference '時，該表達式也會返回。
|
||||
|
||||
下面幾個 閉包表達式是 等價的：
|
||||
|
||||
```swift
|
||||
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' .
|
||||
|
||||
```swift
|
||||
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. ） 例如：
|
||||
|
||||
```swift
|
||||
// Weak capture of "self.parent" as "parent"
|
||||
myFunction { [weak parent = self.parent] in print（parent!.title） }
|
||||
```
|
||||
|
||||
關於閉包表達式的更多信息和例子，請參見： Closure Expressions.
|
||||
|
||||
> 閉包表達式語法
|
||||
> *閉包表達式* → **{** [*閉包簽名(Signational)*](..\chapter3\04_Expressions.html#closure_signature) _可選_ [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) **}**
|
||||
> *閉包簽名(Signational)* → [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_ **in**
|
||||
> *閉包簽名(Signational)* → [*標識符列表*](LexicalStructure.html#identifier_list) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_ **in**
|
||||
> *閉包簽名(Signational)* → [*捕獲(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_ **in**
|
||||
> *閉包簽名(Signational)* → [*捕獲(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*標識符列表*](LexicalStructure.html#identifier_list) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_ **in**
|
||||
> *閉包簽名(Signational)* → [*捕獲(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) **in**
|
||||
> *捕獲(Capature)列表* → **[** [*捕獲(Capature)說明符*](..\chapter3\04_Expressions.html#capture_specifier) [*表達式*](..\chapter3\04_Expressions.html#expression) **]**
|
||||
> *捕獲(Capature)說明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**
|
||||
|
||||
### 隱式成員表達式（Implicit Member Expression）
|
||||
|
||||
在可以判斷出類型（type）的上下文（context）中，隱式成員表達式是訪問某個type的member（ 例如 class method, enumeration case） 的簡潔方法。 它的形式是：
|
||||
|
||||
> .`member name`
|
||||
|
||||
例子：
|
||||
|
||||
```swift
|
||||
var x = MyEnumeration.SomeValue
|
||||
x = .AnotherValue
|
||||
```
|
||||
|
||||
> 隱式成員表達式語法
|
||||
> *隱式成員表達式* → **.** [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
|
||||
### 圓括號表達式（Parenthesized Expression）
|
||||
|
||||
圓括號表達式由多個子表達式和逗號','組成。 每個子表達式前面可以有 identifier x: 這樣的可選前綴。形式如下：
|
||||
|
||||
>（`identifier 1`: `expression 1`, `identifier 2`: `expression 2`, `...`）
|
||||
|
||||
圓括號表達式用來建立tuples ， 然後把它做為參數傳遞給 function. 如果某個圓括號表達式中只有一個 子表達式，那麼它的type就是 子表達式的type。例如： （1）的 type是Int, 而不是（Int）
|
||||
|
||||
> 圓括號表達式(Parenthesized Expression)語法
|
||||
> *圓括號表達式* → **(** [*表達式元素列表*](..\chapter3\04_Expressions.html#expression_element_list) _可選_ **)**
|
||||
> *表達式元素列表* → [*表達式元素*](..\chapter3\04_Expressions.html#expression_element) | [*表達式元素*](..\chapter3\04_Expressions.html#expression_element) **,** [*表達式元素列表*](..\chapter3\04_Expressions.html#expression_element_list)
|
||||
> *表達式元素* → [*表達式*](..\chapter3\04_Expressions.html#expression) | [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) **:** [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
### 通配符表達式（Wildcard Expression）
|
||||
|
||||
通配符表達式用來忽略傳遞進來的某個參數。例如：下面的代碼中，10被傳遞給x, 20被忽略（譯註：好奇葩的語法。。。）
|
||||
|
||||
```swift
|
||||
（x, _） = （10, 20）
|
||||
// x is 10, 20 is ignored
|
||||
```
|
||||
|
||||
> 通配符表達式語法
|
||||
> *通配符表達式* → **_**
|
||||
|
||||
<a name="postfix_expressions"></a>
|
||||
## 後綴表達式（Postfix Expressions）
|
||||
|
||||
後綴表達式就是在某個表達式的後面加上 操作符。 嚴格的講，每個主要表達式（primary expression）都是一個後綴表達式
|
||||
|
||||
Swift 標準庫提供了下列後綴表達式：
|
||||
|
||||
- ++ Increment
|
||||
- -- Decrement
|
||||
|
||||
對於這些操作符的使用，請參見： Basic Operators and Advanced Operators
|
||||
|
||||
> 後置表達式語法
|
||||
> *後置表達式* → [*主表達式*](..\chapter3\04_Expressions.html#primary_expression)
|
||||
> *後置表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) [*後置運算符*](..\chapter3\02_Lexical_Structure.html#postfix_operator)
|
||||
> *後置表達式* → [*函數調用表達式*](..\chapter3\04_Expressions.html#function_call_expression)
|
||||
> *後置表達式* → [*構造器表達式*](..\chapter3\04_Expressions.html#initializer_expression)
|
||||
> *後置表達式* → [*顯示成員表達式*](..\chapter3\04_Expressions.html#explicit_member_expression)
|
||||
> *後置表達式* → [*後置self表達式*](..\chapter3\04_Expressions.html#postfix_self_expression)
|
||||
> *後置表達式* → [*動態類型表達式*](..\chapter3\04_Expressions.html#dynamic_type_expression)
|
||||
> *後置表達式* → [*下標表達式*](..\chapter3\04_Expressions.html#subscript_expression)
|
||||
> *後置表達式* → [*強制取值(Forced Value)表達式*](..\chapter3\04_Expressions.html#forced_value_expression)
|
||||
> *後置表達式* → [*可選鏈(Optional Chaining)表達式*](..\chapter3\04_Expressions.html#optional_chaining_expression)
|
||||
|
||||
### 函數調用表達式（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） ， 該閉包會被目標函數理解並執行。它具有如下兩種寫法：
|
||||
|
||||
```swift
|
||||
// someFunction takes an integer and a closure as its arguments
|
||||
someFunction（x, {$0 == 13}）
|
||||
someFunction（x） {$0 == 13}
|
||||
```
|
||||
|
||||
如果閉包是該函數的唯一參數，那麼圓括號可以省略。
|
||||
|
||||
```swift
|
||||
// someFunction takes a closure as its only argument
|
||||
myData.someMethod（） {$0 == 13}
|
||||
myData.someMethod {$0 == 13}
|
||||
```
|
||||
|
||||
> 函數調用表達式語法
|
||||
> *函數調用表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) [*圓括號表達式*](..\chapter3\04_Expressions.html#parenthesized_expression)
|
||||
> *函數調用表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) [*圓括號表達式*](..\chapter3\04_Expressions.html#parenthesized_expression) _可選_ [*後置閉包(Trailing Closure)*](..\chapter3\04_Expressions.html#trailing_closure)
|
||||
> *後置閉包(Trailing Closure)* → [*閉包表達式*](..\chapter3\04_Expressions.html#closure_expression)
|
||||
|
||||
### 初始化函數表達式（Initializer Expression）
|
||||
|
||||
Initializer表達式用來給某個Type初始化。 它的形式如下：
|
||||
|
||||
> `expression`.init（`initializer arguments`）
|
||||
|
||||
（Initializer表達式用來給某個Type初始化。） 跟函數（function）不同， initializer 不能返回值。
|
||||
|
||||
```swift
|
||||
var x = SomeClass.someClassFunction // ok
|
||||
var y = SomeClass.init // error
|
||||
```
|
||||
|
||||
可以通過 initializer 表達式來委託調用（delegate to ）到superclass的initializers.
|
||||
|
||||
```swift
|
||||
class SomeSubClass: SomeSuperClass {
|
||||
init（） {
|
||||
// subclass initialization goes here
|
||||
super.init（）
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
> 構造器表達式語法
|
||||
> *構造器表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **init**
|
||||
|
||||
### 顯式成員表達式（Explicit Member Expression）
|
||||
|
||||
顯示成員表達式允許我們訪問type, tuple, module的成員變量。它的形式如下：
|
||||
|
||||
> `expression`.`member name`
|
||||
|
||||
該member 就是某個type在聲明時候所定義（declaration or extension） 的變量, 例如：
|
||||
|
||||
```swift
|
||||
class SomeClass {
|
||||
var someProperty = 42
|
||||
}
|
||||
let c = SomeClass（）
|
||||
let y = c.someProperty // Member access
|
||||
```
|
||||
|
||||
對於tuple, 要根據它們出現的順序（0, 1, 2...）來使用:
|
||||
|
||||
```swift
|
||||
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.）
|
||||
|
||||
> 顯式成員表達式語法
|
||||
> *顯示成員表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*十進制數字*](..\chapter3\02_Lexical_Structure.html#decimal_digit)
|
||||
> *顯示成員表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型參數子句*](GenericParametersAndArguments.html#generic_argument_clause) _可選_
|
||||
|
||||
### 後綴self表達式（Postfix Self Expression）
|
||||
|
||||
後綴表達式由 某個表達式 + '.self' 組成. 形式如下：
|
||||
|
||||
> `expression`.self
|
||||
> `type`.self
|
||||
|
||||
形式1 表示會返回 expression 的值。例如： x.self 返回 x
|
||||
|
||||
形式2：返回對應的type。我們可以用它來動態的獲取某個instance的type。
|
||||
|
||||
> 後置Self 表達式語法
|
||||
> *後置self表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **self**
|
||||
|
||||
### dynamic表達式（Dynamic Type Expression）
|
||||
|
||||
（因為dynamicType是一個獨有的方法，所以這裡保留了英文單詞，未作翻譯, --- 類似與self expression）
|
||||
|
||||
dynamicType 表達式由 某個表達式 + '.dynamicType' 組成。
|
||||
|
||||
> `expression`.dynamicType
|
||||
|
||||
上面的形式中， expression 不能是某type的名字（當然了，如果我都知道它的名字了還需要動態來獲取它嗎）。動態類型表達式會返回"運行時"某個instance的type, 具體請看下面的列子：
|
||||
|
||||
```swift
|
||||
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"
|
||||
```
|
||||
|
||||
> 動態類型表達式語法
|
||||
> *動態類型表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **dynamicType**
|
||||
|
||||
### 下標腳本表達式（Subscript Expression）
|
||||
|
||||
下標腳本表達式提供了通過下標腳本訪問getter/setter 的方法。它的形式是：
|
||||
|
||||
> `expression`[`index expressions`]
|
||||
|
||||
可以通過下標腳本表達式通過getter獲取某個值，或者通過setter賦予某個值.
|
||||
|
||||
關於subscript的聲明，請參見： Protocol Subscript Declaration.
|
||||
|
||||
> 附屬腳本表達式語法
|
||||
> *附屬腳本表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **[** [*表達式列表*](..\chapter3\04_Expressions.html#expression_list) **]**
|
||||
|
||||
### 強制取值表達式（Forced-Value Expression）
|
||||
|
||||
強制取值表達式用來獲取某個目標表達式的值（該目標表達式的值必須不是nil ）。它的形式如下：
|
||||
|
||||
> `expression`!
|
||||
|
||||
如果該表達式的值不是nil, 則返回對應的值。 否則，拋出運行時錯誤（runtime error）。
|
||||
|
||||
> 強制取值(Forced Value)語法
|
||||
> *強制取值(Forced Value)表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **!**
|
||||
|
||||
### 可選鏈表達式（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.
|
||||
|
||||
```swift
|
||||
var c: SomeClass?
|
||||
var result: Bool? = c?.property.performAction（）
|
||||
```
|
||||
|
||||
如果不使用可選鏈表達式，那麼 上面例子的代碼跟下面例子等價：
|
||||
|
||||
```swift
|
||||
if let unwrappedC = c {
|
||||
result = unwrappedC.property.performAction（）
|
||||
}
|
||||
```
|
||||
|
||||
> 可選鏈表達式語法
|
||||
> *可選鏈表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **?**
|
||||
855
source-tw/chapter3/05_Declarations.md
Normal file
855
source-tw/chapter3/05_Declarations.md
Normal file
@ -0,0 +1,855 @@
|
||||
> 翻譯：[marsprince](https://github.com/marsprince)
|
||||
> 校對：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
|
||||
|
||||
# 聲明
|
||||
-----------------
|
||||
|
||||
本頁包含內容：
|
||||
|
||||
- [模塊範圍](#module_scope)
|
||||
- [代碼塊](#code_blocks)
|
||||
- [引入聲明](#import_declaration)
|
||||
- [常量聲明](#constant_declaration)
|
||||
- [變量聲明](#variable_declaration)
|
||||
- [類型的別名聲明](#type_alias_declaration)
|
||||
- [函數聲明](#function_declaration)
|
||||
- [枚舉聲明](#enumeration_declaration)
|
||||
- [結構體聲明](#structure_declaration)
|
||||
- [類聲明](#class_declaration)
|
||||
- [協議聲明](#protocol_declaration)
|
||||
- [構造器聲明](#initializer_declaration)
|
||||
- [析構聲明](#deinitializer_declaration)
|
||||
- [擴展聲明](#extension_declaration)
|
||||
- [下標腳本聲明](#subscript_declaration)
|
||||
- [運算符聲明](#operator_declaration)
|
||||
|
||||
一條聲明可以在你的程序裡引入新的名字和構造。舉例來說，你可以使用聲明來引入函數和方法，變量和常量，或者來定義
|
||||
新的命名好的枚舉，結構，類和協議類型。你也可以使用一條聲明來延長一個已經存在的命名好的類型的行為。或者在你的
|
||||
程序裡引入在其他地方聲明的符號。
|
||||
|
||||
在swift中，大多數聲明在某種意義上講也是執行或同事聲明它們的初始化定義。這意味著，因為協議和它們的成員不匹配，
|
||||
大多數協議成員需要單獨的聲明。為了方便起見，也因為這些區別在swift裡不是很重要，聲明語句同時包含了聲明和定義。
|
||||
|
||||
> 聲明語法
|
||||
> *聲明* → [*導入聲明*](..\chapter3\05_Declarations.html#import_declaration)
|
||||
> *聲明* → [*常量聲明*](..\chapter3\05_Declarations.html#constant_declaration)
|
||||
> *聲明* → [*變量聲明*](..\chapter3\05_Declarations.html#variable_declaration)
|
||||
> *聲明* → [*類型別名聲明*](..\chapter3\05_Declarations.html#typealias_declaration)
|
||||
> *聲明* → [*函數聲明*](..\chapter3\05_Declarations.html#function_declaration)
|
||||
> *聲明* → [*枚舉聲明*](..\chapter3\05_Declarations.html#enum_declaration)
|
||||
> *聲明* → [*結構體聲明*](..\chapter3\05_Declarations.html#struct_declaration)
|
||||
> *聲明* → [*類聲明*](..\chapter3\05_Declarations.html#class_declaration)
|
||||
> *聲明* → [*協議聲明*](..\chapter3\05_Declarations.html#protocol_declaration)
|
||||
> *聲明* → [*構造器聲明*](..\chapter3\05_Declarations.html#initializer_declaration)
|
||||
> *聲明* → [*析構器聲明*](..\chapter3\05_Declarations.html#deinitializer_declaration)
|
||||
> *聲明* → [*擴展聲明*](..\chapter3\05_Declarations.html#extension_declaration)
|
||||
> *聲明* → [*附屬腳本聲明*](..\chapter3\05_Declarations.html#subscript_declaration)
|
||||
> *聲明* → [*運算符聲明*](..\chapter3\05_Declarations.html#operator_declaration)
|
||||
> *聲明(Declarations)列表* → [*聲明*](..\chapter3\05_Declarations.html#declaration) [*聲明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可選_
|
||||
> *聲明描述符(Specifiers)列表* → [*聲明描述符(Specifier)*](..\chapter3\05_Declarations.html#declaration_specifier) [*聲明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可選_
|
||||
> *聲明描述符(Specifier)* → **class** | **mutating** | **nonmutating** | **override** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **weak**
|
||||
|
||||
<a name="module_scope"></a>
|
||||
##模塊範圍
|
||||
|
||||
模塊範圍定義了對模塊中其他源文件可見的代碼。（註：待改進）在swift的源文件中，最高級別的代碼由零個或多個語句，
|
||||
聲明和表達組成。變量，常量和其他的聲明語句在一個源文件的最頂級被聲明，使得它們對同一模塊中的每個源文件都是可見的。
|
||||
|
||||
> 頂級(Top Level) 聲明語法
|
||||
> *頂級聲明* → [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) _可選_
|
||||
|
||||
<a name="code_blocks"></a>
|
||||
##代碼塊
|
||||
|
||||
代碼塊用來將一些聲明和控制結構的語句組織在一起。它有如下的形式：
|
||||
|
||||
> {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
代碼塊中的語句包括聲明，表達式和各種其他類型的語句，它們按照在源碼中的出現順序被依次執行。
|
||||
|
||||
> 代碼塊語法
|
||||
> *代碼塊* → **{** [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) _可選_ **}**
|
||||
|
||||
<a name="import_declaration"></a>
|
||||
##引入聲明
|
||||
|
||||
引入聲明使你可以使用在其他文件中聲明的內容。引入語句的基本形式是引入整個代碼模塊；它由import關鍵字開始，後面
|
||||
緊跟一個模塊名：
|
||||
|
||||
> import `module`
|
||||
|
||||
你可以提供更多的細節來限制引入的符號，如聲明一個特殊的子模塊或者在一個模塊或子模塊中做特殊的聲明。（待改進）
|
||||
當你使用了這些細節後，在當前的程序匯總只有引入的符號是可用的（並不是聲明的整個模塊）。
|
||||
|
||||
> import `import kind` `module`.`symbol name`
|
||||
> import `module`.`submodule`
|
||||
|
||||
<p></p>
|
||||
|
||||
> 導入(Import)聲明語法
|
||||
> *導入聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **import** [*導入類型*](..\chapter3\05_Declarations.html#import_kind) _可選_ [*導入路徑*](..\chapter3\05_Declarations.html#import_path)
|
||||
> *導入類型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**
|
||||
> *導入路徑* → [*導入路徑標識符*](..\chapter3\05_Declarations.html#import_path_identifier) | [*導入路徑標識符*](..\chapter3\05_Declarations.html#import_path_identifier) **.** [*導入路徑*](..\chapter3\05_Declarations.html#import_path)
|
||||
> *導入路徑標識符* → [*標識符*](LexicalStructure.html#identifier) | [*運算符*](LexicalStructure.html#operator)
|
||||
|
||||
<a name="constant_declaration"></a>
|
||||
##常量聲明
|
||||
|
||||
常量聲明可以在你的程序裡命名一個常量。常量以關鍵詞let來聲明，遵循如下的格式:
|
||||
|
||||
> let `constant name`: `type` = `expression`
|
||||
|
||||
當常量的值被給定後，常量就將常量名稱和表達式初始值不變的結合在了一起，而且不能更改。
|
||||
這意味著如果常量以類的形式被初始化，類本身的內容是可以改變的，但是常量和類之間的結合關係是不能改變的。
|
||||
當一個常量被聲明為全局變量，它必須被給定一個初始值。當一個常量在類或者結構體中被聲明時，它被認為是一個常量
|
||||
屬性。常量並不是可計算的屬性，因此不包含getters和setters。（譯者註：getters和setters不知道怎麼翻譯，待改進）
|
||||
|
||||
如果常量名是一個元祖形式，元祖中的每一項初始化表達式中都要有對應的值
|
||||
|
||||
```swift
|
||||
let (firstNumber, secondNumber) = (10, 42)
|
||||
```
|
||||
|
||||
在上例中，firstNumber是一個值為10的常量，secnodeName是一個值為42的常量。所有常量都可以獨立的使用：
|
||||
|
||||
```swift
|
||||
println("The first number is \(firstNumber).")
|
||||
// prints "The first number is 10."
|
||||
println("The second number is \(secondNumber).")
|
||||
// prints "The second number is 42."
|
||||
```
|
||||
|
||||
類型註釋（:type）在常量聲明中是一個可選項，它可以用來描述在類型推斷（type inference）中找到的類型。
|
||||
|
||||
聲明一個靜態常量要使用關鍵字static。靜態屬性在類型屬性（type propetries）中有介紹。
|
||||
|
||||
如果還想獲得更多關於常量的信息或者想在使用中獲得幫助，請查看常量和變量（constants and variables）,
|
||||
存儲屬性（stored properties）等節。
|
||||
|
||||
> 常數聲明語法
|
||||
> *常量聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*聲明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可選_ **let** [*模式構造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)
|
||||
> *模式構造器列表* → [*模式構造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式構造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式構造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)
|
||||
> *模式構造器* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*構造器*](..\chapter3\05_Declarations.html#initializer) _可選_
|
||||
> *構造器* → **=** [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<a name="variable_declaration"></a>
|
||||
##變量聲明
|
||||
|
||||
變量聲明可以在你的程序裡聲明一個變量，它以關鍵字var來聲明。根據聲明變量類型和值的不同，如存儲和計算
|
||||
變量和屬性，存儲變量和屬性監視，和靜態變量屬性，有著不同的聲明形式。（待改進）
|
||||
所使用的聲明形式取決於變量所聲明的範圍和你打算聲明的變量類型。
|
||||
|
||||
>注意：
|
||||
你也可以在協議聲明的上下文聲明屬性，詳情參見類型屬性聲明。
|
||||
|
||||
###存儲型變量和存儲型屬性
|
||||
|
||||
下面的形式聲明了一個存儲型變量或存儲型變量屬性
|
||||
|
||||
> var `variable name`: `type` = `expression`
|
||||
|
||||
你可以在全局，函數內，或者在類和結構體的聲明(context)中使用這種形式來聲明一個變量。當變量以這種形式
|
||||
在全局或者一個函數內被聲明時，它代表一個存儲型變量。當它在類或者結構體中被聲明時，它代表一個存儲型變量屬性。
|
||||
|
||||
初始化的表達式不可以在協議（protocol）的定義中出現，在其他情況下，初始化表達式是可選的（optional），如果沒有初始化表達式，那麼變量定義時必須顯示的聲明變量類型（:type)
|
||||
|
||||
對於常量的定義，如果名字是一個元祖（tuple），元祖每一項的`name`都要和初始化表達式`expression`中的相應值一致。
|
||||
|
||||
正如名字一樣，存儲型變量的值或存儲型變量屬性存儲在內存中。
|
||||
|
||||
###計算型變量和計算型屬性
|
||||
|
||||
如下形式聲明一個一個存儲型變量或存儲型屬性：
|
||||
|
||||
> var `variable name`: `type` {
|
||||
> get {
|
||||
> `statements`
|
||||
> }
|
||||
> set(`setter name`) {
|
||||
> `statements`
|
||||
> }
|
||||
> }
|
||||
|
||||
你可以在全局，函數體內或者類，結構體，枚舉，擴展聲明的上下文中使用這種形式的聲明。
|
||||
當變量以這種形式在全局或者一個函數內被聲明時，它代表一個計算型變量。當它在類，結構體，枚舉，擴展聲明的上下文
|
||||
中中被聲明時，它代表一個計算型變量屬性。
|
||||
|
||||
getter用來讀取變量值，setter用來寫入變量值。setter子句是可選擇的，只有getter是必需的，你可以將這些語句
|
||||
都省略，只是簡單的直接返回請求值，正如在只讀計算屬性(read-only computed properites)中描述的那樣。
|
||||
但是如果你提供了一個setter語句，你也必需提供一個getter語句。
|
||||
|
||||
setter的名字和圓括號內的語句是可選的。如果你寫了一個setter名，它就會作為setter的參數被使用。如果你不寫setter名，
|
||||
setter的初始名為newValue，正如在setter聲明速記(shorthand setter declaration)中提到的那樣。
|
||||
|
||||
不像存儲型變量和存儲型屬性那樣，計算型屬性和計算型變量的值不存儲在內存中。
|
||||
|
||||
獲得更多信息，查看更多關於計算型屬性的例子，請查看計算型屬性(computed properties)一節。
|
||||
|
||||
###存儲型變量監視器和屬性監視器
|
||||
|
||||
你可以用willset和didset監視器來聲明一個存儲型變量或屬性。一個包含監視器的存儲型變量或屬性按如下的形式聲明：
|
||||
|
||||
> var `variable name`: `type` = expression {
|
||||
> willSet(setter name) {
|
||||
> `statements`
|
||||
> }
|
||||
> didSet(`setter name`) {
|
||||
> `statements`
|
||||
> }
|
||||
> }
|
||||
|
||||
你可以在全局，函數體內或者類，結構體，枚舉，擴展聲明的上下文中使用這種形式的聲明。
|
||||
當變量以這種形式在全局或者一個函數內被聲明時，監視器代表一個存儲型變量監視器；
|
||||
當它在類，結構體，枚舉，擴展聲明的上下文中被聲明時，監視器代表屬性監視器。
|
||||
|
||||
你可以為適合的監視器添加任何存儲型屬性。你也可以通過重寫子類屬性的方式為適合的監視器添加任何繼承的屬性
|
||||
(無論是存儲型還是計算型的)，參見重寫屬性監視器(overriding properyt observers)。
|
||||
|
||||
初始化表達式在類或者結構體的聲明中是可選的，但是在其他地方是必需的。無論在什麼地方聲明，
|
||||
所有包含監視器的變量聲明都必須有類型註釋(type annotation)。
|
||||
|
||||
當變量或屬性的值被改變時，willset和didset監視器提供了一個監視方法（適當的回應）。
|
||||
監視器不會在變量或屬性第一次初始化時運行，它們只有在值被外部初始化語句改變時才會被運行。
|
||||
|
||||
willset監視器只有在變量或屬性值被改變之前運行。新的值作為一個常量經過過willset監視器，因此不可以在
|
||||
willset語句中改變它。didset監視器在變量或屬性值被改變後立即運行。和willset監視器相反，為了以防止你仍然
|
||||
需要獲得舊的數據，舊變量值或者屬性會經過didset監視器。這意味著，如果你在變量或屬性自身的didiset監視器語句
|
||||
中設置了一個值，你設置的新值會取代剛剛在willset監視器中經過的那個值。
|
||||
|
||||
在willset和didset語句中，setter名和圓括號的語句是可選的。如果你寫了一個setter名，它就會作為willset和didset的參數被使用。如果你不寫setter名，
|
||||
willset監視器初始名為newvalue，didset監視器初始名為oldvalue。
|
||||
|
||||
當你提供一個willset語句時，didset語句是可選的。同樣的，在你提供了一個didset語句時，willset語句是可選的。
|
||||
|
||||
獲得更多信息，查看如何使用屬性監視器的例子，請查看屬性監視器(prpperty observers)一節。
|
||||
|
||||
###類和靜態變量屬性
|
||||
|
||||
class關鍵字用來聲明類的計算型屬性。static關鍵字用來聲明類的靜態變量屬性。類和靜態變量在類型屬性(type properties)中有詳細討論。
|
||||
|
||||
> 變量聲明語法
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*模式構造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter塊*](..\chapter3\05_Declarations.html#getter_setter_block)
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter關鍵字(Keyword)塊*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*構造器*](..\chapter3\05_Declarations.html#initializer) _可選_ [*willSet-didSet代碼塊*](..\chapter3\05_Declarations.html#willSet_didSet_block)
|
||||
> *變量聲明頭(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*聲明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可選_ **var**
|
||||
> *變量名稱* → [*標識符*](LexicalStructure.html#identifier)
|
||||
> *getter-setter塊* → **{** [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) _可選_ **}**
|
||||
> *getter-setter塊* → **{** [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) **}**
|
||||
> *getter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **get** [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *setter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **set** [*setter名稱*](..\chapter3\05_Declarations.html#setter_name) _可選_ [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *setter名稱* → **(** [*標識符*](LexicalStructure.html#identifier) **)**
|
||||
> *getter-setter關鍵字(Keyword)塊* → **{** [*getter關鍵字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) [*setter關鍵字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) _可選_ **}**
|
||||
> *getter-setter關鍵字(Keyword)塊* → **{** [*setter關鍵字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) [*getter關鍵字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) **}**
|
||||
> *getter關鍵字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **get**
|
||||
> *setter關鍵字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **set**
|
||||
> *willSet-didSet代碼塊* → **{** [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) _可選_ **}**
|
||||
> *willSet-didSet代碼塊* → **{** [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) **}**
|
||||
> *willSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **willSet** [*setter名稱*](..\chapter3\05_Declarations.html#setter_name) _可選_ [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *didSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **didSet** [*setter名稱*](..\chapter3\05_Declarations.html#setter_name) _可選_ [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
|
||||
<a name="type_alias_declaration"></a>
|
||||
##類型的別名聲明
|
||||
|
||||
類型別名的聲明可以在你的程序裡為一個已存在的類型聲明一個別名。類型的別名聲明以關鍵字typealias開始，遵循如下的
|
||||
形式：
|
||||
|
||||
> `typealias name` = `existing type`
|
||||
|
||||
當聲明一個類型的別名後，你可以在你程序的任何地方使用別名來代替已存在的類型。已存在的類型可以是已經被命名的
|
||||
類型或者是混合類型。類型的別名不產生新的類型，它只是簡單的和已存在的類型做名稱替換。
|
||||
|
||||
查看更多Protocol Associated Type Declaration.
|
||||
|
||||
> 類型別名聲明語法
|
||||
> *類型別名聲明* → [*類型別名頭(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*類型別名賦值*](..\chapter3\05_Declarations.html#typealias_assignment)
|
||||
> *類型別名頭(Head)* → **typealias** [*類型別名名稱*](..\chapter3\05_Declarations.html#typealias_name)
|
||||
> *類型別名名稱* → [*標識符*](LexicalStructure.html#identifier)
|
||||
> *類型別名賦值* → **=** [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<a name="function_declaration"></a>
|
||||
##函數聲明
|
||||
|
||||
你可以使用函數聲明在你的程序裡引入新的函數。函數可以在類的上下文，結構體，枚舉，或者作為方法的協議中被聲明。
|
||||
函數聲明使用關鍵字func，遵循如下的形式：
|
||||
|
||||
> func `function name`(`parameters`) -> `return type` {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
如果函數不返回任何值，返回類型可以被忽略，如下所示：
|
||||
|
||||
> func `function name`(`parameters`) {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
每個參數的類型都要標明，它們不能被推斷出來。初始時函數的參數是常量。在這些參數前面添加var使它們成為變量，
|
||||
作用域內任何對變量的改變只在函數體內有效，或者用inout使的這些改變可以在調用域內生效。
|
||||
更多關於in-out參數的討論，參見in-out參數(in-out parameters)
|
||||
|
||||
函數可以使用元組類型作為返回值來返回多個變量。
|
||||
|
||||
函數定義可以出現在另一個函數聲明內。這種函數被稱作nested函數。更多關於nested函數的討論，參見nestde functions。
|
||||
|
||||
###參數名
|
||||
|
||||
函數的參數是一個以逗號分隔的列表 。函數調用是的變量順序必須和函數聲明時的參數順序一致。
|
||||
最簡單的參數列表有著如下的形式：
|
||||
|
||||
> `parameter name`: `parameter type`
|
||||
|
||||
對於函數參數來講，參數名在函數體內被使用，而不是在函數調用時使用。對於方法參數，參數名在函數體內被使用，
|
||||
同時也在方法被調用時作為標籤被使用。該方法的第一個參數名僅僅在函數體內被使用，就像函數的參數一樣，舉例來講：
|
||||
|
||||
```swift
|
||||
func f(x: Int, y: String) -> String {
|
||||
return y + String(x)
|
||||
}
|
||||
f(7, "hello") // x and y have no name
|
||||
```
|
||||
|
||||
```swift
|
||||
class C {
|
||||
func f(x: Int, y: String) -> String {
|
||||
return y + String(x)
|
||||
}
|
||||
}
|
||||
let c = C()
|
||||
c.f(7, y: "hello") // x沒有名稱，y有名稱
|
||||
```
|
||||
|
||||
你可以按如下的形式，重寫參數名被使用的過程：
|
||||
|
||||
> `external parameter name` `local parameter name`: `parameter type`
|
||||
> #`parameter name`: `parameter type`
|
||||
> _ `local parameter name`: `parameter type`
|
||||
|
||||
在本地參數前命名的第二名稱(second name)使得參數有一個擴展名。且不同於本地的參數名。
|
||||
擴展參數名在函數被調用時必須被使用。對應的參數在方法或函數被調用時必須有擴展名 。
|
||||
|
||||
在參數名前所寫的哈希符號(#)代表著這個參數名可以同時作為外部或本體參數名來使用。等同於書寫兩次本地參數名。
|
||||
在函數或方法調用時，與其對應的語句必須包含這個名字。
|
||||
|
||||
本地參數名前的強調字符(_)使參數在函數被調用時沒有名稱。在函數或方法調用時，與其對應的語句必須沒有名字。
|
||||
|
||||
###特殊類型的參數
|
||||
|
||||
參數可以被忽略，值可以是變化的，並且提供一個初始值，這種方法有著如下的形式：
|
||||
|
||||
> _ : <#parameter type#.
|
||||
> `parameter name`: `parameter type`...
|
||||
> `parameter name`: `parameter type` = `default argument value`
|
||||
|
||||
以強調符(_)命名的參數明確的在函數體內不能被訪問。
|
||||
|
||||
一個以基礎類型名的參數，如果緊跟著三個點(...)，被理解為是可變參數。一個函數至多可以擁有一個可變參數，
|
||||
且必須是最後一個參數。可變參數被作為該基本類型名的數組來看待。舉例來講，可變參數int...被看做是int[]。
|
||||
查看可變參數的使用例子，詳見可變參數(variadic parameters)一節。
|
||||
|
||||
在參數的類型後面有一個以等號(=)連接的表達式，這樣的參數被看做有著給定表達式的初始值。如果參數在函數
|
||||
調用時被省略了，就會使用初始值。如果參數沒有省略，那麼它在函數調用是必須有自己的名字.舉例來講，
|
||||
f()和f(x:7)都是只有一個變量x的函數的有效調用，但是f(7)是非法的，因為它提供了一個值而不是名稱。
|
||||
|
||||
###特殊方法
|
||||
|
||||
以self修飾的枚舉或結構體方法必須以mutating關鍵字作為函數聲明頭。
|
||||
|
||||
子類重寫的方法必須以override關鍵字作為函數聲明頭。不用override關鍵字重寫的方法，使用了override關鍵字
|
||||
卻並沒有重寫父類方法都會報錯。
|
||||
|
||||
和類型相關而不是和類型實例相關的方法必須在static聲明的結構以或枚舉內，亦或是以class關鍵字定義的類內。
|
||||
|
||||
###柯裡化函數和方法(Curried Functions and Methods)
|
||||
|
||||
柯裡化函數或方法有著如下的形式：
|
||||
|
||||
> func `function name`(`parameters`)(`parameters`) -> `return type` {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
以這種形式定義的函數的返回值是另一個函數。舉例來說，下面的兩個聲明是等價的:
|
||||
|
||||
```swift
|
||||
func addTwoNumbers(a: Int)(b: Int) -> Int {
|
||||
return a + b
|
||||
}
|
||||
func addTwoNumbers(a: Int) -> (Int -> Int) {
|
||||
func addTheSecondNumber(b: Int) -> Int {
|
||||
return a + b
|
||||
}
|
||||
return addTheSecondNumber
|
||||
}
|
||||
```
|
||||
|
||||
```swift
|
||||
addTwoNumbers(4)(5) // Returns 9
|
||||
```
|
||||
|
||||
多級柯裡化應用如下
|
||||
|
||||
> 函數聲明語法
|
||||
> *函數聲明* → [*函數頭*](..\chapter3\05_Declarations.html#function_head) [*函數名*](..\chapter3\05_Declarations.html#function_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*函數簽名(Signature)*](..\chapter3\05_Declarations.html#function_signature) [*函數體*](..\chapter3\05_Declarations.html#function_body)
|
||||
> *函數頭* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*聲明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可選_ **func**
|
||||
> *函數名* → [*標識符*](LexicalStructure.html#identifier) | [*運算符*](LexicalStructure.html#operator)
|
||||
> *函數簽名(Signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_
|
||||
> *函數結果* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
> *函數體* → [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *parameter-clauses* → [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可選_
|
||||
> *參數子句* → **(** **)** | **(** [*參數列表*](..\chapter3\05_Declarations.html#parameter_list) **...** _可選_ **)**
|
||||
> *參數列表* → [*參數*](..\chapter3\05_Declarations.html#parameter) | [*參數*](..\chapter3\05_Declarations.html#parameter) **,** [*參數列表*](..\chapter3\05_Declarations.html#parameter_list)
|
||||
> *參數* → **inout** _可選_ **let** _可選_ **#** _可選_ [*參數名*](..\chapter3\05_Declarations.html#parameter_name) [*本地參數名*](..\chapter3\05_Declarations.html#local_parameter_name) _可選_ [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*默認參數子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可選_
|
||||
> *參數* → **inout** _可選_ **var** **#** _可選_ [*參數名*](..\chapter3\05_Declarations.html#parameter_name) [*本地參數名*](..\chapter3\05_Declarations.html#local_parameter_name) _可選_ [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*默認參數子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可選_
|
||||
> *參數* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
> *參數名* → [*標識符*](LexicalStructure.html#identifier) | **_**
|
||||
> *本地參數名* → [*標識符*](LexicalStructure.html#identifier) | **_**
|
||||
> *默認參數子句* → **=** [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<a name="enumeration_declaration"></a>
|
||||
##枚舉聲明
|
||||
|
||||
在你的程序裡使用枚舉聲明來引入一個枚舉類型。
|
||||
|
||||
枚舉聲明有兩種基本的形式，使用關鍵字enum來聲明。枚舉聲明體使用從零開始的變量——叫做枚舉事件，和任意數量的
|
||||
聲明，包括計算型屬性，實例方法，靜態方法，構造器，類型別名，甚至其他枚舉，結構體，和類。枚舉聲明不能
|
||||
包含析構器或者協議聲明。
|
||||
|
||||
不像類或者結構體。枚舉類型並不提供隱式的初始構造器，所有構造器必須顯式的聲明。構造器可以委託枚舉中的其他
|
||||
構造器，但是構造過程僅當構造器將一個枚舉時間完成後才全部完成。
|
||||
|
||||
和結構體類似但是和類不同，枚舉是值類型：枚舉實例在賦予變量或常量時，或者被函數調用時被複製。
|
||||
更多關於值類型的信息，參見結構體和枚舉都是值類型(Structures and Enumerations Are Value Types)一節。
|
||||
|
||||
你可以擴展枚舉類型，正如在擴展名聲明(Extension Declaration)中討論的一樣。
|
||||
|
||||
###任意事件類型的枚舉
|
||||
|
||||
如下的形式聲明了一個包含任意類型枚舉時間的枚舉變量
|
||||
|
||||
> enum `enumeration name` {
|
||||
> case `enumeration case 1`
|
||||
> case `enumeration case 2`(`associated value types`)
|
||||
> }
|
||||
|
||||
這種形式的枚舉聲明在其他語言中有時被叫做可識別聯合(discrinminated)。
|
||||
|
||||
這種形式中，每一個事件塊由關鍵字case開始，後面緊接著一個或多個以逗號分隔的枚舉事件。每一個事件名必須是
|
||||
獨一無二的。每一個事件也可以指定它所存儲的指定類型的值，這些類型在關聯值類型的元祖裡被指定，立即書寫在事件
|
||||
名後。獲得更多關於關聯值類型的信息和例子，請查看關聯值(associated values)一節。
|
||||
|
||||
###使用原始事件值的枚舉
|
||||
|
||||
以下的形式聲明了一個包含相同基礎類型的枚舉事件的枚舉：
|
||||
|
||||
> enum `enumeration name`: `raw value type` {
|
||||
> case `enumeration case 1` = `raw value 1`
|
||||
> case `enumeration case 2` = `raw value 2`
|
||||
> }
|
||||
|
||||
在這種形式中，每一個事件塊由case關鍵字開始，後面緊接著一個或多個以逗號分隔的枚舉事件。和第一種形式的枚舉
|
||||
事件不同，這種形式的枚舉事件包含一個同類型的基礎值，叫做原始值(raw value)。這些值的類型在原始值類型(raw value type)
|
||||
中被指定，必須是字面上的整數，浮點數，字符或者字符串。
|
||||
|
||||
每一個事件必須有唯一的名字，必須有一個唯一的初始值。如果初始值類型被指定為int，則不必為事件顯式的指定值，
|
||||
它們會隱式的被標為值0,1,2等。每一個沒有被賦值的Int類型時間會隱式的賦予一個初始值，它們是自動遞增的。
|
||||
|
||||
```swift
|
||||
num ExampleEnum: Int {
|
||||
case A, B, C = 5, D
|
||||
}
|
||||
```
|
||||
|
||||
在上面的例子中，ExampleEnum.A的值是0，ExampleEnum.B的值是。因為ExampleEnum.C的值被顯式的設定為5，因此
|
||||
ExampleEnum.D的值會自動增長為6.
|
||||
|
||||
枚舉事件的初始值可以調用方法roRaw獲得，如ExampleEnum.B.toRaw()。你也可以通過調用fromRaw方法來使用初始值找到
|
||||
其對應的事件，並返回一個可選的事件。查看更多信息和獲取初始值類型事件的信息，參閱初始值(raw values)。
|
||||
|
||||
###獲得枚舉事件
|
||||
|
||||
使用點(.)來引用枚舉類型的事件，如 EnumerationType.EnumerationCase。當枚舉類型可以上下文推斷出時，你可以
|
||||
省略它(.仍然需要)，參照枚舉語法(Enumeration Syntax)和顯式成員表達(Implicit Member Expression).
|
||||
|
||||
使用switch語句來檢驗枚舉事件的值，正如使用switch語句匹配枚舉值（Matching Enumeration Values with a Switch Statement)一節描述的那樣。
|
||||
|
||||
枚舉類型是模式匹配(pattern-matched)的，和其相反的是switch語句case塊中枚舉事件匹配，在枚舉事件類型(Enumeration Case Pattern)中有描述。
|
||||
|
||||
> 枚舉聲明語法
|
||||
> *枚舉聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*聯合式枚舉*](..\chapter3\05_Declarations.html#union_style_enum) | [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*原始值式枚舉*](..\chapter3\05_Declarations.html#raw_value_style_enum)
|
||||
> *聯合式枚舉* → [*枚舉名*](..\chapter3\05_Declarations.html#enum_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可選_ **}**
|
||||
> *union-style-enum-members* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可選_
|
||||
> *union-style-enum-member* → [*聲明*](..\chapter3\05_Declarations.html#declaration) | [*聯合式(Union Style)的枚舉case子句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause)
|
||||
> *聯合式(Union Style)的枚舉case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **case** [*聯合式(Union Style)的枚舉case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)
|
||||
> *聯合式(Union Style)的枚舉case列表* → [*聯合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) | [*聯合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) **,** [*聯合式(Union Style)的枚舉case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)
|
||||
> *聯合式(Union Style)的case* → [*枚舉的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元組類型*](..\chapter3\03_Types.html#tuple_type) _可選_
|
||||
> *枚舉名* → [*標識符*](LexicalStructure.html#identifier)
|
||||
> *枚舉的case名* → [*標識符*](LexicalStructure.html#identifier)
|
||||
> *原始值式枚舉* → [*枚舉名*](..\chapter3\05_Declarations.html#enum_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ **:** [*類型標識*](..\chapter3\03_Types.html#type_identifier) **{** [*原始值式枚舉成員列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可選_ **}**
|
||||
> *原始值式枚舉成員列表* → [*原始值式枚舉成員*](..\chapter3\05_Declarations.html#raw_value_style_enum_member) [*原始值式枚舉成員列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可選_
|
||||
> *原始值式枚舉成員* → [*聲明*](..\chapter3\05_Declarations.html#declaration) | [*原始值式枚舉case子句*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_clause)
|
||||
> *原始值式枚舉case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **case** [*原始值式枚舉case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)
|
||||
> *原始值式枚舉case列表* → [*原始值式枚舉case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚舉case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚舉case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)
|
||||
> *原始值式枚舉case* → [*枚舉的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*原始值賦值*](..\chapter3\05_Declarations.html#raw_value_assignment) _可選_
|
||||
> *原始值賦值* → **=** [*字面量*](LexicalStructure.html#literal)
|
||||
|
||||
<a name="structure_declaration"></a>
|
||||
##結構體聲明
|
||||
|
||||
使用結構體聲明可以在你的程序裡引入一個結構體類型。結構體聲明使用struct關鍵字，遵循如下的形式：
|
||||
|
||||
> struct `structure name`: `adopted protocols` {
|
||||
> `declarations`
|
||||
> }
|
||||
|
||||
結構體內包含零或多個聲明。這些聲明可以包括存儲型和計算型屬性，靜態屬性，實例方法，靜態方法，構造器，
|
||||
類型別名，甚至其他結構體，類，和枚舉聲明。結構體聲明不能包含析構器或者協議聲明。詳細討論和包含多種結構體
|
||||
聲明的實例，參見類和結構體一節。
|
||||
|
||||
結構體可以包含任意數量的協議，但是不能繼承自類，枚舉或者其他結構體。
|
||||
|
||||
有三種方法可以創建一個聲明過的結構體實例：
|
||||
|
||||
-調用結構體內聲明的構造器，參照構造器(initializers)一節。
|
||||
|
||||
—如果沒有聲明構造器，調用結構體的逐個構造器，詳情參見Memberwise Initializers for Structure Types.
|
||||
|
||||
—如果沒有聲明析構器，結構體的所有屬性都有初始值，調用結構體的默認構造器，詳情參見默認構造器(Default Initializers).
|
||||
|
||||
結構體的構造過程參見初始化(initiaization)一節。
|
||||
|
||||
結構體實例屬性可以用點(.)來獲得，詳情參見獲得屬性(Accessing Properties)一節。
|
||||
|
||||
結構體是值類型；結構體的實例在被賦予變量或常量，被函數調用時被複製。獲得關於值類型更多信息，參見
|
||||
結構體和枚舉都是值類型(Structures and Enumerations Are Value Types)一節。
|
||||
|
||||
你可以使用擴展聲明來擴展結構體類型的行為，參見擴展聲明(Extension Declaration).
|
||||
|
||||
> 結構體聲明語法
|
||||
> *結構體聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **struct** [*結構體名稱*](..\chapter3\05_Declarations.html#struct_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*結構體主體*](..\chapter3\05_Declarations.html#struct_body)
|
||||
> *結構體名稱* → [*標識符*](LexicalStructure.html#identifier)
|
||||
> *結構體主體* → **{** [*聲明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可選_ **}**
|
||||
|
||||
<a name="class_declaration"></a>
|
||||
##類聲明
|
||||
|
||||
你可以在你的程序中使用類聲明來引入一個類。類聲明使用關鍵字class，遵循如下的形式：
|
||||
|
||||
> class `class name`: `superclass`, `adopted protocols` {
|
||||
> `declarations`
|
||||
> }
|
||||
|
||||
一個類內包含零或多個聲明。這些聲明可以包括存儲型和計算型屬性，實例方法，類方法，構造器，單獨的析構器方法，
|
||||
類型別名，甚至其他結構體，類，和枚舉聲明。類聲明不能包含協議聲明。詳細討論和包含多種類聲明的實例，參見類和
|
||||
結構體一節。
|
||||
|
||||
一個類只能繼承一個父類，超類，但是可以包含任意數量的協議。這些超類第一次在type-inheritance-clause出現，遵循任意協議。
|
||||
|
||||
正如在初始化聲明(Initializer Declaration)談及的那樣，類可以有指定(designated)和方便(convenience)構造器。當你聲明任一種構造器時，
|
||||
你可以使用required變量來標記構造器，要求任意子類來重寫它。指定類的構造器必須初始化類所有的已聲明的屬性，
|
||||
它必須在子類構造器調用前被執行。
|
||||
|
||||
類可以重寫屬性，方法和它的超類的構造器。重寫的方法和屬性必須以override標注。
|
||||
|
||||
雖然超類的屬性和方法聲明可以被當前類繼承，但是超類聲明的指定構造器卻不能。這意味著，如果當前類重寫了超類
|
||||
的所有指定構造器，它就繼承了超類的方便構造器。Swift的類並不是繼承自一個全局基礎類。
|
||||
|
||||
有兩種方法來創建已聲明的類的實例：
|
||||
|
||||
- 調用類的一個構造器，參見構造器(initializers)。
|
||||
- 如果沒有聲明構造器，而且類的所有屬性都被賦予了初始值，調用類的默認構造器，參見默認構造器(default initializers).
|
||||
|
||||
類實例屬性可以用點(.)來獲得，詳情參見獲得屬性(Accessing Properties)一節。
|
||||
|
||||
類是引用類型；當被賦予常量或變量，函數調用時，類的實例是被引用，而不是複製。獲得更多關於引用類型的信息，
|
||||
結構體和枚舉都是值類型(Structures and Enumerations Are Value Types)一節。
|
||||
|
||||
你可以使用擴展聲明來擴展類的行為，參見擴展聲明(Extension Declaration).
|
||||
|
||||
> 類聲明語法
|
||||
> *類聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **class** [*類名*](..\chapter3\05_Declarations.html#class_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*類主體*](..\chapter3\05_Declarations.html#class_body)
|
||||
> *類名* → [*標識符*](LexicalStructure.html#identifier)
|
||||
> *類主體* → **{** [*聲明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可選_ **}**
|
||||
|
||||
<a name="protocol_declaration"></a>
|
||||
##協議聲明(translated by 小一)
|
||||
|
||||
一個協議聲明為你的程序引入一個命名了的協議類型。協議聲明使用 `protocol` 關鍵詞來進行聲明並有下面這樣的形式：
|
||||
|
||||
> protocol `protocol name`: `inherited protocols` {
|
||||
> `protocol member declarations`
|
||||
> }
|
||||
|
||||
協議的主體包含零或多個協議成員聲明，這些成員描述了任何採用該協議必須滿足的一致性要求。特別的，一個協議可以聲明必須實現某些屬性、方法、初始化程序及下標腳本的一致性類型。協議也可以聲明專用種類的類型別名，叫做關聯類型，它可以指定協議的不同聲明之間的關係。協議成員聲明會在下面的詳情裡進行討論。
|
||||
|
||||
協議類型可以從很多其它協議那繼承。當一個協議類型從其它協議那繼承的時候，來自其它協議的所有要求就集合了，而且從當前協議繼承的任何類型必須符合所有的這些要求。對於如何使用協議繼承的例子，查看[協議繼承](../chapter2/21_Protocols.html#protocol_inheritance)
|
||||
|
||||
> 注意：
|
||||
你也可以使用協議合成類型集合多個協議的一致性要求，詳情參見[協議合成類型](../chapter3/03_Types.html#protocol_composition_type)和[協議合成](../chapter2/21_Protocols.html#protocol_composition)
|
||||
|
||||
你可以通過採用在類型的擴展聲明中的協議來為之前聲明的類型添加協議一致性。在擴展中你必須實現所有採用協議的要求。如果該類型已經實現了所有的要求，你可以讓這個擴展聲明的主題留空。
|
||||
|
||||
默認地，符合某一個協議的類型必須實現所有聲明在協議中的屬性、方法和下標腳本。也就是說，你可以用`optional`屬性標注這些協議成員聲明以指定它們的一致性類型實現是可選的。`optional`屬性僅僅可以用於使用`objc`屬性標記過的協議。這樣的結果就是僅僅類類型可以採用並符合包含可選成員要求的協議。更多關於如何使用`optional`屬性的信息及如何訪問可選協議成員的指導——比如當你不能肯定是否一致性的類型實現了它們——參見[可選協議要求](../chapter2/21_Protocols.html#optional_protocol_requirements)
|
||||
|
||||
為了限制協議的採用僅僅針對類類型，需要使用`class_protocol`屬性標記整個協議聲明。任意繼承自標記有`class_protocol`屬性協議的協議都可以智能地僅能被類類型採用。
|
||||
|
||||
>注意：
|
||||
如果協議已經用`object`屬性標記了，`class_protocol`屬性就隱性地應用於該協議；沒有必要再明確地使用`class_protocol`屬性來標記該協議了。
|
||||
|
||||
協議是命名的類型，因此它們可以以另一個命名類型出現在你代碼的所有地方，就像[協議類型](../chapter2/21_Protocols.html#protocols_as_types)裡討論的那樣。然而你不能構造一個協議的實例，因為協議實際上不提供它們指定的要求的實現。
|
||||
|
||||
你可以使用協議來聲明一個類的代理的方法或者應該實現的結構，就像[委託(代理)模式](../chapter2/21_Protocols.html#delegation)描述的那樣。
|
||||
|
||||
> 協議(Protocol)聲明語法
|
||||
> *協議聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **protocol** [*協議名*](..\chapter3\05_Declarations.html#protocol_name) [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*協議主體*](..\chapter3\05_Declarations.html#protocol_body)
|
||||
> *協議名* → [*標識符*](LexicalStructure.html#identifier)
|
||||
> *協議主體* → **{** [*協議成員聲明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可選_ **}**
|
||||
> *協議成員聲明* → [*協議屬性聲明*](..\chapter3\05_Declarations.html#protocol_property_declaration)
|
||||
> *協議成員聲明* → [*協議方法聲明*](..\chapter3\05_Declarations.html#protocol_method_declaration)
|
||||
> *協議成員聲明* → [*協議構造器聲明*](..\chapter3\05_Declarations.html#protocol_initializer_declaration)
|
||||
> *協議成員聲明* → [*協議附屬腳本聲明*](..\chapter3\05_Declarations.html#protocol_subscript_declaration)
|
||||
> *協議成員聲明* → [*協議關聯類型聲明*](..\chapter3\05_Declarations.html#protocol_associated_type_declaration)
|
||||
> *協議成員聲明(Declarations)列表* → [*協議成員聲明*](..\chapter3\05_Declarations.html#protocol_member_declaration) [*協議成員聲明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可選_
|
||||
|
||||
<a name="protocol_property_declaration"></a>
|
||||
###協議屬性聲明
|
||||
|
||||
協議聲明了一致性類型必須在協議聲明的主體裡通過引入一個協議屬性聲明來實現一個屬性。協議屬性聲明有一種特殊的類型聲明形式：
|
||||
|
||||
> var `property name`: `type` { get set }
|
||||
|
||||
同其它協議成員聲明一樣，這些屬性聲明僅僅針對符合該協議的類型聲明了`getter`和`setter`要求。結果就是你不需要在協議裡它被聲明的地方實現`getter`和`setter`。
|
||||
|
||||
`getter`和`setter`要求可以通過一致性類型以各種方式滿足。如果屬性聲明包含`get`和`set`關鍵詞，一致性類型就可以用可讀寫（實現了`getter`和`setter`）的存儲型變量屬性或計算型屬性，但是屬性不能以常量屬性或只讀計算型屬性實現。如果屬性聲明僅僅包含`get`關鍵詞的話，它可以作為任意類型的屬性被實現。比如說實現了協議的屬性要求的一致性類型，參見[屬性要求](../chapter2/21_Protocols.html#property_requirements)
|
||||
|
||||
更多參見[變量聲明](../chapter3/05_Declarations.html#variable_declaration)
|
||||
|
||||
> 協議屬性聲明語法
|
||||
> *協議屬性聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter關鍵字(Keyword)塊*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
|
||||
|
||||
###協議方法聲明
|
||||
|
||||
協議聲明了一致性類型必須在協議聲明的主體裡通過引入一個協議方法聲明來實現一個方法.
|
||||
協議方法聲明和函數方法聲明有著相同的形式，包含如下兩條規則：它們不包括函數體，你不能在類的聲明內為它們的
|
||||
參數提供初始值.舉例來說，符合的類型執行協議必需的方法。參見必需方法一節。
|
||||
|
||||
使用關鍵字class可以在協議聲明中聲明一個類或必需的靜態方法。執行這些方法的類也用關鍵字class聲明。
|
||||
相反的，執行這些方法的結構體必須以關鍵字static聲明。如果你想使用擴展方法，在擴展類時使用class關鍵字，
|
||||
在擴展結構體時使用static關鍵字。
|
||||
|
||||
更多請參閱函數聲明。
|
||||
|
||||
> 協議方法聲明語法
|
||||
> *協議方法聲明* → [*函數頭*](..\chapter3\05_Declarations.html#function_head) [*函數名*](..\chapter3\05_Declarations.html#function_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*函數簽名(Signature)*](..\chapter3\05_Declarations.html#function_signature)
|
||||
|
||||
###協議構造器聲明
|
||||
|
||||
協議聲明了一致性類型必須在協議聲明的主體裡通過引入一個協議構造器聲明來實現一個構造器。協議構造器聲明
|
||||
除了不包含構造器體外，和構造器聲明有著相同的形式，
|
||||
|
||||
更多請參閱構造器聲明。
|
||||
|
||||
> 協議構造器聲明語法
|
||||
> *協議構造器聲明* → [*構造器頭(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause)
|
||||
|
||||
###協議下標腳本聲明
|
||||
|
||||
協議聲明了一致性類型必須在協議聲明的主體裡通過引入一個協議下標腳本聲明來實現一個下標腳本。協議屬性聲明
|
||||
對下標腳本聲明有一個特殊的形式：
|
||||
|
||||
> subscript (`parameters`) -> `return type` { get set }
|
||||
|
||||
下標腳本聲明只為和協議一致的類型聲明了必需的最小數量的的getter和setter。如果下標腳本申明包含get和set關鍵字，
|
||||
一致的類型也必須有一個getter和setter語句。如果下標腳本聲明值包含get關鍵字，一致的類型必須至少包含一個
|
||||
getter語句，可以選擇是否包含setter語句。
|
||||
|
||||
更多參閱下標腳本聲明。
|
||||
|
||||
> 協議附屬腳本聲明語法
|
||||
> *協議附屬腳本聲明* → [*附屬腳本頭(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附屬腳本結果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter關鍵字(Keyword)塊*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
|
||||
|
||||
###協議相關類型聲明
|
||||
|
||||
協議聲明相關類型使用關鍵字typealias。相關類型為作為協議聲明的一部分的類型提供了一個別名。相關類型和參數
|
||||
語句中的類型參數很相似，但是它們在聲明的協議中包含self關鍵字。在這些語句中，self指代和協議一致的可能的類型。
|
||||
獲得更多信息和例子，查看相關類型或類型別名聲明。
|
||||
|
||||
> 協議關聯類型聲明語法
|
||||
> *協議關聯類型聲明* → [*類型別名頭(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*類型別名賦值*](..\chapter3\05_Declarations.html#typealias_assignment) _可選_
|
||||
|
||||
<a name="initializer_declaration"></a>
|
||||
##構造器聲明
|
||||
|
||||
構造器聲明會為程序內的類，結構體或枚舉引入構造器。構造器使用關鍵字Init來聲明，遵循兩條基本形式。
|
||||
|
||||
結構體，枚舉，類可以有任意數量的構造器，但是類的構造器的規則和行為是不一樣的。不像結構體和枚舉那樣，類
|
||||
有兩種結構體，designed initializers 和convenience initializers，參見構造器一節。
|
||||
|
||||
如下的形式聲明了結構體，枚舉和類的指定構造器：
|
||||
|
||||
> init(`parameters`) {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
類的指定構造器將類的所有屬性直接初始化。如果類有超類，它不能調用該類的其他構造器,它只能調用超類的一個
|
||||
指定構造器。如果該類從它的超類處繼承了任何屬性，這些屬性在當前類內被賦值或修飾時，必須調用一個超類的
|
||||
指定構造器。
|
||||
|
||||
指定構造器可以在類聲明的上下文中聲明，因此它不能用擴展聲明的方法加入一個類中。
|
||||
|
||||
結構體和枚舉的構造器可以調用其他的已聲明的構造器，委託其中一個或所有的構造器進行初始化過程。
|
||||
|
||||
以關鍵字convenience來聲明一個類的便利構造器：
|
||||
|
||||
> convenience init(`parameters`) {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
便利構造器可以將初始化過程委託給另一個便利構造器或類的一個指定構造器。這意味著，類的初始化過程必須
|
||||
以一個將所有類屬性完全初始化的指定構造器的調用作為結束。便利構造器不能調用超類的構造器。
|
||||
|
||||
你可以使用required關鍵字，將便利構造器和指定構造器標記為每個子類的構造器都必須擁有的。因為指定構造器
|
||||
不被子類繼承，它們必須被立即執行。當子類直接執行所有超類的指定構造器(或使用便利構造器重寫指定構造器)時，
|
||||
必需的便利構造器可以被隱式的執行，亦可以被繼承。不像方法，下標腳本那樣，你不需要為這些重寫的構造器標注
|
||||
overrride關鍵字。
|
||||
|
||||
查看更多關於不同聲明方法的構造器的例子，參閱構造過程一節。
|
||||
|
||||
> 構造器聲明語法
|
||||
> *構造器聲明* → [*構造器頭(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause) [*構造器主體*](..\chapter3\05_Declarations.html#initializer_body)
|
||||
> *構造器頭(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **convenience** _可選_ **init**
|
||||
> *構造器主體* → [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
|
||||
<a name="deinitializer_declaration"></a>
|
||||
##析構聲明
|
||||
|
||||
析構聲明為類聲明了一個析構器。析構器沒有參數，遵循如下的格式：
|
||||
|
||||
> deinit {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
當類沒有任何語句時將要被釋放時，析構器會自動的被調用。析構器在類的聲明體內只能被聲明一次——但是不能在
|
||||
類的擴展聲明內，每個類最多只能有一個。
|
||||
|
||||
子類繼承了它的超類的析構器，在子類將要被釋放時隱式的調用。子類在所有析構器被執行完畢前不會被釋放。
|
||||
|
||||
析構器不會被直接調用。
|
||||
|
||||
查看例子和如何在類的聲明中使用析構器，參見析構過程一節。
|
||||
|
||||
> 析構器聲明語法
|
||||
> *析構器聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **deinit** [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
|
||||
<a name="extension_declaration"></a>
|
||||
##擴展聲明
|
||||
|
||||
擴展聲明用於擴展一個現存的類，結構體，枚舉的行為。擴展聲明以關鍵字extension開始，遵循如下的規則：
|
||||
|
||||
> extension `type`: `adopted protocols` {
|
||||
> `declarations`
|
||||
> }
|
||||
|
||||
一個擴展聲明體包括零個或多個聲明。這些聲明可以包括計算型屬性，計算型靜態屬性，實例方法，靜態和類方法，構造器，
|
||||
下標腳本聲明，甚至其他結構體，類，和枚舉聲明。擴展聲明不能包含析構器，協議聲明，存儲型屬性，屬性監測器或其他
|
||||
的擴展屬性。詳細討論和查看包含多種擴展聲明的實例，參見擴展一節。
|
||||
|
||||
擴展聲明可以向現存的類，結構體，枚舉內添加一致的協議。擴展聲明不能向一個類中添加繼承的類，因此
|
||||
type-inheritance-clause是一個只包含協議列表的擴展聲明。
|
||||
|
||||
屬性，方法，現存類型的構造器不能被它們類型的擴展所重寫。
|
||||
|
||||
擴展聲明可以包含構造器聲明，這意味著，如果你擴展的類型在其他模塊中定義，構造器聲明必須委託另一個在
|
||||
那個模塊裡聲明的構造器來恰當的初始化。
|
||||
|
||||
> 擴展(Extension)聲明語法
|
||||
> *擴展聲明* → **extension** [*類型標識*](..\chapter3\03_Types.html#type_identifier) [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)
|
||||
> *extension-body* → **{** [*聲明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可選_ **}**
|
||||
|
||||
<a name="subscript_declaration"></a>
|
||||
##下標腳本聲明(translated by 林)
|
||||
|
||||
附屬腳本用於向特定類型添加附屬腳本支持，通常為訪問集合，列表和序列的元素時提供語法便利。附屬腳本聲明使用關鍵字`subscript`，聲明形式如下：
|
||||
|
||||
> subscript (`parameter`) -> (return type){
|
||||
> get{
|
||||
> `statements`
|
||||
> }
|
||||
> set(`setter name`){
|
||||
> `statements`
|
||||
> }
|
||||
> }
|
||||
|
||||
附屬腳本聲明只能在類，結構體，枚舉，擴展和協議聲明的上下文進行聲明。
|
||||
|
||||
_變量(parameters)_指定一個或多個用於在相關類型的下標腳本中訪問元素的索引（例如，表達式`object[i]`中的`i`）。儘管用於元素訪問的索引可以是任意類型的，但是每個變量必須包含一個用於指定每種索引類型的類型標注。_返回類型(return type)_指定被訪問的元素的類型。
|
||||
|
||||
和計算性屬性一樣，下標腳本聲明支持對訪問元素的讀寫操作。getter用於讀取值，setter用於寫入值。setter子句是可選的，當僅需要一個getter子句時，可以將二者都忽略且直接返回請求的值即可。也就是說，如果使用了setter子句，就必須使用getter子句。
|
||||
|
||||
setter的名字和封閉的括號是可選的。如果使用了setter名稱，它會被當做傳給setter的變量的名稱。如果不使用setter名稱，那麼傳給setter的變量的名稱默認是`value`。setter名稱的類型必須與_返回類型(return type)_的類型相同。
|
||||
|
||||
可以在下標腳本聲明的類型中，可以重載下標腳本，只要_變量(parameters)_或_返回類型(return type)_與先前的不同即可。此時，必須使用`override`關鍵字聲明那個被覆蓋的下標腳本。(註：好亂啊！到底是重載還是覆蓋？！)
|
||||
|
||||
同樣可以在協議聲明的上下文中聲明下標腳本，[Protocol Subscript Declaration](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Declarations.html#//apple_ref/doc/uid/TP40014097-CH34-XID_619)中有所描述。
|
||||
|
||||
更多關於下標腳本和下標腳本聲明的例子，請參考[Subscripts](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Subscripts.html#//apple_ref/doc/uid/TP40014097-CH16-XID_393)。
|
||||
|
||||
> 附屬腳本聲明語法
|
||||
> *附屬腳本聲明* → [*附屬腳本頭(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附屬腳本結果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *附屬腳本聲明* → [*附屬腳本頭(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附屬腳本結果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter塊*](..\chapter3\05_Declarations.html#getter_setter_block)
|
||||
> *附屬腳本聲明* → [*附屬腳本頭(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*附屬腳本結果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter關鍵字(Keyword)塊*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
|
||||
> *附屬腳本頭(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **subscript** [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause)
|
||||
> *附屬腳本結果(Result)* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<a name="operator_declaration"></a>
|
||||
##運算符聲明(translated by 林)
|
||||
|
||||
運算符聲明會向程序中引入中綴、前綴或後綴運算符，它使用上下文關鍵字`operator`聲明。
|
||||
可以聲明三種不同的綴性：中綴、前綴和後綴。操作符的綴性描述了操作符與它的操作數的相對位置。
|
||||
運算符聲明有三種基本形式，每種綴性各一種。運算符的綴性通過在`operator`和運算符之間添加上下文關鍵字`infix`，`prefix`或`postfix`來指定。每種形式中，運算符的名字只能包含[Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/LexicalStructure.html#//apple_ref/doc/uid/TP40014097-CH30-XID_871)中定義的運算符字符。
|
||||
|
||||
下面的這種形式聲明了一個新的中綴運算符：
|
||||
> operator infix `operator name`{
|
||||
> previewprecedence `precedence level`
|
||||
> associativity `associativity`
|
||||
> }
|
||||
|
||||
_中綴_運算符是二元運算符，它可以被置於兩個操作數之間，比如表達式`1 + 2` 中的加法運算符(`+`)。
|
||||
|
||||
中綴運算符可以可選地指定優先級，結合性，或兩者同時指定。
|
||||
|
||||
運算符的_優先級_可以指定在沒有括號包圍的情況下，運算符與它的操作數如何緊密綁定的。可以使用上下文關鍵字`precedence`並_優先級(precedence level)_一起來指定一個運算符的優先級。_優先級_可以是0到255之間的任何一個數字(十進制整數)；與十進制整數字面量不同的是，它不可以包含任何下劃線字符。儘管優先級是一個特定的數字，但它僅用作與另一個運算符比較(大小)。也就是說，一個操作數可以同時被兩個運算符使用時，例如`2 + 3 * 5`，優先級更高的運算符將優先與操作數綁定。
|
||||
|
||||
運算符的_結合性_可以指定在沒有括號包圍的情況下，優先級相同的運算符以何種順序被分組的。可以使用上下文關鍵字`associativity`並_結合性(associativity)_一起來指定一個運算符的結合性，其中_結合性_可以說是上下文關鍵字`left`，`right`或`none`中的任何一個。左結合運算符以從左到右的形式分組。例如，減法運算符(`-`)具有左結合性，因此`4 - 5 - 6`被以`(4 - 5) - 6`的形式分組，其結果為`-7`。
|
||||
右結合運算符以從右到左的形式分組，對於設置為`none`的非結合運算符，它們不以任何形式分組。具有相同優先級的非結合運算符，不可以互相鄰接。例如，表達式`1 < 2 < 3`非法的。
|
||||
|
||||
聲明時不指定任何優先級或結合性的中綴運算符，它們的優先級會被初始化為100，結合性被初始化為`none`。
|
||||
|
||||
下面的這種形式聲明了一個新的前綴運算符：
|
||||
> operator prefix `operator name`{}
|
||||
|
||||
緊跟在操作數前邊的_前綴運算符(prefix operator)_是一元運算符，例如表達式`++i`中的前綴遞增運算符(`++`)。
|
||||
|
||||
前綴運算符的聲明中不指定優先級。前綴運算符是非結合的。
|
||||
|
||||
下面的這種形式聲明了一個新的後綴運算符：
|
||||
|
||||
> operator postfix `operator name`{}
|
||||
|
||||
緊跟在操作數後邊的_後綴運算符(postfix operator)_是一元運算符，例如表達式`i++`中的前綴遞增運算符(`++`)。
|
||||
|
||||
和前綴運算符一樣，後綴運算符的聲明中不指定優先級。後綴運算符是非結合的。
|
||||
|
||||
聲明了一個新的運算符以後，需要聲明一個跟這個運算符同名的函數來實現這個運算符。如何實現一個新的運算符，請參考[Custom Operators](https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/AdvancedOperators.html#//apple_ref/doc/uid/TP40014097-CH27-XID_48)。
|
||||
|
||||
> 運算符聲明語法
|
||||
> *運算符聲明* → [*前置運算符聲明*](..\chapter3\05_Declarations.html#prefix_operator_declaration) | [*後置運算符聲明*](..\chapter3\05_Declarations.html#postfix_operator_declaration) | [*中置運算符聲明*](..\chapter3\05_Declarations.html#infix_operator_declaration)
|
||||
> *前置運算符聲明* → **運算符** **prefix** [*運算符*](LexicalStructure.html#operator) **{** **}**
|
||||
> *後置運算符聲明* → **運算符** **postfix** [*運算符*](LexicalStructure.html#operator) **{** **}**
|
||||
> *中置運算符聲明* → **運算符** **infix** [*運算符*](LexicalStructure.html#operator) **{** [*中置運算符屬性*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可選_ **}**
|
||||
> *中置運算符屬性* → [*優先級子句*](..\chapter3\05_Declarations.html#precedence_clause) _可選_ [*結和性子句*](..\chapter3\05_Declarations.html#associativity_clause) _可選_
|
||||
> *優先級子句* → **precedence** [*優先級水平*](..\chapter3\05_Declarations.html#precedence_level)
|
||||
> *優先級水平* → 數值 0 到 255
|
||||
> *結和性子句* → **associativity** [*結和性*](..\chapter3\05_Declarations.html#associativity)
|
||||
> *結和性* → **left** | **right** | **none**
|
||||
124
source-tw/chapter3/06_Attributes.md
Normal file
124
source-tw/chapter3/06_Attributes.md
Normal file
@ -0,0 +1,124 @@
|
||||
> 翻譯：[Hawstein](https://github.com/Hawstein)
|
||||
> 校對：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
|
||||
|
||||
# 特性
|
||||
-----------------
|
||||
|
||||
本頁內容包括：
|
||||
|
||||
- [聲明特性](#declaration_attributes)
|
||||
- [類型特性](#type_attributes)
|
||||
|
||||
特性提供了關於聲明和類型的更多信息。在Swift中有兩類特性，用於修飾聲明的以及用於修飾類型的。例如，`required`特性，當應用於一個類的指定或便利初始化器聲明時，表明它的每個子類都必須實現那個初始化器。再比如`noreturn`特性，當應用於函數或方法類型時，表明該函數或方法不會返回到它的調用者。
|
||||
|
||||
通過以下方式指定一個特性：符號`@`後面跟特性名，如果包含參數，則把參數帶上：
|
||||
|
||||
> @`attribute name`
|
||||
> @`attribute name`(`attribute arguments`)
|
||||
|
||||
有些聲明特性通過接收參數來指定特性的更多信息以及它是如何修飾一個特定的聲明的。這些特性的參數寫在小括號內，它們的格式由它們所屬的特性來定義。
|
||||
|
||||
<a name="declaration_attributes"></a>
|
||||
## 聲明特性
|
||||
|
||||
聲明特性只能應用於聲明。然而，你也可以將`noreturn`特性應用於函數或方法類型。
|
||||
|
||||
`assignment`
|
||||
|
||||
該特性用於修飾重載了復合賦值運算符的函數。重載了復合賦值運算符的函數必需將它們的初始輸入參數標記為`inout`。如何使用`assignment`特性的一個例子，請見：[復合賦值運算符]()。
|
||||
|
||||
`class_protocol`
|
||||
|
||||
該特性用於修飾一個協議表明該協議只能被類類型採用[待改：adopted]。
|
||||
|
||||
如果你用`objc`特性修飾一個協議，`class_protocol`特性就會隱式地應用到該協議，因此無需顯式地用`class_protocol`特性標記該協議。
|
||||
|
||||
`exported`
|
||||
|
||||
該特性用於修飾導入聲明，以此來導出已導入的模塊，子模塊，或當前模塊的聲明。如果另一個模塊導入了當前模塊，那麼那個模塊可以訪問當前模塊的導出項。
|
||||
|
||||
`final`
|
||||
|
||||
該特性用於修飾一個類或類中的屬性，方法，以及下標成員。如果用它修飾一個類，那麼這個類則不能被繼承。如果用它修飾類中的屬性，方法或下標，則表示在子類中，它們不能被重寫。
|
||||
|
||||
`lazy`
|
||||
|
||||
該特性用於修飾類或結構體中的存儲型變量屬性，表示該屬性的初始值最多只被計算和存儲一次，且發生在第一次訪問它時。如何使用`lazy`特性的一個例子，請見：[惰性存儲型屬性]()。
|
||||
|
||||
`noreturn`
|
||||
|
||||
該特性用於修飾函數或方法聲明，表明該函數或方法的對應類型，`T`，是`@noreturn T`。你可以用這個特性修飾函數或方法的類型，這樣一來，函數或方法就不會返回到它的調用者中去。
|
||||
|
||||
對於一個沒有用`noreturn`特性標記的函數或方法，你可以將它重寫(override)為用該特性標記的。相反，對於一個已經用`noreturn`特性標記的函數或方法，你則不可以將它重寫為沒使用該特性標記的。相同的規則試用於當你在一個comforming類型中實現一個協議方法時。
|
||||
|
||||
`NSCopying`
|
||||
|
||||
該特性用於修飾一個類的存儲型變量屬性。該特性將使屬性的setter與屬性值的一個副本合成，由`copyWithZone`方法返回，而不是屬性本身的值。該屬性的類型必需遵循`NSCopying`協議。
|
||||
|
||||
`NSCopying`特性的行為與Objective-C中的`copy`特性相似。
|
||||
|
||||
`NSManaged`
|
||||
|
||||
該特性用於修飾`NSManagedObject`子類中的存儲型變量屬性，表明屬性的存儲和實現由Core Data在運行時基於相關實體描述動態提供。
|
||||
|
||||
`objc`
|
||||
|
||||
該特性用於修飾任意可以在Objective-C中表示的聲明，比如，非嵌套類，協議，類和協議中的屬性和方法（包含getter和setter），初始化器，析構器，以下下標。`objc`特性告訴編譯器該聲明可以在Objective-C代碼中使用。
|
||||
|
||||
如果你將`objc`特性應用於一個類或協議，它也會隱式地應用於那個類或協議的成員。對於標記了`objc`特性的類，編譯器會隱式地為它的子類添加`objc`特性。標記了`objc`特性的協議不能繼承自沒有標記`objc`的協議。
|
||||
|
||||
`objc`特性有一個可選的參數，由標記符組成。當你想把`objc`所修飾的實體以一個不同的名字暴露給Objective-C，你就可以使用這個特性參數。你可以使用這個參數來命名類，協議，方法，getters，setters，以及初始化器。下面的例子把`ExampleClass`中`enabled`屬性的getter暴露給Objective-C，名字是`isEnabled`，而不是它原來的屬性名。
|
||||
|
||||
```swift
|
||||
@objc
|
||||
class ExampleClass {
|
||||
var enabled: Bool {
|
||||
@objc(isEnabled) get {
|
||||
// Return the appropriate value
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
`optional`
|
||||
|
||||
用該特性修飾協議的屬性，方法或下標成員，表示實現這些成員並不需要一致性類型（conforming type）。
|
||||
|
||||
你只能用`optional`特性修飾那些標記了`objc`特性的協議。因此，只有類類型可以adopt和comform to那些包含可選成員需求的協議。更多關於如何使用`optional`特性以及如何訪問可選協議成員的指導，例如，當你不確定一個conforming類型是否實現了它們，請見：[可選協議需求]()。
|
||||
|
||||
`required`
|
||||
|
||||
用該特性修飾一個類的指定或便利初始化器，表示該類的所有子類都必需實現該初始化器。
|
||||
|
||||
加了該特性的指定初始化器必需顯式地實現，而便利初始化器既可顯式地實現，也可以在子類實現了超類所有指定初始化器後繼承而來（或者當子類使用便利初始化器重寫了指定初始化器）。
|
||||
|
||||
### Interface Builder使用的聲明特性
|
||||
|
||||
Interface Builder特性是Interface Builder用來與Xcode同步的聲明特性。Swift提供了以下的Interface Builder特性：`IBAction`，`IBDesignable`，`IBInspectable`，以及`IBOutlet`。這些特性與Objective-C中對應的特性在概念上是相同的。
|
||||
|
||||
`IBOutlet`和`IBInspectable`用於修飾一個類的屬性聲明；`IBAction`特性用於修飾一個類的方法聲明；`IBDesignable`用於修飾類的聲明。
|
||||
|
||||
<a name="type_attributes"></a>
|
||||
## 類型特性
|
||||
|
||||
類型特性只能用於修飾類型。然而，你也可以用`noreturn`特性去修飾函數或方法聲明。
|
||||
|
||||
`auto_closure`
|
||||
|
||||
這個特性通過自動地將表達式封閉到一個無參數閉包中來延遲表達式的求值。使用該特性修飾無參的函數或方法類型，返回表達式的類型。一個如何使用`auto_closure`特性的例子，見[函數類型]()
|
||||
|
||||
`noreturn`
|
||||
|
||||
該特性用於修飾函數或方法的類型，表明該函數或方法不會返回到它的調用者中去。你也可以用它標記函數或方法的聲明，表示函數或方法的相應類型，`T`，是`@noreturn T`。
|
||||
|
||||
> 特性語法
|
||||
> *特性* → **@** [*特性名*](..\chapter3\06_Attributes.html#attribute_name) [*特性參數子句*](..\chapter3\06_Attributes.html#attribute_argument_clause) _可選_
|
||||
> *特性名* → [*標識符*](LexicalStructure.html#identifier)
|
||||
> *特性參數子句* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_ **)**
|
||||
> *特性(Attributes)列表* → [*特色*](..\chapter3\06_Attributes.html#attribute) [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_
|
||||
> *平衡令牌列表* → [*平衡令牌*](..\chapter3\06_Attributes.html#balanced_token) [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_
|
||||
> *平衡令牌* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_ **)**
|
||||
> *平衡令牌* → **[** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_ **]**
|
||||
> *平衡令牌* → **{** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_ **}**
|
||||
> *平衡令牌* → **任意標識符, 關鍵字, 字面量或運算符**
|
||||
> *平衡令牌* → **任意標點除了(, ), [, ], {, 或 }**
|
||||
182
source-tw/chapter3/07_Patterns.md
Normal file
182
source-tw/chapter3/07_Patterns.md
Normal file
@ -0,0 +1,182 @@
|
||||
> 翻譯：[honghaoz](https://github.com/honghaoz)
|
||||
> 校對：[numbbbbb](https://github.com/numbbbbb), [stanzhai](https://github.com/stanzhai)
|
||||
|
||||
# 模式（Patterns）
|
||||
-----------------
|
||||
|
||||
本頁內容包括：
|
||||
|
||||
- [通配符模式（Wildcard Pattern）](#wildcard_pattern)
|
||||
- [標識符模式（Identifier Pattern）](#identifier_pattern)
|
||||
- [值綁定模式（Value-Binding Pattern）](#value-binding_pattern)
|
||||
- [元組模式（Tuple Pattern）](#tuple_pattern)
|
||||
- [枚舉用例模式（Enumeration Case Pattern）](#enumeration_case_pattern)
|
||||
- [類型轉換模式（Type-Casting Patterns）](#type-casting_patterns)
|
||||
- [表達式模式（Expression Pattern）](#expression_pattern)
|
||||
|
||||
模式（pattern）代表了單個值或者復合值的結構。例如，元組`(1, 2)`的結構是逗號分隔的，包含兩個元素的列表。因為模式代表一種值的結構，而不是特定的某個值，你可以把模式和各種同類型的值匹配起來。比如，`(x, y)`可以匹配元組`(1, 2)`，以及任何含兩個元素的元組。除了將模式與一個值匹配外，你可以從合成值中提取出部分或全部，然後分別把各個部分和一個常量或變量綁定起來。
|
||||
|
||||
在Swift中，模式出現在變量和常量的聲明（在它們的左側），`for-in`語句和`switch`語句（在它們的case標籤）中。儘管任何模式都可以出現在`switch`語句的case標籤中，但在其他情況下，只有通配符模式（wildcard pattern），標識符模式（identifier pattern）和包含這兩種模式的模式才能出現。
|
||||
|
||||
你可以為通配符模式（wildcard pattern），標識符模式（identifier pattern）和元組模式（tuple pattern）指定類型註釋，用來限制這種模式只匹配某種類型的值。
|
||||
|
||||
> 模式(Patterns) 語法
|
||||
> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*類型註解*](..\chapter3\03_Types.html#type_annotation) _可選_
|
||||
> *模式* → [*標識符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*類型註解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可選_
|
||||
> *模式* → [*值綁定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)
|
||||
> *模式* → [*元組模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*類型註解*](..\chapter3\03_Types.html#type_annotation) _可選_
|
||||
> *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern)
|
||||
> *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern)
|
||||
> *模式* → [*表達式模式*](..\chapter3\07_Patterns.html#expression_pattern)
|
||||
|
||||
<a name="wildcard_pattern"></a>
|
||||
## 通配符模式（Wildcard Pattern）
|
||||
|
||||
通配符模式匹配並忽略任何值，包含一個下劃線（_）。當你不關心被匹配的值時，可以使用此模式。例如，下面這段代碼進行了`1...3`的循環，並忽略了每次循環的值：
|
||||
|
||||
```swift
|
||||
for _ in 1...3 {
|
||||
// Do something three times.
|
||||
}
|
||||
```
|
||||
|
||||
> 通配符模式語法
|
||||
> *通配符模式* → **_**
|
||||
|
||||
<a name="identifier_pattern"></a>
|
||||
## 標識符模式（Identifier Pattern）
|
||||
|
||||
標識符模式匹配任何值，並將匹配的值和一個變量或常量綁定起來。例如，在下面的常量申明中，`someValue`是一個標識符模式，匹配了類型是`Int`的`42`。
|
||||
|
||||
```swift
|
||||
let someValue = 42
|
||||
```
|
||||
|
||||
當匹配成功時，`42`被綁定（賦值）給常量`someValue`。
|
||||
|
||||
當一個變量或常量申明的左邊是標識符模式時，此時，標識符模式是隱式的值綁定模式（value-binding pattern）。
|
||||
|
||||
> 標識符模式語法
|
||||
> *標識符模式* → [*標識符*](LexicalStructure.html#identifier)
|
||||
|
||||
<a name="value-binding_pattern"></a>
|
||||
## 值綁定模式（Value-Binding Pattern）
|
||||
|
||||
值綁定模式綁定匹配的值到一個變量或常量。當綁定匹配值給常量時，用關鍵字`let`,綁定給變量時，用關鍵字`var`。
|
||||
|
||||
標識符模式包含在值綁定模式中，綁定新的變量或常量到匹配的值。例如，你可以分解一個元組的元素，並把每個元素綁定到相應的標識符模式中。
|
||||
|
||||
```swift
|
||||
let point = (3, 2)
|
||||
switch point {
|
||||
// Bind x and y to the elements of point.
|
||||
case let (x, y):
|
||||
println("The point is at (\(x), \(y)).")
|
||||
}
|
||||
// prints "The point is at (3, 2).」
|
||||
```
|
||||
|
||||
在上面這個例子中，`let`將元組模式`(x, y)`分配到各個標識符模式。因為這種行為，`switch`語句中`case let (x, y):`和`case (let x, let y):`匹配的值是一樣的。
|
||||
|
||||
> 值綁定(Value Binding)模式語法
|
||||
> *值綁定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern)
|
||||
|
||||
<a name="tuple_pattern"></a>
|
||||
## 元組模式（Tuple Pattern）
|
||||
|
||||
元組模式是逗號分隔的列表，包含一個或多個模式，並包含在一對圓括號中。元組模式匹配相應元組類型的值。
|
||||
|
||||
你可以使用類型註釋來限制一個元組模式來匹配某種元組類型。例如，在常量申明`let (x, y): (Int, Int) = (1, 2)`中的元組模式`(x, y): (Int, Int)`，只匹配兩個元素都是`Int`這種類型的元組。如果僅需要限制一個元組模式中的某幾個元素，只需要直接對這幾個元素提供類型註釋即可。例如，在`let (x: String, y)`中的元組模式，只要某個元組類型是包含兩個元素，且第一個元素類型是`String`，則被匹配。
|
||||
|
||||
當元組模式被用在`for-in`語句或者變量或常量申明時，它可以包含通配符模式，標識符模式或者其他包含這兩種模式的模式。例如，下面這段代碼是不正確的，因為`(x, 0)`中的元素`0`是一個表達式模式：
|
||||
|
||||
```swift
|
||||
let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
|
||||
// This code isn't valid.
|
||||
for (x, 0) in points {
|
||||
/* ... */
|
||||
}
|
||||
```
|
||||
|
||||
對於只包含一個元素的元組，括號是不起作用的。模式匹配那個單個元素的類型。例如，下面是等效的：
|
||||
|
||||
```swift
|
||||
let a = 2 // a: Int = 2
|
||||
let (a) = 2 // a: Int = 2
|
||||
let (a): Int = 2 // a: Int = 2
|
||||
```
|
||||
|
||||
> 元組模式語法
|
||||
> *元組模式* → **(** [*元組模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可選_ **)**
|
||||
> *元組模式元素列表* → [*元組模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) | [*元組模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元組模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list)
|
||||
> *元組模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern)
|
||||
|
||||
<a name="enumeration_case_pattern"></a>
|
||||
## 枚舉用例模式（Enumeration Case Pattern）
|
||||
|
||||
枚舉用例模式匹配現有的枚舉類型的某種用例。枚舉用例模式僅在`switch`語句中的`case`標籤中出現。
|
||||
|
||||
如果你準備匹配的枚舉用例有任何關聯的值，則相應的枚舉用例模式必須指定一個包含每個關聯值元素的元組模式。關於使用`switch`語句來匹配包含關聯值枚舉用例的例子，請參閱`Associated Values`.
|
||||
|
||||
> 枚舉用例模式語法
|
||||
> *enum-case-pattern* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) _可選_ **.** [*枚舉的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元組模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可選_
|
||||
|
||||
<a name="type-casting_patterns"></a>
|
||||
## 類型轉換模式（Type-Casting Patterns）
|
||||
|
||||
有兩種類型轉換模式，`is`模式和`as`模式。這兩種模式均只出現在`switch`語句中的`case`標籤中。`is`模式和`as`模式有以下形式：
|
||||
|
||||
> is `type`
|
||||
> `pattern` as `type`
|
||||
|
||||
`is`模式匹配一個值，如果這個值的類型在運行時（runtime）和`is`模式右邊的指定類型（或者那個類型的子類）是一致的。`is`模式和`is`操作符一樣，它們都進行類型轉換，但是拋棄了返回的類型。
|
||||
|
||||
`as`模式匹配一個值，如果這個值的類型在運行時（runtime）和`as`模式右邊的指定類型（或者那個類型的子類）是一致的。一旦匹配成功，匹配的值的類型被轉換成`as`模式左邊指定的模式。
|
||||
|
||||
關於使用`switch`語句來匹配`is`模式和`as`模式值的例子，請參閱`Type Casting for Any and AnyObject`。
|
||||
|
||||
> 類型轉換模式語法
|
||||
> *type-casting-pattern* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern)
|
||||
> *is模式* → **is** [*類型*](..\chapter3\03_Types.html#type)
|
||||
> *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<a name="expression_pattern"></a>
|
||||
## 表達式模式（Expression Pattern）
|
||||
|
||||
表達式模式代表了一個表達式的值。這個模式只出現在`switch`語句中的`case`標籤中。
|
||||
|
||||
由表達式模式所代表的表達式用Swift標準庫中的`~=`操作符與輸入表達式的值進行比較。如果`~=`操作符返回`true`，則匹配成功。默認情況下，`~=`操作符使用`==`操作符來比較兩個相同類型的值。它也可以匹配一個整數值與一個`Range`對像中的整數範圍，正如下面這個例子所示：
|
||||
|
||||
```swift
|
||||
let point = (1, 2)
|
||||
switch point {
|
||||
case (0, 0):
|
||||
println("(0, 0) is at the origin.")
|
||||
case (-2...2, -2...2):
|
||||
println("(\(point.0), \(point.1)) is near the origin.")
|
||||
default:
|
||||
println("The point is at (\(point.0), \(point.1)).")
|
||||
}
|
||||
// prints "(1, 2) is near the origin.」
|
||||
```
|
||||
|
||||
你可以重載`~=`操作符來提供自定義的表達式行為。例如，你可以重寫上面的例子，以實現用字符串表達的點來比較`point`表達式。
|
||||
|
||||
```swift
|
||||
// Overload the ~= operator to match a string with an integer
|
||||
func ~=(pattern: String, value: Int) -> Bool {
|
||||
return pattern == "\(value)"
|
||||
}
|
||||
switch point {
|
||||
case ("0", "0"):
|
||||
println("(0, 0) is at the origin.")
|
||||
case ("-2...2", "-2...2"):
|
||||
println("(\(point.0), \(point.1)) is near the origin.")
|
||||
default:
|
||||
println("The point is at (\(point.0), \(point.1)).")
|
||||
}
|
||||
// prints "(1, 2) is near the origin.」
|
||||
```
|
||||
|
||||
> 表達式模式語法
|
||||
> *表達式模式* → [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
106
source-tw/chapter3/08_Generic_Parameters_and_Arguments.md
Normal file
106
source-tw/chapter3/08_Generic_Parameters_and_Arguments.md
Normal file
@ -0,0 +1,106 @@
|
||||
> 翻譯：[fd5788](https://github.com/fd5788)
|
||||
> 校對：[yankuangshi](https://github.com/yankuangshi), [stanzhai](https://github.com/stanzhai)
|
||||
|
||||
# 泛型參數
|
||||
---------
|
||||
|
||||
本頁包含內容：
|
||||
|
||||
- [泛型形參子句](#generic_parameter)
|
||||
- [泛型實參子句](#generic_argument)
|
||||
|
||||
本節涉及泛型類型、泛型函數以及泛型構造器的參數，包括形參和實參。聲明泛型類型、函數或構造器時，須指定相應的類型參數。類型參數相當於一個佔位符，當實例化泛型類型、調用泛型函數或泛型構造器時，就用具體的類型實參替代之。
|
||||
|
||||
關於 Swift 語言的泛型概述，見[泛型](../charpter2/22_Generics.md)(第二部分第22章)。
|
||||
|
||||
<a name="generic_parameter"></a>
|
||||
## 泛型形參子句
|
||||
|
||||
泛型形參子句指定泛型類型或函數的類型形參，以及這些參數的關聯約束和要求。泛型形參子句用尖括號（<>）包住，並且有以下兩種形式：
|
||||
|
||||
> <`generic parameter list`>
|
||||
> <`generic parameter list` where `requirements`>
|
||||
|
||||
泛型形參列表中泛型形參用逗號分開，每一個採用以下形式：
|
||||
|
||||
> `type parameter` : `constrain`
|
||||
|
||||
泛型形參由兩部分組成：類型形參及其後的可選約束。類型形參只是佔位符類型（如T，U，V，KeyType，ValueType等）的名字而已。你可以在泛型類型、函數的其餘部分或者構造器聲明，以及函數或構造器的簽名中使用它。
|
||||
|
||||
約束用於指明該類型形參繼承自某個類或者遵守某個協議或協議的一部分。例如，在下面的泛型中，泛型形參`T: Comparable`表示任何用於替代類型形參`T`的類型實參必須滿足`Comparable`協議。
|
||||
|
||||
```swift
|
||||
func simpleMin<T: COmparable>(x: T, y: T) -> T {
|
||||
if x < y {
|
||||
return y
|
||||
}
|
||||
return x
|
||||
}
|
||||
```
|
||||
|
||||
如，`Int`和`Double`均滿足`Comparable`協議，該函數接受任何一種類型。與泛型類型相反，調用泛型函數或構造器時不需要指定泛型實參子句。類型實參由傳遞給函數或構造器的實參推斷而出。
|
||||
|
||||
```swift
|
||||
simpleMin(17, 42) // T is inferred to be Int
|
||||
simpleMin(3.14159, 2.71828) // T is inferred to be Double
|
||||
```
|
||||
|
||||
## Where 子句
|
||||
|
||||
要想對類型形參及其關聯類型指定額外要求，可以在泛型形參列表之後添加`where`子句。`where`子句由關鍵字`where`及其後的用逗號分割的多個要求組成。
|
||||
|
||||
`where`子句中的要求用於指明該類型形參繼承自某個類或遵守某個協議或協議的一部分。儘管`where`子句有助於表達類型形參上的簡單約束（如`T: Comparable`等同於`T where T: Comparable`，等等），但是依然可以用來對類型形參及其關聯約束提供更複雜的約束。如，`<T where T: C, T: P>`表示泛型類型`T`繼承自類`C`且遵守協議`P`。
|
||||
|
||||
如上所述，可以強制約束類型形參的關聯類型遵守某個協議。`<T: Generator where T.Element: Equatable>`表示`T`遵守`Generator`協議，而且`T`的關聯類型`T.Element`遵守`Eauatable`協議（`T`有關聯類型是因為`Generator`聲明了`Element`，而`T`遵守`Generator`協議）。
|
||||
|
||||
也可以用操作符`==`來指定兩個類型等效的要求。例如，有這樣一個約束：`T`和`U`遵守`Generator`協議，同時要求它們的關聯類型等同，可以這樣來表達：`<T: Generator, U: Generator where T.Element == U.Element>`。
|
||||
|
||||
當然，替代類型形參的類型實參必須滿足所有類型形參所要求的約束和要求。
|
||||
|
||||
泛型函數或構造器可以重載，但在泛型形參子句中的類型形參必須有不同的約束或要求，抑或二者皆不同。當調用重載的泛型函數或構造器時，編譯器會用這些約束來決定調用哪個重載函數或構造器。
|
||||
|
||||
泛型類可以生成一個子類，但是這個子類也必須是泛型類。
|
||||
|
||||
> 泛型形參子句語法
|
||||
> *泛型參數子句* → **<** [*泛型參數列表*](GenericParametersAndArguments.html#generic_parameter_list) [*約束子句*](GenericParametersAndArguments.html#requirement_clause) _可選_ **>**
|
||||
> *泛型參數列表* → [*泛形參數*](GenericParametersAndArguments.html#generic_parameter) | [*泛形參數*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型參數列表*](GenericParametersAndArguments.html#generic_parameter_list)
|
||||
> *泛形參數* → [*類型名稱*](..\chapter3\03_Types.html#type_name)
|
||||
> *泛形參數* → [*類型名稱*](..\chapter3\03_Types.html#type_name) **:** [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
> *泛形參數* → [*類型名稱*](..\chapter3\03_Types.html#type_name) **:** [*協議合成類型*](..\chapter3\03_Types.html#protocol_composition_type)
|
||||
> *約束子句* → **where** [*約束列表*](GenericParametersAndArguments.html#requirement_list)
|
||||
> *約束列表* → [*約束*](GenericParametersAndArguments.html#requirement) | [*約束*](GenericParametersAndArguments.html#requirement) **,** [*約束列表*](GenericParametersAndArguments.html#requirement_list)
|
||||
> *約束* → [*一致性約束*](GenericParametersAndArguments.html#conformance_requirement) | [*同類型約束*](GenericParametersAndArguments.html#same_type_requirement)
|
||||
> *一致性約束* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) **:** [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
> *一致性約束* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) **:** [*協議合成類型*](..\chapter3\03_Types.html#protocol_composition_type)
|
||||
> *同類型約束* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) **==** [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
|
||||
|
||||
<a name="generic_argument"></a>
|
||||
## 泛型實參子句
|
||||
|
||||
泛型實參子句指定_泛型類型_的類型實參。泛型實參子句用尖括號（<>）包住，形式如下：
|
||||
|
||||
> <`generic argument list`>
|
||||
|
||||
泛型實參列表中類型實參有逗號分開。類型實參是實際具體類型的名字，用來替代泛型類型的泛型形參子句中的相應的類型形參。從而得到泛型類型的一個特化版本。如，Swift標準庫的泛型字典類型定義如下：
|
||||
|
||||
```swift
|
||||
struct Dictionary<KeyTypel: Hashable, ValueType>: Collection, DictionaryLiteralConvertible {
|
||||
/* .. */
|
||||
}
|
||||
```
|
||||
|
||||
泛型`Dictionary`類型的特化版本，`Dictionary<String, Int>`就是用具體的`String`和`Int`類型替代泛型類型`KeyType: Hashable`和`ValueType`產生的。每一個類型實參必須滿足它所替代的泛型形參的所有約束，包括任何`where`子句所指定的額外的要求。上面的例子中，類型形參`KeyType`要求滿足`Hashable`協議，因此`String`也必須滿足`Hashable`協議。
|
||||
|
||||
可以用本身就是泛型類型的特化版本的類型實參替代類型形參（假設已滿足合適的約束和要求）。例如，為了生成一個元素類型是整型數組的數組，可以用數組的特化版本`Array<Int>`替代泛型類型`Array<T>`的類型形參`T`來實現。
|
||||
|
||||
```swift
|
||||
let arrayOfArrays: Array<Array<Int>> = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
|
||||
```
|
||||
|
||||
如[泛型形參子句](#generic_parameter)所述，不能用泛型實參子句來指定泛型函數或構造器的類型實參。
|
||||
|
||||
> 泛型實參子句語法
|
||||
> *(泛型參數子句Generic Argument Clause)* → **<** [*泛型參數列表*](GenericParametersAndArguments.html#generic_argument_list) **>**
|
||||
> *泛型參數列表* → [*泛型參數*](GenericParametersAndArguments.html#generic_argument) | [*泛型參數*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型參數列表*](GenericParametersAndArguments.html#generic_argument_list)
|
||||
> *泛型參數* → [*類型*](..\chapter3\03_Types.html#type)
|
||||
743
source-tw/chapter3/09_Summary_of_the_Grammar.md
Normal file
743
source-tw/chapter3/09_Summary_of_the_Grammar.md
Normal file
@ -0,0 +1,743 @@
|
||||
> 翻譯：[stanzhai](https://github.com/stanzhai)
|
||||
> 校對：[xielingwang](https://github.com/xielingwang)
|
||||
|
||||
# 語法總結
|
||||
_________________
|
||||
|
||||
本頁包含內容：
|
||||
|
||||
* [語句（Statements）](#statements)
|
||||
* [泛型參數（Generic Parameters and Arguments）](#generic_parameters_and_arguments)
|
||||
* [聲明（Declarations）](#declarations)
|
||||
* [模式（Patterns）](#patterns)
|
||||
* [特性（Attributes）](#attributes)
|
||||
* [表達式（Expressions）](#expressions)
|
||||
* [詞法結構（Lexical Structure）](#lexical_structure)
|
||||
* [類型（Types）](#types)
|
||||
|
||||
<a name="statements"></a>
|
||||
## 語句
|
||||
|
||||
> 語句語法
|
||||
> *語句* → [*表達式*](..\chapter3\04_Expressions.html#expression) **;** _可選_
|
||||
> *語句* → [*聲明*](..\chapter3\05_Declarations.html#declaration) **;** _可選_
|
||||
> *語句* → [*循環語句*](..\chapter3\10_Statements.html#loop_statement) **;** _可選_
|
||||
> *語句* → [*分支語句*](..\chapter3\10_Statements.html#branch_statement) **;** _可選_
|
||||
> *語句* → [*標記語句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement)
|
||||
> *語句* → [*控制轉移語句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可選_
|
||||
> *多條語句(Statements)* → [*語句*](..\chapter3\10_Statements.html#statement) [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 循環語句語法
|
||||
> *循環語句* → [*for語句*](..\chapter3\10_Statements.html#for_statement)
|
||||
> *循環語句* → [*for-in語句*](..\chapter3\10_Statements.html#for_in_statement)
|
||||
> *循環語句* → [*while語句*](..\chapter3\10_Statements.html#wheetatype類型ile_statement)
|
||||
> *循環語句* → [*do-while語句*](..\chapter3\10_Statements.html#do_while_statement)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> For 循環語法
|
||||
> *for語句* → **for** [*for初始條件*](..\chapter3\10_Statements.html#for_init) _可選_ **;** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_ **;** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_ [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *for語句* → **for** **(** [*for初始條件*](..\chapter3\10_Statements.html#for_init) _可選_ **;** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_ **;** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_ **)** [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *for初始條件* → [*變量聲明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表達式列表*](..\chapter3\04_Expressions.html#expression_list)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> For-In 循環語法
|
||||
> *for-in語句* → **for** [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表達式*](..\chapter3\04_Expressions.html#expression) [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> While 循環語法
|
||||
> *while語句* → **while** [*while條件*](..\chapter3\10_Statements.html#while_condition) [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *while條件* → [*表達式*](..\chapter3\04_Expressions.html#expression) | [*聲明*](..\chapter3\05_Declarations.html#declaration)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> Do-While 循環語法
|
||||
> *do-while語句* → **do** [*代碼塊*](..\chapter3\05_Declarations.html#code_block) **while** [*while條件*](..\chapter3\10_Statements.html#while_condition)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 分支語句語法
|
||||
> *分支語句* → [*if語句*](..\chapter3\10_Statements.html#if_statement)
|
||||
> *分支語句* → [*switch語句*](..\chapter3\10_Statements.html#switch_statement)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> If語句語法
|
||||
> *if語句* → **if** [*if條件*](..\chapter3\10_Statements.html#if_condition) [*代碼塊*](..\chapter3\05_Declarations.html#code_block) [*else子句(Clause)*](..\chapter3\10_Statements.html#else_clause) _可選_
|
||||
> *if條件* → [*表達式*](..\chapter3\04_Expressions.html#expression) | [*聲明*](..\chapter3\05_Declarations.html#declaration)
|
||||
> *else子句(Clause)* → **else** [*代碼塊*](..\chapter3\05_Declarations.html#code_block) | **else** [*if語句*](..\chapter3\10_Statements.html#if_statement)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> Switch語句語法
|
||||
> *switch語句* → **switch** [*表達式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可選_ **}**
|
||||
> *SwitchCase列表* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可選_
|
||||
> *SwitchCase* → [*case標籤*](..\chapter3\10_Statements.html#case_label) [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) | [*default標籤*](..\chapter3\10_Statements.html#default_label) [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements)
|
||||
> *SwitchCase* → [*case標籤*](..\chapter3\10_Statements.html#case_label) **;** | [*default標籤*](..\chapter3\10_Statements.html#default_label) **;**
|
||||
> *case標籤* → **case** [*case項列表*](..\chapter3\10_Statements.html#case_item_list) **:**
|
||||
> *case項列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可選_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可選_ **,** [*case項列表*](..\chapter3\10_Statements.html#case_item_list)
|
||||
> *default標籤* → **default** **:**
|
||||
> *guard-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard_expression)
|
||||
> *guard-expression* → [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 標記語句語法
|
||||
> *標記語句(Labeled Statement)* → [*語句標籤*](..\chapter3\10_Statements.html#statement_label) [*循環語句*](..\chapter3\10_Statements.html#loop_statement) | [*語句標籤*](..\chapter3\10_Statements.html#statement_label) [*switch語句*](..\chapter3\10_Statements.html#switch_statement)
|
||||
> *語句標籤* → [*標籤名稱*](..\chapter3\10_Statements.html#label_name) **:**
|
||||
> *標籤名稱* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 控制傳遞語句(Control Transfer Statement) 語法
|
||||
> *控制傳遞語句* → [*break語句*](..\chapter3\10_Statements.html#break_statement)
|
||||
> *控制傳遞語句* → [*continue語句*](..\chapter3\10_Statements.html#continue_statement)
|
||||
> *控制傳遞語句* → [*fallthrough語句*](..\chapter3\10_Statements.html#fallthrough_statement)
|
||||
> *控制傳遞語句* → [*return語句*](..\chapter3\10_Statements.html#return_statement)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> Break 語句語法
|
||||
> *break語句* → **break** [*標籤名稱*](..\chapter3\10_Statements.html#label_name) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> Continue 語句語法
|
||||
> *continue語句* → **continue** [*標籤名稱*](..\chapter3\10_Statements.html#label_name) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> Fallthrough 語句語法
|
||||
> *fallthrough語句* → **fallthrough**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> Return 語句語法
|
||||
> *return語句* → **return** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_
|
||||
|
||||
<a name="generic_parameters_and_arguments"></a>
|
||||
## 泛型參數
|
||||
|
||||
> 泛型形參子句(Generic Parameter Clause) 語法
|
||||
> *泛型參數子句* → **<** [*泛型參數列表*](GenericParametersAndArguments.html#generic_parameter_list) [*約束子句*](GenericParametersAndArguments.html#requirement_clause) _可選_ **>**
|
||||
> *泛型參數列表* → [*泛形參數*](GenericParametersAndArguments.html#generic_parameter) | [*泛形參數*](GenericParametersAndArguments.html#generic_parameter) **,** [*泛型參數列表*](GenericParametersAndArguments.html#generic_parameter_list)
|
||||
> *泛形參數* → [*類型名稱*](..\chapter3\03_Types.html#type_name)
|
||||
> *泛形參數* → [*類型名稱*](..\chapter3\03_Types.html#type_name) **:** [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
> *泛形參數* → [*類型名稱*](..\chapter3\03_Types.html#type_name) **:** [*協議合成類型*](..\chapter3\03_Types.html#protocol_composition_type)
|
||||
> *約束子句* → **where** [*約束列表*](GenericParametersAndArguments.html#requirement_list)
|
||||
> *約束列表* → [*約束*](GenericParametersAndArguments.html#requirement) | [*約束*](GenericParametersAndArguments.html#requirement) **,** [*約束列表*](GenericParametersAndArguments.html#requirement_list)
|
||||
> *約束* → [*一致性約束*](GenericParametersAndArguments.html#conformance_requirement) | [*同類型約束*](GenericParametersAndArguments.html#same_type_requirement)
|
||||
> *一致性約束* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) **:** [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
> *一致性約束* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) **:** [*協議合成類型*](..\chapter3\03_Types.html#protocol_composition_type)
|
||||
> *同類型約束* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) **==** [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 泛型實參子句語法
|
||||
> *(泛型參數子句Generic Argument Clause)* → **<** [*泛型參數列表*](GenericParametersAndArguments.html#generic_argument_list) **>**
|
||||
> *泛型參數列表* → [*泛型參數*](GenericParametersAndArguments.html#generic_argument) | [*泛型參數*](GenericParametersAndArguments.html#generic_argument) **,** [*泛型參數列表*](GenericParametersAndArguments.html#generic_argument_list)
|
||||
> *泛型參數* → [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<a name="declarations"></a>
|
||||
## 聲明 (Declarations)
|
||||
|
||||
> 聲明語法
|
||||
> *聲明* → [*導入聲明*](..\chapter3\05_Declarations.html#import_declaration)
|
||||
> *聲明* → [*常量聲明*](..\chapter3\05_Declarations.html#constant_declaration)
|
||||
> *聲明* → [*變量聲明*](..\chapter3\05_Declarations.html#variable_declaration)
|
||||
> *聲明* → [*類型別名聲明*](..\chapter3\05_Declarations.html#typealias_declaration)
|
||||
> *聲明* → [*函數聲明*](..\chapter3\05_Declarations.html#function_declaration)
|
||||
> *聲明* → [*枚舉聲明*](..\chapter3\05_Declarations.html#enum_declaration)
|
||||
> *聲明* → [*結構體聲明*](..\chapter3\05_Declarations.html#struct_declaration)
|
||||
> *聲明* → [*類聲明*](..\chapter3\05_Declarations.html#class_declaration)
|
||||
> *聲明* → [*協議聲明*](..\chapter3\05_Declarations.html#protocol_declaration)
|
||||
> *聲明* → [*構造器聲明*](..\chapter3\05_Declarations.html#initializer_declaration)
|
||||
> *聲明* → [*析構器聲明*](..\chapter3\05_Declarations.html#deinitializer_declaration)
|
||||
> *聲明* → [*擴展聲明*](..\chapter3\05_Declarations.html#extension_declaration)
|
||||
> *聲明* → [*下標腳本聲明*](..\chapter3\05_Declarations.html#subscript_declaration)
|
||||
> *聲明* → [*運算符聲明*](..\chapter3\05_Declarations.html#operator_declaration)
|
||||
> *聲明(Declarations)列表* → [*聲明*](..\chapter3\05_Declarations.html#declaration) [*聲明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可選_
|
||||
> *聲明描述符(Specifiers)列表* → [*聲明描述符(Specifier)*](..\chapter3\05_Declarations.html#declaration_specifier) [*聲明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可選_
|
||||
> *聲明描述符(Specifier)* → **class** | **mutating** | **nonmutating** | **override** | **static** | **unowned** | **unowned(safe)** | **unowned(unsafe)** | **weak**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 頂級(Top Level) 聲明語法
|
||||
> *頂級聲明* → [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 代碼塊語法
|
||||
> *代碼塊* → **{** [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) _可選_ **}**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 導入(Import)聲明語法
|
||||
> *導入聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **import** [*導入類型*](..\chapter3\05_Declarations.html#import_kind) _可選_ [*導入路徑*](..\chapter3\05_Declarations.html#import_path)
|
||||
> *導入類型* → **typealias** | **struct** | **class** | **enum** | **protocol** | **var** | **func**
|
||||
> *導入路徑* → [*導入路徑標識符*](..\chapter3\05_Declarations.html#import_path_identifier) | [*導入路徑標識符*](..\chapter3\05_Declarations.html#import_path_identifier) **.** [*導入路徑*](..\chapter3\05_Declarations.html#import_path)
|
||||
> *導入路徑標識符* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*運算符*](..\chapter3\02_Lexical_Structure.html#operator)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 常數聲明語法
|
||||
> *常量聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*聲明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可選_ **let** [*模式構造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)
|
||||
> *模式構造器列表* → [*模式構造器*](..\chapter3\05_Declarations.html#pattern_initializer) | [*模式構造器*](..\chapter3\05_Declarations.html#pattern_initializer) **,** [*模式構造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)
|
||||
> *模式構造器* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*構造器*](..\chapter3\05_Declarations.html#initializer) _可選_
|
||||
> *構造器* → **=** [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 變量聲明語法
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*模式構造器列表*](..\chapter3\05_Declarations.html#pattern_initializer_list)
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter塊*](..\chapter3\05_Declarations.html#getter_setter_block)
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter關鍵字(Keyword)塊*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
|
||||
> *變量聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*構造器*](..\chapter3\05_Declarations.html#initializer) _可選_ [*willSet-didSet代碼塊*](..\chapter3\05_Declarations.html#willSet_didSet_block)
|
||||
> *變量聲明頭(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*聲明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可選_ **var**
|
||||
> *變量名稱* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *getter-setter塊* → **{** [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) _可選_ **}**
|
||||
> *getter-setter塊* → **{** [*setter子句*](..\chapter3\05_Declarations.html#setter_clause) [*getter子句*](..\chapter3\05_Declarations.html#getter_clause) **}**
|
||||
> *getter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **get** [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *setter子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **set** [*setter名稱*](..\chapter3\05_Declarations.html#setter_name) _可選_ [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *setter名稱* → **(** [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) **)**
|
||||
> *getter-setter關鍵字(Keyword)塊* → **{** [*getter關鍵字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) [*setter關鍵字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) _可選_ **}**
|
||||
> *getter-setter關鍵字(Keyword)塊* → **{** [*setter關鍵字(Keyword)子句*](..\chapter3\05_Declarations.html#setter_keyword_clause) [*getter關鍵字(Keyword)子句*](..\chapter3\05_Declarations.html#getter_keyword_clause) **}**
|
||||
> *getter關鍵字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **get**
|
||||
> *setter關鍵字(Keyword)子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **set**
|
||||
> *willSet-didSet代碼塊* → **{** [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) _可選_ **}**
|
||||
> *willSet-didSet代碼塊* → **{** [*didSet子句*](..\chapter3\05_Declarations.html#didSet_clause) [*willSet子句*](..\chapter3\05_Declarations.html#willSet_clause) **}**
|
||||
> *willSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **willSet** [*setter名稱*](..\chapter3\05_Declarations.html#setter_name) _可選_ [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *didSet子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **didSet** [*setter名稱*](..\chapter3\05_Declarations.html#setter_name) _可選_ [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 類型別名聲明語法
|
||||
> *類型別名聲明* → [*類型別名頭(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*類型別名賦值*](..\chapter3\05_Declarations.html#typealias_assignment)
|
||||
> *類型別名頭(Head)* → **typealias** [*類型別名名稱*](..\chapter3\05_Declarations.html#typealias_name)
|
||||
> *類型別名名稱* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *類型別名賦值* → **=** [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 函數聲明語法
|
||||
> *函數聲明* → [*函數頭*](..\chapter3\05_Declarations.html#function_head) [*函數名*](..\chapter3\05_Declarations.html#function_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*函數簽名(Signature)*](..\chapter3\05_Declarations.html#function_signature) [*函數體*](..\chapter3\05_Declarations.html#function_body)
|
||||
> *函數頭* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*聲明描述符(Specifiers)列表*](..\chapter3\05_Declarations.html#declaration_specifiers) _可選_ **func**
|
||||
> *函數名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*運算符*](..\chapter3\02_Lexical_Structure.html#operator)
|
||||
> *函數簽名(Signature)* → [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_
|
||||
> *函數結果* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
> *函數體* → [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *parameter-clauses* → [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause) [*parameter-clauses*](..\chapter3\05_Declarations.html#parameter_clauses) _可選_
|
||||
> *參數子句* → **(** **)** | **(** [*參數列表*](..\chapter3\05_Declarations.html#parameter_list) **...** _可選_ **)**
|
||||
> *參數列表* → [*參數*](..\chapter3\05_Declarations.html#parameter) | [*參數*](..\chapter3\05_Declarations.html#parameter) **,** [*參數列表*](..\chapter3\05_Declarations.html#parameter_list)
|
||||
> *參數* → **inout** _可選_ **let** _可選_ **#** _可選_ [*參數名*](..\chapter3\05_Declarations.html#parameter_name) [*本地參數名*](..\chapter3\05_Declarations.html#local_parameter_name) _可選_ [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*默認參數子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可選_
|
||||
> *參數* → **inout** _可選_ **var** **#** _可選_ [*參數名*](..\chapter3\05_Declarations.html#parameter_name) [*本地參數名*](..\chapter3\05_Declarations.html#local_parameter_name) _可選_ [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*默認參數子句*](..\chapter3\05_Declarations.html#default_argument_clause) _可選_
|
||||
> *參數* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
> *參數名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) | **_**
|
||||
> *本地參數名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) | **_**
|
||||
> *默認參數子句* → **=** [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 枚舉聲明語法
|
||||
> *枚舉聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*聯合式枚舉*](..\chapter3\05_Declarations.html#union_style_enum) | [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*原始值式枚舉*](..\chapter3\05_Declarations.html#raw_value_style_enum)
|
||||
> *聯合式枚舉* → [*枚舉名*](..\chapter3\05_Declarations.html#enum_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ **{** [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可選_ **}**
|
||||
> *union-style-enum-members* → [*union-style-enum-member*](..\chapter3\05_Declarations.html#union_style_enum_member) [*union-style-enum-members*](..\chapter3\05_Declarations.html#union_style_enum_members) _可選_
|
||||
> *union-style-enum-member* → [*聲明*](..\chapter3\05_Declarations.html#declaration) | [*聯合式(Union Style)的枚舉case子句*](..\chapter3\05_Declarations.html#union_style_enum_case_clause)
|
||||
> *聯合式(Union Style)的枚舉case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **case** [*聯合式(Union Style)的枚舉case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)
|
||||
> *聯合式(Union Style)的枚舉case列表* → [*聯合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) | [*聯合式(Union Style)的case*](..\chapter3\05_Declarations.html#union_style_enum_case) **,** [*聯合式(Union Style)的枚舉case列表*](..\chapter3\05_Declarations.html#union_style_enum_case_list)
|
||||
> *聯合式(Union Style)的case* → [*枚舉的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元組類型*](..\chapter3\03_Types.html#tuple_type) _可選_
|
||||
> *枚舉名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *枚舉的case名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *原始值式枚舉* → [*枚舉名*](..\chapter3\05_Declarations.html#enum_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ **:** [*類型標識*](..\chapter3\03_Types.html#type_identifier) **{** [*原始值式枚舉成員列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可選_ **}**
|
||||
> *原始值式枚舉成員列表* → [*原始值式枚舉成員*](..\chapter3\05_Declarations.html#raw_value_style_enum_member) [*原始值式枚舉成員列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_members) _可選_
|
||||
> *原始值式枚舉成員* → [*聲明*](..\chapter3\05_Declarations.html#declaration) | [*原始值式枚舉case子句*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_clause)
|
||||
> *原始值式枚舉case子句* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **case** [*原始值式枚舉case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)
|
||||
> *原始值式枚舉case列表* → [*原始值式枚舉case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) | [*原始值式枚舉case*](..\chapter3\05_Declarations.html#raw_value_style_enum_case) **,** [*原始值式枚舉case列表*](..\chapter3\05_Declarations.html#raw_value_style_enum_case_list)
|
||||
> *原始值式枚舉case* → [*枚舉的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*原始值賦值*](..\chapter3\05_Declarations.html#raw_value_assignment) _可選_
|
||||
> *原始值賦值* → **=** [*字面量*](..\chapter3\02_Lexical_Structure.html#literal)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 結構體聲明語法
|
||||
> *結構體聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **struct** [*結構體名稱*](..\chapter3\05_Declarations.html#struct_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*結構體主體*](..\chapter3\05_Declarations.html#struct_body)
|
||||
> *結構體名稱* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *結構體主體* → **{** [*聲明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可選_ **}**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 類聲明語法
|
||||
> *類聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **class** [*類名*](..\chapter3\05_Declarations.html#class_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*類主體*](..\chapter3\05_Declarations.html#class_body)
|
||||
> *類名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *類主體* → **{** [*聲明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可選_ **}**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 協議(Protocol)聲明語法
|
||||
> *協議聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **protocol** [*協議名*](..\chapter3\05_Declarations.html#protocol_name) [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*協議主體*](..\chapter3\05_Declarations.html#protocol_body)
|
||||
> *協議名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *協議主體* → **{** [*協議成員聲明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可選_ **}**
|
||||
> *協議成員聲明* → [*協議屬性聲明*](..\chapter3\05_Declarations.html#protocol_property_declaration)
|
||||
> *協議成員聲明* → [*協議方法聲明*](..\chapter3\05_Declarations.html#protocol_method_declaration)
|
||||
> *協議成員聲明* → [*協議構造器聲明*](..\chapter3\05_Declarations.html#protocol_initializer_declaration)
|
||||
> *協議成員聲明* → [*協議下標腳本聲明*](..\chapter3\05_Declarations.html#protocol_subscript_declaration)
|
||||
> *協議成員聲明* → [*協議關聯類型聲明*](..\chapter3\05_Declarations.html#protocol_associated_type_declaration)
|
||||
> *協議成員聲明(Declarations)列表* → [*協議成員聲明*](..\chapter3\05_Declarations.html#protocol_member_declaration) [*協議成員聲明(Declarations)列表*](..\chapter3\05_Declarations.html#protocol_member_declarations) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 協議屬性聲明語法
|
||||
> *協議屬性聲明* → [*變量聲明頭(Head)*](..\chapter3\05_Declarations.html#variable_declaration_head) [*變量名*](..\chapter3\05_Declarations.html#variable_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation) [*getter-setter關鍵字(Keyword)塊*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 協議方法聲明語法
|
||||
> *協議方法聲明* → [*函數頭*](..\chapter3\05_Declarations.html#function_head) [*函數名*](..\chapter3\05_Declarations.html#function_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*函數簽名(Signature)*](..\chapter3\05_Declarations.html#function_signature)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 協議構造器聲明語法
|
||||
> *協議構造器聲明* → [*構造器頭(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 協議下標腳本聲明語法
|
||||
> *協議下標腳本聲明* → [*下標腳本頭(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下標腳本結果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter關鍵字(Keyword)塊*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 協議關聯類型聲明語法
|
||||
> *協議關聯類型聲明* → [*類型別名頭(Head)*](..\chapter3\05_Declarations.html#typealias_head) [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*類型別名賦值*](..\chapter3\05_Declarations.html#typealias_assignment) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 構造器聲明語法
|
||||
> *構造器聲明* → [*構造器頭(Head)*](..\chapter3\05_Declarations.html#initializer_head) [*泛型參數子句*](GenericParametersAndArguments.html#generic_parameter_clause) _可選_ [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause) [*構造器主體*](..\chapter3\05_Declarations.html#initializer_body)
|
||||
> *構造器頭(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **convenience** _可選_ **init**
|
||||
> *構造器主體* → [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 析構器聲明語法
|
||||
> *析構器聲明* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **deinit** [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 擴展(Extension)聲明語法
|
||||
> *擴展聲明* → **extension** [*類型標識*](..\chapter3\03_Types.html#type_identifier) [*類型繼承子句*](..\chapter3\03_Types.html#type_inheritance_clause) _可選_ [*extension-body*](..\chapter3\05_Declarations.html#extension_body)
|
||||
> *extension-body* → **{** [*聲明(Declarations)列表*](..\chapter3\05_Declarations.html#declarations) _可選_ **}**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 下標腳本聲明語法
|
||||
> *下標腳本聲明* → [*下標腳本頭(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下標腳本結果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *下標腳本聲明* → [*下標腳本頭(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下標腳本結果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter塊*](..\chapter3\05_Declarations.html#getter_setter_block)
|
||||
> *下標腳本聲明* → [*下標腳本頭(Head)*](..\chapter3\05_Declarations.html#subscript_head) [*下標腳本結果(Result)*](..\chapter3\05_Declarations.html#subscript_result) [*getter-setter關鍵字(Keyword)塊*](..\chapter3\05_Declarations.html#getter_setter_keyword_block)
|
||||
> *下標腳本頭(Head)* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **subscript** [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause)
|
||||
> *下標腳本結果(Result)* → **->** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 運算符聲明語法
|
||||
> *運算符聲明* → [*前置運算符聲明*](..\chapter3\05_Declarations.html#prefix_operator_declaration) | [*後置運算符聲明*](..\chapter3\05_Declarations.html#postfix_operator_declaration) | [*中置運算符聲明*](..\chapter3\05_Declarations.html#infix_operator_declaration)
|
||||
> *前置運算符聲明* → **運算符** **prefix** [*運算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** **}**
|
||||
> *後置運算符聲明* → **運算符** **postfix** [*運算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** **}**
|
||||
> *中置運算符聲明* → **運算符** **infix** [*運算符*](..\chapter3\02_Lexical_Structure.html#operator) **{** [*中置運算符屬性*](..\chapter3\05_Declarations.html#infix_operator_attributes) _可選_ **}**
|
||||
> *中置運算符屬性* → [*優先級子句*](..\chapter3\05_Declarations.html#precedence_clause) _可選_ [*結和性子句*](..\chapter3\05_Declarations.html#associativity_clause) _可選_
|
||||
> *優先級子句* → **precedence** [*優先級水平*](..\chapter3\05_Declarations.html#precedence_level)
|
||||
> *優先級水平* → 數值 0 到 255
|
||||
> *結和性子句* → **associativity** [*結和性*](..\chapter3\05_Declarations.html#associativity)
|
||||
> *結和性* → **left** | **right** | **none**
|
||||
|
||||
<a name="patterns"></a>
|
||||
## 模式
|
||||
|
||||
> 模式(Patterns) 語法
|
||||
> *模式* → [*通配符模式*](..\chapter3\07_Patterns.html#wildcard_pattern) [*類型註解*](..\chapter3\03_Types.html#type_annotation) _可選_
|
||||
> *模式* → [*標識符模式*](..\chapter3\07_Patterns.html#identifier_pattern) [*類型註解*](..\chapter3\03_Types.html#type_annotati(Value Binding)on) _可選_
|
||||
> *模式* → [*值綁定模式*](..\chapter3\07_Patterns.html#value_binding_pattern)
|
||||
> *模式* → [*元組模式*](..\chapter3\07_Patterns.html#tuple_pattern) [*類型註解*](..\chapter3\03_Types.html#type_annotation) _可選_
|
||||
> *模式* → [*enum-case-pattern*](..\chapter3\07_Patterns.html#enum_case_pattern)
|
||||
> *模式* → [*type-casting-pattern*](..\chapter3\07_Patterns.html#type_casting_pattern)
|
||||
> *模式* → [*表達式模式*](..\chapter3\07_Patterns.html#expression_pattern)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 通配符模式語法
|
||||
> *通配符模式* → **_**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 標識符模式語法
|
||||
> *標識符模式* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 值綁定(Value Binding)模式語法
|
||||
> *值綁定模式* → **var** [*模式*](..\chapter3\07_Patterns.html#pattern) | **let** [*模式*](..\chapter3\07_Patterns.html#pattern)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 元組模式語法
|
||||
> *元組模式* → **(** [*元組模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list) _可選_ **)**
|
||||
> *元組模式元素列表* → [*元組模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) | [*元組模式元素*](..\chapter3\07_Patterns.html#tuple_pattern_element) **,** [*元組模式元素列表*](..\chapter3\07_Patterns.html#tuple_pattern_element_list)
|
||||
> *元組模式元素* → [*模式*](..\chapter3\07_Patterns.html#pattern)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 枚舉用例模式語法
|
||||
> *enum-case-pattern* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) _可選_ **.** [*枚舉的case名*](..\chapter3\05_Declarations.html#enum_case_name) [*元組模式*](..\chapter3\07_Patterns.html#tuple_pattern) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 類型轉換模式語法
|
||||
> *type-casting-pattern* → [*is模式*](..\chapter3\07_Patterns.html#is_pattern) | [*as模式*](..\chapter3\07_Patterns.html#as_pattern)
|
||||
> *is模式* → **is** [*類型*](..\chapter3\03_Types.html#type)
|
||||
> *as模式* → [*模式*](..\chapter3\07_Patterns.html#pattern) **as** [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 表達式模式語法
|
||||
> *表達式模式* → [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<a name="attributes"></a>
|
||||
## 特性
|
||||
|
||||
> 特性語法
|
||||
> *特色* → **@** [*特性名*](..\chapter3\06_Attributes.html#attribute_name) [*特性參數子句*](..\chapter3\06_Attributes.html#attribute_argument_clause) _可選_
|
||||
> *特性名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *特性參數子句* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_ **)**
|
||||
> *特性(Attributes)列表* → [*特色*](..\chapter3\06_Attributes.html#attribute) [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_
|
||||
> *平衡令牌列表* → [*平衡令牌*](..\chapter3\06_Attributes.html#balanced_token) [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_
|
||||
> *平衡令牌* → **(** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_ **)**
|
||||
> *平衡令牌* → **[** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_ **]**
|
||||
> *平衡令牌* → **{** [*平衡令牌列表*](..\chapter3\06_Attributes.html#balanced_tokens) _可選_ **}**
|
||||
> *平衡令牌* → **任意標識符, 關鍵字, 字面量或運算符**
|
||||
> *平衡令牌* → **任意標點除了(, ), [, ], {, 或 }**
|
||||
|
||||
<a name="expressions"></a>
|
||||
## 表達式
|
||||
|
||||
> 表達式語法
|
||||
> *表達式* → [*前置表達式*](..\chapter3\04_Expressions.html#prefix_expression) [*二元表達式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可選_
|
||||
> *表達式列表* → [*表達式*](..\chapter3\04_Expressions.html#expression) | [*表達式*](..\chapter3\04_Expressions.html#expression) **,** [*表達式列表*](..\chapter3\04_Expressions.html#expression_list)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 前置表達式語法
|
||||
> *前置表達式* → [*前置運算符*](..\chapter3\02_Lexical_Structure.html#prefix_operator) _可選_ [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression)
|
||||
> *前置表達式* → [*寫入寫出(in-out)表達式*](..\chapter3\04_Expressions.html#in_out_expression)
|
||||
> *寫入寫出(in-out)表達式* → **&** [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 二元表達式語法
|
||||
> *二元表達式* → [*二元運算符*](..\chapter3\02_Lexical_Structure.html#binary_operator) [*前置表達式*](..\chapter3\04_Expressions.html#prefix_expression)
|
||||
> *二元表達式* → [*賦值運算符*](..\chapter3\04_Expressions.html#assignment_operator) [*前置表達式*](..\chapter3\04_Expressions.html#prefix_expression)
|
||||
> *二元表達式* → [*條件運算符*](..\chapter3\04_Expressions.html#conditional_operator) [*前置表達式*](..\chapter3\04_Expressions.html#prefix_expression)
|
||||
> *二元表達式* → [*類型轉換運算符*](..\chapter3\04_Expressions.html#type_casting_operator)
|
||||
> *二元表達式列表* → [*二元表達式*](..\chapter3\04_Expressions.html#binary_expression) [*二元表達式列表*](..\chapter3\04_Expressions.html#binary_expressions) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 賦值運算符語法
|
||||
> *賦值運算符* → **=**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 三元條件運算符語法
|
||||
> *三元條件運算符* → **?** [*表達式*](..\chapter3\04_Expressions.html#expression) **:**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 類型轉換運算符語法
|
||||
> *類型轉換運算符* → **is** [*類型*](..\chapter3\03_Types.html#type) | **as** **?** _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 主表達式語法
|
||||
> *主表達式* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型參數子句*](GenericParametersAndArguments.html#generic_argument_clause) _可選_
|
||||
> *主表達式* → [*字面量表達式*](..\chapter3\04_Expressions.html#literal_expression)
|
||||
> *主表達式* → [*self表達式*](..\chapter3\04_Expressions.html#self_expression)
|
||||
> *主表達式* → [*超類表達式*](..\chapter3\04_Expressions.html#superclass_expression)
|
||||
> *主表達式* → [*閉包表達式*](..\chapter3\04_Expressions.html#closure_expression)
|
||||
> *主表達式* → [*圓括號表達式*](..\chapter3\04_Expressions.html#parenthesized_expression)
|
||||
> *主表達式* → [*隱式成員表達式*](..\chapter3\04_Expressions.html#implicit_member_expression)
|
||||
> *主表達式* → [*通配符表達式*](..\chapter3\04_Expressions.html#wildcard_expression)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 字面量表達式語法
|
||||
> *字面量表達式* → [*字面量*](..\chapter3\02_Lexical_Structure.html#literal)
|
||||
> *字面量表達式* → [*數組字面量*](..\chapter3\04_Expressions.html#array_literal) | [*字典字面量*](..\chapter3\04_Expressions.html#dictionary_literal)
|
||||
> *字面量表達式* → **__FILE__** | **__LINE__** | **__COLUMN__** | **__FUNCTION__**
|
||||
> *數組字面量* → **[** [*數組字面量項列表*](..\chapter3\04_Expressions.html#array_literal_items) _可選_ **]**
|
||||
> *數組字面量項列表* → [*數組字面量項*](..\chapter3\04_Expressions.html#array_literal_item) **,** _可選_ | [*數組字面量項*](..\chapter3\04_Expressions.html#array_literal_item) **,** [*數組字面量項列表*](..\chapter3\04_Expressions.html#array_literal_items)
|
||||
> *數組字面量項* → [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
> *字典字面量* → **[** [*字典字面量項列表*](..\chapter3\04_Expressions.html#dictionary_literal_items) **]** | **[** **:** **]**
|
||||
> *字典字面量項列表* → [*字典字面量項*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** _可選_ | [*字典字面量項*](..\chapter3\04_Expressions.html#dictionary_literal_item) **,** [*字典字面量項列表*](..\chapter3\04_Expressions.html#dictionary_literal_items)
|
||||
> *字典字面量項* → [*表達式*](..\chapter3\04_Expressions.html#expression) **:** [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> Self 表達式語法
|
||||
> *self表達式* → **self**
|
||||
> *self表達式* → **self** **.** [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *self表達式* → **self** **[** [*表達式*](..\chapter3\04_Expressions.html#expression) **]**
|
||||
> *self表達式* → **self** **.** **init**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 超類表達式語法
|
||||
> *超類表達式* → [*超類方法表達式*](..\chapter3\04_Expressions.html#superclass_method_expression) | [*超類下標表達式*](..\chapter3\04_Expressions.html#超類下標表達式) | [*超類構造器表達式*](..\chapter3\04_Expressions.html#superclass_initializer_expression)
|
||||
> *超類方法表達式* → **super** **.** [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
> *超類下標表達式* → **super** **[** [*表達式*](..\chapter3\04_Expressions.html#expression) **]**
|
||||
> *超類構造器表達式* → **super** **.** **init**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 閉包表達式語法
|
||||
> *閉包表達式* → **{** [*閉包簽名(Signational)*](..\chapter3\04_Expressions.html#closure_signature) _可選_ [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) **}**
|
||||
> *閉包簽名(Signational)* → [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_ **in**
|
||||
> *閉包簽名(Signational)* → [*標識符列表*](..\chapter3\02_Lexical_Structure.html#identifier_list) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_ **in**
|
||||
> *閉包簽名(Signational)* → [*捕獲(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*參數子句*](..\chapter3\05_Declarations.html#parameter_clause) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_ **in**
|
||||
> *閉包簽名(Signational)* → [*捕獲(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) [*標識符列表*](..\chapter3\02_Lexical_Structure.html#identifier_list) [*函數結果*](..\chapter3\05_Declarations.html#function_result) _可選_ **in**
|
||||
> *閉包簽名(Signational)* → [*捕獲(Capature)列表*](..\chapter3\04_Expressions.html#capture_list) **in**
|
||||
> *捕獲(Capature)列表* → **[** [*捕獲(Capature)說明符*](..\chapter3\04_Expressions.html#capture_specifier) [*表達式*](..\chapter3\04_Expressions.html#expression) **]**
|
||||
> *捕獲(Capature)說明符* → **weak** | **unowned** | **unowned(safe)** | **unowned(unsafe)**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 隱式成員表達式語法
|
||||
> *隱式成員表達式* → **.** [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 圓括號表達式(Parenthesized Expression)語法
|
||||
> *圓括號表達式* → **(** [*表達式元素列表*](..\chapter3\04_Expressions.html#expression_element_list) _可選_ **)**
|
||||
> *表達式元素列表* → [*表達式元素*](..\chapter3\04_Expressions.html#expression_element) | [*表達式元素*](..\chapter3\04_Expressions.html#expression_element) **,** [*表達式元素列表*](..\chapter3\04_Expressions.html#expression_element_list)
|
||||
> *表達式元素* → [*表達式*](..\chapter3\04_Expressions.html#expression) | [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) **:** [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 通配符表達式語法
|
||||
> *通配符表達式* → **_**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 後置表達式語法
|
||||
> *後置表達式* → [*主表達式*](..\chapter3\04_Expressions.html#primary_expression)
|
||||
> *後置表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) [*後置運算符*](..\chapter3\02_Lexical_Structure.html#postfix_operator)
|
||||
> *後置表達式* → [*函數調用表達式*](..\chapter3\04_Expressions.html#function_call_expression)
|
||||
> *後置表達式* → [*構造器表達式*](..\chapter3\04_Expressions.html#initializer_expression)
|
||||
> *後置表達式* → [*顯示成員表達式*](..\chapter3\04_Expressions.html#explicit_member_expression)
|
||||
> *後置表達式* → [*後置self表達式*](..\chapter3\04_Expressions.html#postfix_self_expression)
|
||||
> *後置表達式* → [*動態類型表達式*](..\chapter3\04_Expressions.html#dynamic_type_expression)
|
||||
> *後置表達式* → [*下標表達式*](..\chapter3\04_Expressions.html#subscript_expression)
|
||||
> *後置表達式* → [*強制取值(Forced Value)表達式*](..\chapter3\04_Expressions.html#forced_value_expression)
|
||||
> *後置表達式* → [*可選鏈(Optional Chaining)表達式*](..\chapter3\04_Expressions.html#optional_chaining_expression)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 函數調用表達式語法
|
||||
> *函數調用表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) [*圓括號表達式*](..\chapter3\04_Expressions.html#parenthesized_expression)
|
||||
> *函數調用表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) [*圓括號表達式*](..\chapter3\04_Expressions.html#parenthesized_expression) _可選_ [*後置閉包(Trailing Closure)*](..\chapter3\04_Expressions.html#trailing_closure)
|
||||
> *後置閉包(Trailing Closure)* → [*閉包表達式*](..\chapter3\04_Expressions.html#closure_expression)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 構造器表達式語法
|
||||
> *構造器表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **init**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 顯式成員表達式語法
|
||||
> *顯示成員表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*十進制數字*](..\chapter3\02_Lexical_Structure.html#decimal_digit)
|
||||
> *顯示成員表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) [*泛型參數子句*](GenericParametersAndArguments.html#generic_argument_clause) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 後置Self 表達式語法
|
||||
> *後置self表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **self**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 動態類型表達式語法
|
||||
> *動態類型表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **.** **dynamicType**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 附屬腳本表達式語法
|
||||
> *附屬腳本表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **[** [*表達式列表*](..\chapter3\04_Expressions.html#expression_list) **]**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 強制取值(Forced Value)語法
|
||||
> *強制取值(Forced Value)表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **!**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 可選鏈表達式語法
|
||||
> *可選鏈表達式* → [*後置表達式*](..\chapter3\04_Expressions.html#postfix_expression) **?**
|
||||
|
||||
<a name="lexical_structure"></a>
|
||||
## 詞法結構
|
||||
|
||||
> 標識符語法
|
||||
> *標識符* → [*標識符頭(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head) [*標識符字符列表*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可選_
|
||||
> *標識符* → **`** [*標識符頭(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head) [*標識符字符列表*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可選_ **`**
|
||||
> *標識符* → [*隱式參數名*](..\chapter3\02_Lexical_Structure.html#implicit_parameter_name)
|
||||
> *標識符列表* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) | [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier) **,** [*標識符列表*](..\chapter3\02_Lexical_Structure.html#identifier_list)
|
||||
> *標識符頭(Head)* → Upper- or lowercase letter A through Z
|
||||
> *標識符頭(Head)* → U+00A8, U+00AA, U+00AD, U+00AF, U+00B2–U+00B5, or U+00B7–U+00BA
|
||||
> *標識符頭(Head)* → U+00BC–U+00BE, U+00C0–U+00D6, U+00D8–U+00F6, or U+00F8–U+00FF
|
||||
> *標識符頭(Head)* → U+0100–U+02FF, U+0370–U+167F, U+1681–U+180D, or U+180F–U+1DBF
|
||||
> *標識符頭(Head)* → U+1E00–U+1FFF
|
||||
> *標識符頭(Head)* → U+200B–U+200D, U+202A–U+202E, U+203F–U+2040, U+2054, or U+2060–U+206F
|
||||
> *標識符頭(Head)* → U+2070–U+20CF, U+2100–U+218F, U+2460–U+24FF, or U+2776–U+2793
|
||||
> *標識符頭(Head)* → U+2C00–U+2DFF or U+2E80–U+2FFF
|
||||
> *標識符頭(Head)* → U+3004–U+3007, U+3021–U+302F, U+3031–U+303F, or U+3040–U+D7FF
|
||||
> *標識符頭(Head)* → U+F900–U+FD3D, U+FD40–U+FDCF, U+FDF0–U+FE1F, or U+FE30–U+FE44
|
||||
> *標識符頭(Head)* → U+FE47–U+FFFD
|
||||
> *標識符頭(Head)* → U+10000–U+1FFFD, U+20000–U+2FFFD, U+30000–U+3FFFD, or U+40000–U+4FFFD
|
||||
> *標識符頭(Head)* → U+50000–U+5FFFD, U+60000–U+6FFFD, U+70000–U+7FFFD, or U+80000–U+8FFFD
|
||||
> *標識符頭(Head)* → U+90000–U+9FFFD, U+A0000–U+AFFFD, U+B0000–U+BFFFD, or U+C0000–U+CFFFD
|
||||
> *標識符頭(Head)* → U+D0000–U+DFFFD or U+E0000–U+EFFFD
|
||||
> *標識符字符* → 數值 0 到 9
|
||||
> *標識符字符* → U+0300–U+036F, U+1DC0–U+1DFF, U+20D0–U+20FF, or U+FE20–U+FE2F
|
||||
> *標識符字符* → [*標識符頭(Head)*](..\chapter3\02_Lexical_Structure.html#identifier_head)
|
||||
> *標識符字符列表* → [*標識符字符*](..\chapter3\02_Lexical_Structure.html#identifier_character) [*標識符字符列表*](..\chapter3\02_Lexical_Structure.html#identifier_characters) _可選_
|
||||
> *隱式參數名* → **$** [*十進制數字列表*](..\chapter3\02_Lexical_Structure.html#decimal_digits)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 字面量語法
|
||||
> *字面量* → [*整型字面量*](..\chapter3\02_Lexical_Structure.html#integer_literal) | [*浮點數字面量*](..\chapter3\02_Lexical_Structure.html#floating_point_literal) | [*字符串字面量*](..\chapter3\02_Lexical_Structure.html#string_literal)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 整型字面量語法
|
||||
> *整型字面量* → [*二進制字面量*](..\chapter3\02_Lexical_Structure.html#binary_literal)
|
||||
> *整型字面量* → [*八進制字面量*](..\chapter3\02_Lexical_Structure.html#octal_literal)
|
||||
> *整型字面量* → [*十進制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)
|
||||
> *整型字面量* → [*十六進制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal)
|
||||
> *二進制字面量* → **0b** [*二進制數字*](..\chapter3\02_Lexical_Structure.html#binary_digit) [*二進制字面量字符列表*](..\chapter3\02_Lexical_Structure.html#binary_literal_characters) _可選_
|
||||
> *二進制數字* → 數值 0 到 1
|
||||
> *二進制字面量字符* → [*二進制數字*](..\chapter3\02_Lexical_Structure.html#binary_digit) | **_**
|
||||
> *二進制字面量字符列表* → [*二進制字面量字符*](..\chapter3\02_Lexical_Structure.html#binary_literal_character) [*二進制字面量字符列表*](..\chapter3\02_Lexical_Structure.html#binary_literal_characters) _可選_
|
||||
> *八進制字面量* → **0o** [*八進字數字*](..\chapter3\02_Lexical_Structure.html#octal_digit) [*八進制字符列表*](..\chapter3\02_Lexical_Structure.html#octal_literal_characters) _可選_
|
||||
> *八進字數字* → 數值 0 到 7
|
||||
> *八進制字符* → [*八進字數字*](..\chapter3\02_Lexical_Structure.html#octal_digit) | **_**
|
||||
> *八進制字符列表* → [*八進制字符*](..\chapter3\02_Lexical_Structure.html#octal_literal_character) [*八進制字符列表*](..\chapter3\02_Lexical_Structure.html#octal_literal_characters) _可選_
|
||||
> *十進制字面量* → [*十進制數字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) [*十進制字符列表*](..\chapter3\02_Lexical_Structure.html#decimal_literal_characters) _可選_
|
||||
> *十進制數字* → 數值 0 到 9
|
||||
> *十進制數字列表* → [*十進制數字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) [*十進制數字列表*](..\chapter3\02_Lexical_Structure.html#decimal_digits) _可選_
|
||||
> *十進制字符* → [*十進制數字*](..\chapter3\02_Lexical_Structure.html#decimal_digit) | **_**
|
||||
> *十進制字符列表* → [*十進制字符*](..\chapter3\02_Lexical_Structure.html#decimal_literal_character) [*十進制字符列表*](..\chapter3\02_Lexical_Structure.html#decimal_literal_characters) _可選_
|
||||
> *十六進制字面量* → **0x** [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制字面量字符列表*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_characters) _可選_
|
||||
> *十六進制數字* → 數值 0 到 9, a through f, or A through F
|
||||
> *十六進制字符* → [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) | **_**
|
||||
> *十六進制字面量字符列表* → [*十六進制字符*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_character) [*十六進制字面量字符列表*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal_characters) _可選_
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 浮點型字面量語法
|
||||
> *浮點數字面量* → [*十進制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal) [*十進制分數*](..\chapter3\02_Lexical_Structure.html#decimal_fraction) _可選_ [*十進制指數*](..\chapter3\02_Lexical_Structure.html#decimal_exponent) _可選_
|
||||
> *浮點數字面量* → [*十六進制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal) [*十六進制分數*](..\chapter3\02_Lexical_Structure.html#hexadecimal_fraction) _可選_ [*十六進制指數*](..\chapter3\02_Lexical_Structure.html#hexadecimal_exponent)
|
||||
> *十進制分數* → **.** [*十進制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)
|
||||
> *十進制指數* → [*浮點數e*](..\chapter3\02_Lexical_Structure.html#floating_point_e) [*正負號*](..\chapter3\02_Lexical_Structure.html#sign) _可選_ [*十進制字面量*](..\chapter3\02_Lexical_Structure.html#decimal_literal)
|
||||
> *十六進制分數* → **.** [*十六進制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal) _可選_
|
||||
> *十六進制指數* → [*浮點數p*](..\chapter3\02_Lexical_Structure.html#floating_point_p) [*正負號*](..\chapter3\02_Lexical_Structure.html#sign) _可選_ [*十六進制字面量*](..\chapter3\02_Lexical_Structure.html#hexadecimal_literal)
|
||||
> *浮點數e* → **e** | **E**
|
||||
> *浮點數p* → **p** | **P**
|
||||
> *正負號* → **+** | **-**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 字符型字面量語法
|
||||
> *字符串字面量* → **"** [*引用文本*](..\chapter3\02_Lexical_Structure.html#quoted_text) **"**
|
||||
> *引用文本* → [*引用文本條目*](..\chapter3\02_Lexical_Structure.html#quoted_text_item) [*引用文本*](..\chapter3\02_Lexical_Structure.html#quoted_text) _可選_
|
||||
> *引用文本條目* → [*轉義字符*](..\chapter3\02_Lexical_Structure.html#escaped_character)
|
||||
> *引用文本條目* → **\(** [*表達式*](..\chapter3\04_Expressions.html#expression) **)**
|
||||
> *引用文本條目* → 除了"-, \-, U+000A, or U+000D的所有Unicode的字符
|
||||
> *轉義字符* → **\0** | **\\** | **\t** | **\n** | **\r** | **\"** | **\'**
|
||||
> *轉義字符* → **\x** [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit)
|
||||
> *轉義字符* → **\u** [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit)
|
||||
> *轉義字符* → **\U** [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit) [*十六進制數字*](..\chapter3\02_Lexical_Structure.html#hexadecimal_digit)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 運算符語法語法
|
||||
> *運算符* → [*運算符字符*](..\chapter3\02_Lexical_Structure.html#operator_character) [*運算符*](..\chapter3\02_Lexical_Structure.html#operator) _可選_
|
||||
> *運算符字符* → **/** | **=** | **-** | **+** | **!** | ***** | **%** | **<** | **>** | **&** | **|** | **^** | **~** | **.**
|
||||
> *二元運算符* → [*運算符*](..\chapter3\02_Lexical_Structure.html#operator)
|
||||
> *前置運算符* → [*運算符*](..\chapter3\02_Lexical_Structure.html#operator)
|
||||
> *後置運算符* → [*運算符*](..\chapter3\02_Lexical_Structure.html#operator)
|
||||
|
||||
<a name="types"></a>
|
||||
## 類型
|
||||
|
||||
> 類型語法
|
||||
> *類型* → [*數組類型*](..\chapter3\03_Types.html#array_type) | [*函數類型*](..\chapter3\03_Types.html#function_type) | [*類型標識*](..\chapter3\03_Types.html#type_identifier) | [*元組類型*](..\chapter3\03_Types.html#tuple_type) | [*可選類型*](..\chapter3\03_Types.html#optional_type) | [*隱式解析可選類型*](..\chapter3\03_Types.html#implicitly_unwrapped_optional_type) | [*協議合成類型*](..\chapter3\03_Types.html#protocol_composition_type) | [*元型類型*](..\chapter3\03_Types.html#metatype_type)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 類型註解語法
|
||||
> *類型註解* → **:** [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 類型標識語法
|
||||
> *類型標識* → [*類型名稱*](..\chapter3\03_Types.html#type_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_argument_clause) _可選_ | [*類型名稱*](..\chapter3\03_Types.html#type_name) [*泛型參數子句*](GenericParametersAndArguments.html#generic_argument_clause) _可選_ **.** [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
> *類名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 元組類型語法
|
||||
> *元組類型* → **(** [*元組類型主體*](..\chapter3\03_Types.html#tuple_type_body) _可選_ **)**
|
||||
> *元組類型主體* → [*元組類型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list) **...** _可選_
|
||||
> *元組類型的元素列表* → [*元組類型的元素*](..\chapter3\03_Types.html#tuple_type_element) | [*元組類型的元素*](..\chapter3\03_Types.html#tuple_type_element) **,** [*元組類型的元素列表*](..\chapter3\03_Types.html#tuple_type_element_list)
|
||||
> *元組類型的元素* → [*特性(Attributes)列表*](..\chapter3\06_Attributes.html#attributes) _可選_ **inout** _可選_ [*類型*](..\chapter3\03_Types.html#type) | **inout** _可選_ [*元素名*](..\chapter3\03_Types.html#element_name) [*類型註解*](..\chapter3\03_Types.html#type_annotation)
|
||||
> *元素名* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 函數類型語法
|
||||
> *函數類型* → [*類型*](..\chapter3\03_Types.html#type) **->** [*類型*](..\chapter3\03_Types.html#type)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 數組類型語法
|
||||
> *數組類型* → [*類型*](..\chapter3\03_Types.html#type) **[** **]** | [*數組類型*](..\chapter3\03_Types.html#array_type) **[** **]**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 可選類型語法
|
||||
> *可選類型* → [*類型*](..\chapter3\03_Types.html#type) **?**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 隱式解析可選類型(Implicitly Unwrapped Optional Type)語法
|
||||
> *隱式解析可選類型* → [*類型*](..\chapter3\03_Types.html#type) **!**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 協議合成類型語法
|
||||
> *協議合成類型* → **protocol** **<** [*協議標識符列表*](..\chapter3\03_Types.html#protocol_identifier_list) _可選_ **>**
|
||||
> *協議標識符列表* → [*協議標識符*](..\chapter3\03_Types.html#protocol_identifier) | [*協議標識符*](..\chapter3\03_Types.html#protocol_identifier) **,** [*協議標識符列表*](..\chapter3\03_Types.html#protocol_identifier_list)
|
||||
> *協議標識符* → [*類型標識*](..\chapter3\03_Types.html#type_identifier)
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 元(Metatype)類型語法
|
||||
> *元類型* → [*類型*](..\chapter3\03_Types.html#type) **.** **Type** | [*類型*](..\chapter3\03_Types.html#type) **.** **Protocol**
|
||||
|
||||
<!-- -->
|
||||
|
||||
> 類型繼承子句語法
|
||||
> *類型繼承子句* → **:** [*類型繼承列表*](..\chapter3\03_Types.html#type_inheritance_list)
|
||||
> *類型繼承列表* → [*類型標識*](..\chapter3\03_Types.html#type_identifier) | [*類型標識*](..\chapter3\03_Types.html#type_identifier) **,** [*類型繼承列表*](..\chapter3\03_Types.html#type_inheritance_list)
|
||||
322
source-tw/chapter3/10_Statements.md
Normal file
322
source-tw/chapter3/10_Statements.md
Normal file
@ -0,0 +1,322 @@
|
||||
> 翻譯：[coverxit](https://github.com/coverxit)
|
||||
> 校對：[numbbbbb](https://github.com/numbbbbb), [coverxit](https://github.com/coverxit), [stanzhai](https://github.com/stanzhai)
|
||||
|
||||
# 語句
|
||||
-----------------
|
||||
|
||||
本頁包含內容：
|
||||
|
||||
- [循環語句](#loop_statements)
|
||||
- [分支語句](#branch_statements)
|
||||
- [帶標籤的語句](#labeled_statement)
|
||||
- [控制傳遞語句](#control_transfer_statements)
|
||||
|
||||
在 Swift 中，有兩種類型的語句：簡單語句和控制流語句。簡單語句是最常見的，用於構造表達式和聲明。控制流語句則用於控制程序執行的流程，Swift 中有三種類型的控制流語句：循環語句、分支語句和控制傳遞語句。
|
||||
|
||||
循環語句用於重複執行代碼塊；分支語句用於執行滿足特定條件的代碼塊；控制傳遞語句則用於修改代碼的執行順序。在稍後的敘述中，將會詳細地介紹每一種類型的控制流語句。
|
||||
|
||||
是否將分號（`;`）添加到語句的結尾處是可選的。但若要在同一行內寫多條獨立語句，請務必使用分號。
|
||||
|
||||
> 語句語法
|
||||
> *語句* → [*表達式*](..\chapter3\04_Expressions.html#expression) **;** _可選_
|
||||
> *語句* → [*聲明*](..\chapter3\05_Declarations.html#declaration) **;** _可選_
|
||||
> *語句* → [*循環語句*](..\chapter3\10_Statements.html#loop_statement) **;** _可選_
|
||||
> *語句* → [*分支語句*](..\chapter3\10_Statements.html#branch_statement) **;** _可選_
|
||||
> *語句* → [*標記語句(Labeled Statement)*](..\chapter3\10_Statements.html#labeled_statement)
|
||||
> *語句* → [*控制轉移語句*](..\chapter3\10_Statements.html#control_transfer_statement) **;** _可選_
|
||||
> *多條語句(Statements)* → [*語句*](..\chapter3\10_Statements.html#statement) [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) _可選_
|
||||
|
||||
<a name="loop_statements"></a>
|
||||
## 循環語句
|
||||
|
||||
取決於特定的循環條件，循環語句允許重複執行代碼塊。Swift 提供四種類型的循環語句：`for`語句、`for-in`語句、`while`語句和`do-while`語句。
|
||||
|
||||
通過`break`語句和`continue`語句可以改變循環語句的控制流。有關這兩條語句，詳情參見 [Break 語句](#break_statement)和 [Continue 語句](#continue_statement)。
|
||||
|
||||
> 循環語句語法
|
||||
> *循環語句* → [*for語句*](..\chapter3\10_Statements.html#for_statement)
|
||||
> *循環語句* → [*for-in語句*](..\chapter3\10_Statements.html#for_in_statement)
|
||||
> *循環語句* → [*while語句*](..\chapter3\10_Statements.html#wheetatype類型ile_statement)
|
||||
> *循環語句* → [*do-while語句*](..\chapter3\10_Statements.html#do_while_statement)
|
||||
|
||||
### For 語句
|
||||
|
||||
`for`語句允許在重複執行代碼塊的同時，遞增一個計數器。
|
||||
|
||||
`for`語句的形式如下：
|
||||
|
||||
> for `initialzation`; `condition`; `increment` {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
*initialzation*、*condition* 和 *increment* 之間的分號，以及包圍循環體 *statements* 的大括號都是不可省略的。
|
||||
|
||||
`for`語句的執行流程如下：
|
||||
|
||||
1. *initialzation* 只會被執行一次，通常用於聲明和初始化在接下來的循環中需要使用的變量。
|
||||
2. 計算 *condition* 表達式：
|
||||
如果為`true`，*statements* 將會被執行，然後轉到第3步。如果為`false`，*statements* 和 *increment* 都不會被執行，`for`至此執行完畢。
|
||||
3. 計算 *increment* 表達式，然後轉到第2步。
|
||||
|
||||
定義在 *initialzation* 中的變量僅在`for`語句的作用域以內有效。*condition* 表達式的值的類型必須遵循`LogicValue`協議。
|
||||
|
||||
> For 循環語法
|
||||
> *for語句* → **for** [*for初始條件*](..\chapter3\10_Statements.html#for_init) _可選_ **;** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_ **;** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_ [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *for語句* → **for** **(** [*for初始條件*](..\chapter3\10_Statements.html#for_init) _可選_ **;** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_ **;** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_ **)** [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *for初始條件* → [*變量聲明*](..\chapter3\05_Declarations.html#variable_declaration) | [*表達式列表*](..\chapter3\04_Expressions.html#expression_list)
|
||||
|
||||
### For-In 語句
|
||||
|
||||
`for-in`語句允許在重複執行代碼塊的同時，迭代集合（或遵循`Sequence`協議的任意類型）中的每一項。
|
||||
|
||||
`for-in`語句的形式如下：
|
||||
|
||||
> for `item` in `collection` {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
`for-in`語句在循環開始前會調用 *collection* 表達式的`generate`方法來獲取一個生成器類型（這是一個遵循`Generator`協議的類型）的值。接下來循環開始，調用 *collection* 表達式的`next`方法。如果其返回值不是`None`，它將會被賦給 *item*，然後執行 *statements*，執行完畢後回到循環開始處；否則，將不會賦值給 *item* 也不會執行 *statements*，`for-in`至此執行完畢。
|
||||
|
||||
> For-In 循環語法
|
||||
> *for-in語句* → **for** [*模式*](..\chapter3\07_Patterns.html#pattern) **in** [*表達式*](..\chapter3\04_Expressions.html#expression) [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
|
||||
### While 語句
|
||||
|
||||
`while`語句允許重複執行代碼塊。
|
||||
|
||||
`while`語句的形式如下：
|
||||
|
||||
> while `condition` {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
`while`語句的執行流程如下：
|
||||
|
||||
1. 計算 *condition* 表達式：
|
||||
如果為真`true`，轉到第2步。如果為`false`，`while`至此執行完畢。
|
||||
2. 執行 *statements* ，然後轉到第1步。
|
||||
|
||||
由於 *condition* 的值在 *statements* 執行前就已計算出，因此`while`語句中的 *statements* 可能會被執行若干次，也可能不會被執行。
|
||||
|
||||
*condition* 表達式的值的類型必須遵循`LogicValue`協議。同時，*condition* 表達式也可以使用可選綁定，詳情參見[可選綁定](../chapter2/01_The_Basics.html#optional_binding)。
|
||||
|
||||
> While 循環語法
|
||||
> *while語句* → **while** [*while條件*](..\chapter3\10_Statements.html#while_condition) [*代碼塊*](..\chapter3\05_Declarations.html#code_block)
|
||||
> *while條件* → [*表達式*](..\chapter3\04_Expressions.html#expression) | [*聲明*](..\chapter3\05_Declarations.html#declaration)
|
||||
|
||||
### Do-While 語句
|
||||
|
||||
`do-while`語句允許代碼塊被執行一次或多次。
|
||||
|
||||
`do-while`語句的形式如下：
|
||||
|
||||
> do {
|
||||
> `statements`
|
||||
> } while `condition`
|
||||
|
||||
`do-while`語句的執行流程如下：
|
||||
|
||||
1. 執行 *statements*，然後轉到第2步。
|
||||
2. 計算 *condition* 表達式：
|
||||
如果為`true`，轉到第1步。如果為`false`，`do-while`至此執行完畢。
|
||||
|
||||
由於 *condition* 表達式的值是在 *statements* 執行後才計算出，因此`do-while`語句中的 *statements* 至少會被執行一次。
|
||||
|
||||
*condition* 表達式的值的類型必須遵循`LogicValue`協議。同時，*condition* 表達式也可以使用可選綁定，詳情參見[可選綁定](../chapter2/01_The_Basics.html#optional_binding)。
|
||||
|
||||
> Do-While 循環語法
|
||||
> *do-while語句* → **do** [*代碼塊*](..\chapter3\05_Declarations.html#code_block) **while** [*while條件*](..\chapter3\10_Statements.html#while_condition)
|
||||
|
||||
<a name="branch_statements"></a>
|
||||
## 分支語句
|
||||
|
||||
取決於一個或者多個條件的值，分支語句允許程序執行指定部分的代碼。顯然，分支語句中條件的值將會決定如何分支以及執行哪一塊代碼。Swift 提供兩種類型的分支語句：`if`語句和`switch`語句。
|
||||
|
||||
`switch`語句中的控制流可以用`break`語句修改，詳情請見[Break 語句](#break_statement)。
|
||||
|
||||
> 分支語句語法
|
||||
> *分支語句* → [*if語句*](..\chapter3\10_Statements.html#if_statement)
|
||||
> *分支語句* → [*switch語句*](..\chapter3\10_Statements.html#switch_statement)
|
||||
|
||||
### If 語句
|
||||
|
||||
取決於一個或多個條件的值，`if`語句將決定執行哪一塊代碼。
|
||||
|
||||
`if`語句有兩種標準形式，在這兩種形式裡都必須有大括號。
|
||||
|
||||
第一種形式是當且僅當條件為真時執行代碼，像下面這樣：
|
||||
|
||||
> if `condition` {
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
第二種形式是在第一種形式的基礎上添加 *else 語句*，當只有一個 else 語句時，像下面這樣：
|
||||
|
||||
> if `condition` {
|
||||
> `statements to execute if condition is true`
|
||||
> } else {
|
||||
> `statements to execute if condition is false`
|
||||
> }
|
||||
|
||||
同時，else 語句也可包含`if`語句，從而形成一條鏈來測試更多的條件，像下面這樣：
|
||||
|
||||
> if `condition 1` {
|
||||
> `statements to execute if condition 1 is true`
|
||||
> } else if `condition 2` {
|
||||
> `statements to execute if condition 2 is true`
|
||||
> }
|
||||
> else {
|
||||
> `statements to execute if both conditions are false`
|
||||
> }
|
||||
|
||||
`if`語句中條件的值的類型必須遵循`LogicValue`協議。同時，條件也可以使用可選綁定，詳情參見[可選綁定](../chapter2/01_The_Basics.html#optional_binding)。
|
||||
|
||||
> If語句語法
|
||||
> *if語句* → **if** [*if條件*](..\chapter3\10_Statements.html#if_condition) [*代碼塊*](..\chapter3\05_Declarations.html#code_block) [*else子句(Clause)*](..\chapter3\10_Statements.html#else_clause) _可選_
|
||||
> *if條件* → [*表達式*](..\chapter3\04_Expressions.html#expression) | [*聲明*](..\chapter3\05_Declarations.html#declaration)
|
||||
> *else子句(Clause)* → **else** [*代碼塊*](..\chapter3\05_Declarations.html#code_block) | **else** [*if語句*](..\chapter3\10_Statements.html#if_statement)
|
||||
|
||||
### Switch 語句
|
||||
|
||||
取決於`switch`語句的*控制表達式（control expression）*，`switch`語句將決定執行哪一塊代碼。
|
||||
|
||||
`switch`語句的形式如下：
|
||||
|
||||
> switch `control expression` {
|
||||
> case `pattern 1`:
|
||||
> `statements`
|
||||
> case `pattern 2` where `condition`:
|
||||
> `statements`
|
||||
> case `pattern 3` where `condition`,
|
||||
> `pattern 4` where `condition`:
|
||||
> `statements`
|
||||
> default:
|
||||
> `statements`
|
||||
> }
|
||||
|
||||
`switch`語句的*控制表達式（control expression）*會首先被計算，然後與每一個 case 的模式（pattern）進行匹配。如果匹配成功，程序將會執行對應的 case 分支裡的 *statements*。另外，每一個 case 分支都不能為空，也就是說在每一個 case 分支中至少有一條語句。如果你不想在匹配到的 case 分支中執行代碼，只需在該分支裡寫一條`break`語句即可。
|
||||
|
||||
可以用作控制表達式的值是十分靈活的，除了標量類型(scalar types，如`Int`、`Character`)外，你可以使用任何類型的值，包括浮點數、字符串、元組、自定義類的實例和可選（optional）類型，甚至是枚舉類型中的成員值和指定的範圍(range)等。關於在`switch`語句中使用這些類型，詳情參見[控制流](../chapter2/05_Control_Flow.html)一章的 [Switch](../chapter2/05_Control_Flow.html#switch)。
|
||||
|
||||
你可以在模式後面添加一個起保護作用的表達式(guard expression)。*起保護作用的表達式*是這樣構成的：關鍵字`where`後面跟著一個作為額外測試條件的表達式。因此，當且僅當*控制表達式*匹配一個*case*的某個模式且起保護作用的表達式為真時，對應 case 分支中的 *statements* 才會被執行。在下面的例子中，*控制表達式*只會匹配含兩個相等元素的元組，如`(1, 1)`：
|
||||
|
||||
```swift
|
||||
case let (x, y) where x == y:
|
||||
```
|
||||
|
||||
正如上面這個例子，也可以在模式中使用`let`（或`var`）語句來綁定常量（或變量）。這些常量（或變量）可以在其對應的起保護作用的表達式和其對應的*case*塊裡的代碼中引用。但是，如果 case 中有多個模式匹配控制表達式，那麼這些模式都不能綁定常量（或變量）。
|
||||
|
||||
`switch`語句也可以包含默認（`default`）分支，只有其它 case 分支都無法匹配控制表達式時，默認分支中的代碼才會被執行。一個`switch`語句只能有一個默認分支，而且必須在`switch`語句的最後面。
|
||||
|
||||
儘管模式匹配操作實際的執行順序，特別是模式的計算順序是不可知的，但是 Swift 規定`switch`語句中的模式匹配的順序和書寫源代碼的順序保持一致。因此，當多個模式含有相同的值且能夠匹配控制表達式時，程序只會執行源代碼中第一個匹配的 case 分支中的代碼。
|
||||
|
||||
#### Switch 語句必須是完備的
|
||||
|
||||
在 Swift 中，`switch`語句中控制表達式的每一個可能的值都必須至少有一個 case 分支與之對應。在某些情況下（例如，表達式的類型是`Int`），你可以使用默認塊滿足該要求。
|
||||
|
||||
#### 不存在隱式的貫穿(fall through)
|
||||
|
||||
當匹配的 case 分支中的代碼執行完畢後，程序會終止`switch`語句，而不會繼續執行下一個 case 分支。這就意味著，如果你想執行下一個 case 分支，需要顯式地在你需要的 case 分支裡使用`fallthrough`語句。關於`fallthrough`語句的更多信息，詳情參見 [Fallthrough 語句](#fallthrough_statement)。
|
||||
|
||||
> Switch語句語法
|
||||
> *switch語句* → **switch** [*表達式*](..\chapter3\04_Expressions.html#expression) **{** [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可選_ **}**
|
||||
> *SwitchCase列表* → [*SwitchCase*](..\chapter3\10_Statements.html#switch_case) [*SwitchCase列表*](..\chapter3\10_Statements.html#switch_cases) _可選_
|
||||
> *SwitchCase* → [*case標籤*](..\chapter3\10_Statements.html#case_label) [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements) | [*default標籤*](..\chapter3\10_Statements.html#default_label) [*多條語句(Statements)*](..\chapter3\10_Statements.html#statements)
|
||||
> *SwitchCase* → [*case標籤*](..\chapter3\10_Statements.html#case_label) **;** | [*default標籤*](..\chapter3\10_Statements.html#default_label) **;**
|
||||
> *case標籤* → **case** [*case項列表*](..\chapter3\10_Statements.html#case_item_list) **:**
|
||||
> *case項列表* → [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可選_ | [*模式*](..\chapter3\07_Patterns.html#pattern) [*guard-clause*](..\chapter3\10_Statements.html#guard_clause) _可選_ **,** [*case項列表*](..\chapter3\10_Statements.html#case_item_list)
|
||||
> *default標籤* → **default** **:**
|
||||
> *guard-clause* → **where** [*guard-expression*](..\chapter3\10_Statements.html#guard_expression)
|
||||
> *guard-expression* → [*表達式*](..\chapter3\04_Expressions.html#expression)
|
||||
|
||||
<a name="labeled_statement"></a>
|
||||
<a name="control_transfer_statements"></a> 帶標籤的語句
|
||||
|
||||
你可以在循環語句或`switch`語句前面加上*標籤*，它由標籤名和緊隨其後的冒號(:)組成。在`break`和`continue`後面跟上標籤名可以顯式地在循環語句或`switch`語句中更改控制流，把控制權傳遞給指定標籤標記的語句。關於這兩條語句用法，詳情參見 [Break 語句](#break_statement)和 [Continue 語句](#continue_statement)。
|
||||
|
||||
標籤的作用域是該標籤所標記的語句之後的所有語句。你可以不使用帶標籤的語句，但只要使用它，標籤名就必唯一。
|
||||
|
||||
關於使用帶標籤的語句的例子，詳情參見[控制流](../chapter2/05_Control_Flow.html)一章的[帶標籤的語句](../chapter2/05_Control_Flow.html#labeled_statements)。
|
||||
|
||||
> 標記語句語法
|
||||
> *標記語句(Labeled Statement)* → [*語句標籤*](..\chapter3\10_Statements.html#statement_label) [*循環語句*](..\chapter3\10_Statements.html#loop_statement) | [*語句標籤*](..\chapter3\10_Statements.html#statement_label) [*switch語句*](..\chapter3\10_Statements.html#switch_statement)
|
||||
> *語句標籤* → [*標籤名稱*](..\chapter3\10_Statements.html#label_name) **:**
|
||||
> *標籤名稱* → [*標識符*](..\chapter3\02_Lexical_Structure.html#identifier)
|
||||
|
||||
## 控制傳遞語句
|
||||
|
||||
通過無條件地把控制權從一片代碼傳遞到另一片代碼，控制傳遞語句能夠改變代碼執行的順序。Swift 提供四種類型的控制傳遞語句：`break`語句、`continue`語句、`fallthrough`語句和`return`語句。
|
||||
|
||||
> 控制傳遞語句(Control Transfer Statement) 語法
|
||||
> *控制傳遞語句* → [*break語句*](..\chapter3\10_Statements.html#break_statement)
|
||||
> *控制傳遞語句* → [*continue語句*](..\chapter3\10_Statements.html#continue_statement)
|
||||
> *控制傳遞語句* → [*fallthrough語句*](..\chapter3\10_Statements.html#fallthrough_statement)
|
||||
> *控制傳遞語句* → [*return語句*](..\chapter3\10_Statements.html#return_statement)
|
||||
|
||||
<a name="break_statement"></a>
|
||||
### Break 語句
|
||||
|
||||
`break`語句用於終止循環或`switch`語句的執行。使用`break`語句時，可以只寫`break`這個關鍵詞，也可以在`break`後面跟上標籤名（label name），像下面這樣：
|
||||
|
||||
> break
|
||||
> break `label name`
|
||||
|
||||
當`break`語句後面帶標籤名時，可用於終止由這個標籤標記的循環或`switch`語句的執行。
|
||||
|
||||
而當只寫`break`時，則會終止`switch`語句或上下文中包含`break`語句的最內層循環的執行。
|
||||
|
||||
在這兩種情況下，控制權都會被傳遞給循環或`switch`語句外面的第一行語句。
|
||||
|
||||
關於使用`break`語句的例子，詳情參見[控制流](../chapter2/05_Control_Flow.html)一章的 [Break](../chapter2/05_Control_Flow.html#break) 和[帶標籤的語句](../chapter2/05_Control_Flow.html#labeled_statements)。
|
||||
|
||||
> Break 語句語法
|
||||
> *break語句* → **break** [*標籤名稱*](..\chapter3\10_Statements.html#label_name) _可選_
|
||||
|
||||
<a name="continue_statement"></a>
|
||||
### Continue 語句
|
||||
|
||||
`continue`語句用於終止循環中當前迭代的執行，但不會終止該循環的執行。使用`continue`語句時，可以只寫`continue`這個關鍵詞，也可以在`continue`後面跟上標籤名（label name），像下面這樣：
|
||||
|
||||
> continue
|
||||
> continue `label name`
|
||||
|
||||
當`continue`語句後面帶標籤名時，可用於終止由這個標籤標記的循環中當前迭代的執行。
|
||||
|
||||
而當只寫`break`時，可用於終止上下文中包含`continue`語句的最內層循環中當前迭代的執行。
|
||||
|
||||
在這兩種情況下，控制權都會被傳遞給循環外面的第一行語句。
|
||||
|
||||
在`for`語句中，`continue`語句執行後，*increment* 表達式還是會被計算，這是因為每次循環體執行完畢後 *increment* 表達式都會被計算。
|
||||
|
||||
關於使用`continue`語句的例子，詳情參見[控制流](../chapter2/05_Control_Flow.html)一章的 [Continue](../chapter2/05_Control_Flow.html#continue) 和[帶標籤的語句](../chapter2/05_Control_Flow.html#labeled_statements)。
|
||||
|
||||
> Continue 語句語法
|
||||
> *continue語句* → **continue** [*標籤名稱*](..\chapter3\10_Statements.html#label_name) _可選_
|
||||
|
||||
<a name="fallthrough_statement"></a>
|
||||
### Fallthrough 語句
|
||||
|
||||
`fallthrough`語句用於在`switch`語句中傳遞控制權。`fallthrough`語句會把控制權從`switch`語句中的一個 case 傳遞給下一個 case 。這種傳遞是無條件的，即使下一個 case 的模式與`switch`語句的控制表達式的值不匹配。
|
||||
|
||||
`fallthrough`語句可出現在`switch`語句中的任意 case 裡，但不能出現在最後一個 case 分支中。同時，`fallthrough`語句也不能把控制權傳遞給使用了可選綁定的 case 分支。
|
||||
|
||||
關於在`switch`語句中使用`fallthrough`語句的例子，詳情參見[控制流](../chapter2/05_Control_Flow.html)一章的[控制傳遞語句](../chapter2/05_Control_Flow.html#control_transfer_statements)。
|
||||
|
||||
> Fallthrough 語句語法
|
||||
> *fallthrough語句* → **fallthrough**
|
||||
|
||||
### Return 語句
|
||||
|
||||
`return`語句用於在函數或方法的實現中將控制權傳遞給調用者，接著程序將會從調用者的位置繼續向下執行。
|
||||
|
||||
使用`return`語句時，可以只寫`return`這個關鍵詞，也可以在`return`後面跟上表達式，像下面這樣：
|
||||
|
||||
> return
|
||||
> return `expression`
|
||||
|
||||
當`return`語句後面帶表達式時，表達式的值將會返回給調用者。如果表達式值的類型與調用者期望的類型不匹配，Swift 則會在返回表達式的值之前將表達式值的類型轉換為調用者期望的類型。
|
||||
|
||||
而當只寫`return`時，僅僅是將控制權從該函數或方法傳遞給調用者，而不返回一個值。（這就是說，該函數或方法的返回類型為`Void`或`()`）
|
||||
|
||||
> Return 語句語法
|
||||
> *return語句* → **return** [*表達式*](..\chapter3\04_Expressions.html#expression) _可選_
|
||||
0
source-tw/chapter3/chapter3.md
Normal file
0
source-tw/chapter3/chapter3.md
Normal file
Reference in New Issue
Block a user