> 1.0 翻譯：[marsprince](https://github.com/marsprince)?[Lenhoon](https://github.com/marsprince)[(微博)](http://www.weibo.com/lenhoon)?校對：[numbbbbb](https://github.com/numbbbbb),?[stanzhai](https://github.com/stanzhai)
>
> 2.0 翻譯+校對：[Lenhoon](https://github.com/Lenhoon)
本頁包含內容：
[TOC=2]
一條_聲明(declaration)_可以在程序里引入新的名字或者構造。舉例來說，可以使用聲明來引入函數和方法，變量和常量，或者來定義新的命名好的枚舉，結構，類和協議類型。可以使用一條聲明來延長一個已經存在的命名好的類型的行為。或者在程序里引入在其它地方聲明的符號。
在Swift中，大多數聲明在某種意義上講也是執行或同時聲明它們的初始化定義。這意味著，因為協議和它們的成員不匹配，大多數協議成員需要單獨的聲明。為了方便起見，也因為這些區別在Swift里不是很重要，_聲明語句(declaration)_同時包含了聲明和定義。
> 聲明語法
> 聲明 → _導入聲明_
> 聲明 → _常量聲明_
> 聲明 → _變量聲明_
> 聲明 → _類型別名聲明_
> 聲明 → _函數聲明_
> 聲明 → _枚舉聲明_
> 聲明 → _結構體聲明_
> 聲明 → _類聲明_
> 聲明 → _協議聲明_
> 聲明 → _構造器聲明_
> 聲明 → _析構器聲明_
> 聲明 → _擴展聲明_
> 聲明 → _附屬腳本聲明_
> 聲明 → _運算符聲明_
> 聲明(Declarations)列表 → _聲明_ _聲明(Declarations)列表_ _可選_
## 頂級代碼
Swift的源文件中的頂級代碼由零個或多個語句，聲明和表達式組成。默認情況下，在一個源文件的頂層聲明的變量，常量和其他命名的聲明語句可以被同一模塊部分里的每一個源文件中的代碼訪問。可以通過使用一個訪問級別修飾符來標記這個聲明，從而重寫這個默認行為，[訪問控制級別(Access Control Levels)](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#access_control_levels)中有所介紹。
> 頂級(Top Level) 聲明語法
> _頂級聲明_?→?[_多條語句(Statements)_](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)?_可選_
## 代碼塊
_代碼塊_用來將一些聲明和控制結構的語句組織在一起。它有如下的形式：
> {
> `statements`
> }
代碼塊中的_語句(statements)_包括聲明，表達式和各種其他類型的語句，它們按照在源碼中的出現順序被依次執行。
> 代碼塊語法
> _代碼塊_?→?{? _多條語句(Statements)_?_可選_?}
## 引入聲明
可以使用在其他文件中聲明的內容_引入聲明(import declaration)_。引入語句的基本形式是引入整個代碼模塊；它由`import`關鍵字開始，后面 緊跟一個模塊名：
> import?`module`
可以提供更多的細節來限制引入的符號，如聲明一個特殊的子模塊或者在一個模塊或子模塊中做特殊的聲明。（待改進） 當使用了這些細節后，在當前的程序匯總只有引入的符號是可用的（并不是聲明的整個模塊）。
> import?`import kind`?`module`.`symbol name`
> import?`module`.`submodule`
> 導入(Import)聲明語法
> 導入聲明 → _特性(attributes)列表_ 可選 import _導入類型_ 可選 _導入路徑_
> 導入類型 → typealias | struct | class | enum | protocol | var | func
> 導入路徑 → _導入路徑標識符_ | _導入路徑標識符_ . _導入路徑_
> 導入路徑標識符 → _標識符_ | _運算符_
## 常量聲明
_常量聲明(constant declaration)_可以在程序里命名一個常量。常量以關鍵詞`let`來聲明，遵循如下的格式:
> let?`constant name`:?`type`?=?`expression`
當常量的值被給定后，常量就將_常量名稱(constant name)_和_表達式(expression)_初始值不變的結合在了一起，而且不能更改。
這意味著如果常量以類的形式被初始化，類本身的內容是可以改變的，但是常量和類之間的結合關系是不能改變的。
當一個常量被聲明為全局變量，它必須被給定一個初始值。當一個常量在類或者結構體中被聲明時，它被認為是一個_常量屬性(constant property)_。常量并不是可計算的屬性，因此不包含getters和setters。
如果_常量名(constant name)_是一個元組形式，元組中的每一項初始化_表達式(expression)_中都要有對應的值。
~~~
let (firstNumber, secondNumber) = (10, 42)
~~~
在上例中，`firstNumber`是一個值為`10`的常量，`secnodeName`是一個值為`42`的常量。所有常量都可以獨立的使用：
~~~
println("The first number is /(firstNumber).")
// prints "The first number is 10."
println("The second number is /(secondNumber).")
// prints "The second number is 42."
~~~
當_常量名稱(constant name)_的類型可以被推斷出時，類型標注_（:type）_在常量聲明中是一個可選項，它可以用來描述在類型推斷(Type Inference)中找到的類型。
聲明一個常量類型屬性要使用關鍵字`static`聲明修飾符。類型屬性在類型屬性(Type Properties)中有介紹。
如果還想獲得更多關于常量的信息或者想在使用中獲得幫助，請查看常量和變量(Constants and Variables)和存儲屬性(Stored Properties)等節。
> 常數聲明語法
> 常量聲明 → _特性(Attributes)列表_ 可選 _聲明修飾符(Specifiers)列表_ 可選 let _模式構造器列表_
> 模式構造器列表 → _模式構造器_ | _模式構造器_ , _模式構造器列表_
> 模式構造器 → _模式_ _構造器_ 可選
> 構造器 → = _表達式_
## 變量聲明
_變量聲明(variable declaration)_可以在程序里聲明一個變量，它以關鍵字`var`來聲明。
變量聲明有幾種不同的形式聲明不同種類的命名值和計算型值，如存儲和計算變量和屬性，存儲變量和屬性監視，和靜態變量屬性。所使用的聲明形式取決于變量所聲明的范圍和打算聲明的變量類型。
> 注意：
> 也可以在協議聲明的上下文聲明屬性，詳情參見協議屬性聲明(Protocal Property Declaration)。
可以重載一個子類中的屬性，通過使用'override'聲明修飾符來標記子類的屬性聲明，重寫(Overriding)中有所介紹。
### 存儲型變量和存儲型屬性
下面的形式聲明了一個存儲型變量或存儲型變量屬性
> var?`variable name`:?`type`?=?`expression`
可以在全局，函數內，或者在類和結構體的聲明(context)中使用這種形式來聲明一個變量。當變量以這種形式 在全局或者一個函數內被聲明時，它代表一個 _存儲型變量(stored variable)_ 。當它在類或者結構體中被聲明時，它代表一個 _存儲型變量屬性(stored variable property)_ 。
初始化的 _表達式（expression）_ 不可以在協議的聲明中出現，在其他情況下，初始化 _表達式(expression)_ 是可選的（optional），如果沒有初始化 _表達式(expression)_ ，那么變量定義時必須顯示包括類型標注 （ _:type_ )
對于常量的定義，如果 _變量名字（variable name）_ 是一個元組（tuple），元組中每一項的名稱都要和初始化 _表達式(expression)_ 中的相應值一致。
正如名字一樣，存儲型變量的值或存儲型變量屬性存儲在內存中。
### 計算型變量和計算型屬性
如下形式聲明一個一個存儲型變量或存儲型屬性：
> var?`variable name`:?`type`?{
> get {
> `statements`
> }
> set(`setter name`) {
> `statements`
> }
> }
可以在全局，函數體內或者類，結構體，枚舉，擴展聲明的上下文中使用這種形式的聲明。當變量以這種形式在全局或者一個函數內被聲明時，它代表一個_計算型變量(computed variable)_。當它在類，結構體，枚舉，擴展聲明的上下文中中被聲明時，它代表一個 _計算型變量(computed variable)_ 。
getter用來讀取變量值，setter用來寫入變量值。setter子句是可選擇的，只有getter是必需的，可以將這些語句 都省略，只是簡單的直接返回請求值，正如在只讀計算屬性(Read-Only Computed Properties)中描述的那樣。但是如果提供了一個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`
> }
> }
可以在全局，函數體內或者類，結構體，枚舉，擴展聲明的上下文中使用這種形式的聲明。當變量以這種形式在全局或者一個函數內被聲明時，監視器代表一個_存儲型變量監視器(stored variable observers)_；當它在類，結構體，枚舉，擴展聲明的上下文中被聲明時，監視器代表_屬性監視器(property observers)_。
可以為適合的監視器添加任何存儲型屬性。也可以通過重寫子類屬性的方式為適合的監視器添加任何繼承的屬性 (無論是存儲型還是計算型的)，參見重寫屬性監視器(Overriding Property Observers)。
初始化_表達式(expression)_在一個類中或者結構體的聲明中是可選的，但是在其他地方是必需的。當類型可以從初始化_表達式(expression)_中推斷而來，那么這個_類型(type)_標注是可選的。
當變量或屬性的值被改變時，`willset`和`didset`監視器提供了一個監視方法（適當的回應）。 監視器不會在變量或屬性第一次初始化時運行，它們只有在值被外部初始化語句改變時才會被運行。
`willset`監視器只有在變量或屬性值被改變之前運行。新的值作為一個常量經過過`willset`監視器，因此不可以在`willset`語句中改變它。`didset`監視器在變量或屬性值被改變后立即運行。和`willset`監視器相反，為了以防止仍然需要獲得舊的數據，舊變量值或者屬性會經過`didset`監視器。這意味著，如果在變量或屬性自身的`didiset`監視器語句中設置了一個值，設置的新值會取代剛剛在`willset`監視器中經過的那個值。
在`willset`和`didset`語句中，_setter名(setter name)_和圓括號的語句是可選的。如果寫了一個setter名，它就會作為`willset`和`didset`的參數被使用。如果不寫setter名，?`willset`監視器初始名為`newvalue`，`didset`監視器初始名為`oldvalue`。
當提供一個`willset`語句時，`didset`語句是可選的。同樣的，在提供了一個`didset`語句時，`willset`語句是可選的。
獲得更多信息，查看如何使用屬性監視器的例子，請查看屬性監視器(Property Observers)一節。 聲明修飾符
### 類型變量屬性
聲明一個類型變量屬性，要用`static`聲明修飾符標記該聲明。類可能需要`class`聲明修飾符去標記類的類型計算型屬性從而允許子類可以重寫超類的實現。類型屬性在類型屬性(Type Properties)章節討論。
> > 注意
> >
> > 在一個類聲明中，關鍵字`static`與用聲明修飾符`class`和`final`去標記一個聲明的效果相同
> 變量聲明語法
> 變量聲明 → _變量聲明頭(Head)_ _模式構造器列表_
> 變量聲明 → _變量聲明頭(Head)_ _變量名_ _類型標注_ _代碼塊_
> 變量聲明 → _變量聲明頭(Head)_ _變量名_ _類型標注_ _getter-setter塊_
> 變量聲明 → _變量聲明頭(Head)_ _變量名_ _類型標注_ _getter-setter關鍵字(Keyword)塊_
> 變量聲明 → _變量聲明頭(Head)_ _變量名_ _構造器_ _willSet-didSet代碼塊_
> 變量聲明 → _變量聲明頭(Head)_ _變量名_ _類型標注_ _構造器_ 可選 _willSet-didSet代碼塊_
> 變量聲明頭(Head) → _特性(Attributes)列表_ 可選 _聲明修飾符(Specifiers)列表_ 可選 var
> 變量名稱 → _標識符_
> getter-setter塊 → { _getter子句_ _setter子句_ 可選 }
> getter-setter塊 → { _setter子句_ _getter子句_ }
> getter子句 → _特性(Attributes)列表_ 可選 get _代碼塊_
> setter子句 → _特性(Attributes)列表_ 可選 set _setter名稱_ 可選 _代碼塊_
> setter名稱 → ( _標識符_ )
> getter-setter關鍵字(Keyword)塊 → { _getter關鍵字(Keyword)子句_ _setter關鍵字(Keyword)子句_ 可選 }
> getter-setter關鍵字(Keyword)塊 → { _setter關鍵字(Keyword)子句_ _getter關鍵字(Keyword)子句_ }
> getter關鍵字(Keyword)子句 → _特性(Attributes)列表_ 可選 get
> setter關鍵字(Keyword)子句 → _特性(Attributes)列表_ 可選 set
> willSet-didSet代碼塊 → { _willSet子句_ _didSet子句_ 可選 }
> willSet-didSet代碼塊 → { _didSet子句_ _willSet子句_ }
> willSet子句 → _特性(Attributes)列表_ 可選 willSet _setter名稱_ 可選 _代碼塊_
> didSet子句 → _特性(Attributes)列表_ 可選 didSet _setter名稱_ 可選 _代碼塊_
## 類型的別名聲明
_類型別名聲明(type alias declaration)_可以在程序里為一個已存在的類型聲明一個別名。類型的別名聲明語句使用關鍵字`typealias`聲明，遵循如下的形式：
> `typealias name`?=?`existing type`
當聲明一個類型的別名后，可以在程序的任何地方使用別_名(name)_來代替_已存在的類型(existing type)_。已存在的類型可以是已經被命名的類型或者是混合類型。類型的別名不產生新的類型，它只是簡單的和已存在的類型做名稱替換。
查看更多[協議關聯類型聲明(Protocol Associated Type Declaration)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO).
> 類型別名聲明語法
> 類型別名聲明 → _類型別名頭(Head)_ _類型別名賦值_
> 類型別名頭(Head) → _屬性列表_ 可選 _訪問級別修飾符_
> 類型別名名稱 → _標識符_
> 類型別名賦值 → = _類型_
## 函數聲明
使用_函數聲明(function declaration)_在程序里引入新的函數或者方法。一個函數被聲明在類的上下文，結構體，枚舉，或者協議中，從而作為_方法(method)_被引用。 函數聲明使用關鍵字`func`，遵循如下的形式：
> func?`function name`(`parameters`) ->?`return type`?{
> `statements`
> }
如果函數返回`Void`類型，返回類型可以被忽略，如下所示：
> func?`function name`(`parameters`) {
> `statements`
> }
每個參數的類型都要標明，它們不能被推斷出來。雖然函數的參數默認是常量，也可以使用參數名前使用`let`來強調這一行為。在這些參數前面添加`var`使它們成為變量，作用域內任何對變量的改變只在函數體內有效，或者用`inout`使的這些改變可以在調用域內生效。更多關于in-out參數的討論，參見In-Out參數(In-Out Parameters)
函數可以使用元組類型作為返回值來返回多個變量。
函數定義可以出現在另一個函數聲明內。這種函數被稱作nested函數。更多關于_嵌套函數(Nested Functions)_的討論，參見嵌套函數(Nested Functions)。
### 參數名
函數的參數是一個以逗號分隔的列表 。函數調用是的變量順序必須和函數聲明時的參數順序一致。 最簡單的參數列表有著如下的形式：
> `parameter name`:?`parameter type`
一個參數有一個內部名稱，這個內部名稱可以在函數體內被使用。同樣也可以作為外部名稱，當調用方法時這個外部名稱被作為實參的標簽來使用。默認情況下，第一個參數的外部名稱省略不寫，第二個和其之后的參數使用它們的內部名稱作為它們的外部名稱。
~~~
func f(x: Int, y: Int) -> Int{ return x + y}
f(1, y: 2) // y是有標記的，x沒有
~~~
可以按如下的一種形式，重寫參數名被使用的默認過程：
> `external parameter name`?`local parameter name`:?`parameter type`
> _?`local parameter name`:?`parameter type`
在內部參數名前的名稱賦予這個參數一個外部名稱，這個名稱可以和內部參數的名稱不同。外部參數名在函數被調用時必須被使用。對應的參數在方法或函數被調用時必須有外部名 。
內部參數名前的強調字符下劃線(_)使參數在函數被調用時沒有名稱。在函數或方法調用時，與其對應的語句必須沒有名字。
~~~
func f(x x: Int, withY y: Int, _z: Int) -> Int{
return x + y + z }
f(x: 1, withY: 2, 3) // x和y是有標記的，z沒有
~~~
### 特殊類型的參數
參數可以被忽略，參數的值的數量可變，并且還可以提供默認值，使用形式如下：
> _ :?`parameter type`.
> `parameter name`:?`parameter type`...
> `parameter name`:?`parameter type`?=?`default argument value`
以下劃線(_)命名的參數是明確忽略的，在函數體內不能被訪問。
一個以基礎類型名的參數，如果緊跟著三個點(`...`)，被理解為是可變參數。一個函數至多可以擁有一個可變參數，且必須是最后一個參數。可變參數被作為該基本類型名的數組來看待。舉例來講，可變參數`Int...`被看做是`[Int]`。查看可變參數的使用例子，詳見可變參數(Variadic Parameters)一節。
在參數的類型后面有一個以等號(`=`)連接的表達式，這樣的參數被看做有著給定表達式的初始值。當函數被調用時，給定的表達式被求值。如果參數在函數調用時被省略了，就會使用初始值。
~~~
func f(x: Int = 42) -> Int { return x}
f() // 有效的，使用默認值
f(7) // 有效的，提供了值，沒有提供值的名稱
f(x: 7) //無效的，值和值的名稱都提供了
~~~
### 特殊方法
枚舉或結構體的方法來修改`self`屬性，必須以`mutating`聲明修飾符標記。
子類方法重寫超類中的方法必須以`override`聲明修飾符標記。重寫一個方法不使用`override`修飾符，或者使用了`override`修飾符卻并沒有重寫超類方法都會產生一個編譯時錯誤。
枚舉或者結構體中的類型方法而不是實例方法，要以`static`聲明修飾符標記，而對于類中的類型方法，要使用`class`聲明修飾符標記。
### 柯里化函數(Curried Functions)
可以重寫一個帶有多個參數的函數使它等同于一個只有一個參數并且返回一個函數的函數，這個返回函數攜帶下一個參數并且返回另外一個函數，一直持續到再沒有剩余的參數，此時要返回的函數返回原來的多參函數要返回的原始值。這個重寫的函數被稱為_柯里化函數(curried function)_。例如，可以為`addTwoInts(a:b:)`重寫一個等價的`addTwoIntsCurried(a:)(b:)`的函數。
~~~
func addTwoInts(a: Int, b: Int) -> Int {
return a + b
}
func addTwoIntsCurried(a: Int) -> (Int -> Int) {
func addTheOtherInt(b: Int) -> Int {
return a + b
}
return addTheOtherInt
}
~~~
這個`addTwoInts(a:b:)`函數帶有兩個整型值并且返回他們的和。`addTwoIntsCurried(a:)(b:)`函數帶有一個整型值，并且返回另外一個帶有第二個整型值的函數并使其和第一個整型值相加（這個內嵌的函數從包含它的函數中捕獲第一個整型參數的值）。
在Swift中，可以通過以下語法非常簡明的寫一個柯里化函數：
> func?`function name`(`parameter`)(`parameter`) ->?`return type`?{
> `statements`
> }
舉例來說，下面的兩個聲明是等價的:
~~~
func addTwoIntsCurried(a a: Int)(b: Int) -> Int {
return a + b
}
func addTwoIntsCurried(a a: Int) -> (Int -> Int)
{
func addTheOtherInt(b: Int) -> Int {
return a + b
}
return addTheOtherInt
}
~~~
為了像使用非柯里化函數一樣的方式使用`addTwoIntsCurried(a:)(b:)`函數，必須用第一個整型參數調用`addTwoIntsCurried(a:)(b:)`,緊接著用第二個整型參數調用其返回的函數：
~~~
addTwoInts(a: 4, b: 5)
//返回值為9
addTwoIntsCurried(a: 4)(b: 5)
//返回值為9
~~~
雖然在每次調用一個非柯里化函數時必須提供所有的參數，可以使用函數的柯里化形式把參數分配在多次函數調用中，稱之為“_偏函數應用(partial function application)_”，例如可以為`addTwoIntsCurried(a:)(b:)`函數使用參數`1`然后把返回的結果賦值給常量`plusOne`：
~~~
let plusOne = addTwoIntsCurried(a: 1)
// plusOne 是類型為 Int -> Int的函數
~~~
因為`plusOne`是函數`addTwoIntsCurried(a:)(b:)`綁定參數為`1`時結果，所以可以調用`plusOne`并且傳入一個整型使其和`1`相加。
~~~
plusOne(10)
// 返回值為11
~~~
### 拋出異常函數和拋出異常方法(Throwing Functions and Methods)
可以拋出一個錯誤的函數或方法必需使用`throws`關鍵字標記。這些函數和方法被稱為_拋出異常函數(throwing functions)_和_拋出異常方法(throwing methods)_。它們有著下面的形式:
> func?`function name`(`parameters`) throws ->?`return type`?{?`statements`?}
調用一個拋出異常函數或拋出異常方法必需用一個`try`或者`try!`表達式來封裝（也就是說，在一個范圍內使用一個`try`或者`try!`運算符）。
`throws`關鍵字是函數的類型的一部分，不拋出異常的函數是拋出異常函數的一個子類型。所以，可以在使用拋出異常函數的地方使用不拋出異常函數。對于柯里化函數，`throws`關鍵字僅運用于最內層的函數。
不能重寫一個僅基于是否能拋出錯誤的函數。也就是說，可以重載一個基于函數_參數(parameter)_能否拋出一個錯誤的函數。
一個拋出異常的方法不能重寫一個不能拋出異常的方法，而且一個異常拋出方法不能滿足一個協議對于不拋出異常方法的需求。也就是說，一個不拋出異常的方法可以重寫一個拋出異常的方法，而且一個不拋出異常的方法可以滿足一個協議對于拋出異常的需求。
### 重拋出異常函數和重拋出異常方法(Rethrowing Functions and Methods)
一個函數或方法可以使用`rethrows`關鍵字來聲明，從而表明僅當這個函數或方法的一個函數參數拋出錯誤時這個函數或方法才拋出錯誤。這些函數和方法被稱為_重拋出異常函數(rethrowing functions)_和_重拋出異常方法(rethrowing methods)_。重拋出異常函數或方法必需有至少一個拋出異常函數參數。
~~~
func functionWithCallback(callback: () throws -> Int) rethrows {
try callback()
}
~~~
一個拋出異常函數方法不能重寫一個重拋出異常函數方法，一個拋出異常方法不能滿足一個協議對于重拋出異常方法的需求。也就是說，一個重拋出異常方法可以重寫一個拋出異常方法，而且一個重拋出異常方法可以滿足一個協議對于拋出異常方法的需求。
> 函數聲明語法
> 函數聲明 → _函數頭_ _函數名_ _泛型參數子句_ 可選 _函數簽名(Signature)_ _函數體_
> 函數頭 → _特性(Attributes)列表_ 可選 _聲明修飾符(Specifiers)列表_ 可選 func
> 函數名 → _標識符_ | _運算符_
> 函數簽名(signature) → _parameter-clauses_ throws _函數結果_ 可選
> 函數簽名(signature) → _parameter-clauses_ rethrows _函數結果_ 可選
> 函數結果 → -> _特性(Attributes)列表_ 可選 _類型_
> 函數體 → _代碼塊_
> parameter-clauses → _參數子句_ _parameter-clauses_ 可選
> 參數子句 → ( ) | ( _參數列表_ ... 可選 )
> 參數列表 → _參數_ | _參數_ , _參數列表_
> 參數 → inout 可選 let 可選 _外部參數名__可選_ _內部參數名_ _類型標注_ _默認參數子句_ 可選
> 參數 → inout 可選 var _外部參數名_ _內部參數名_ _類型標注_ _默認參數子句_ 可選
> 參數 → _特性(Attributes)列表_ 可選 _類型_
> 參數名 → _標識符_ | _
> 內部參數名 → _標識符_ | _
> 默認參數子句 → = _表達式_
## 枚舉聲明
在程序里使用_枚舉聲明(enumeration)_來引入一個枚舉類型。
枚舉聲明有兩種基本的形式，使用關鍵字`enum`來聲明。枚舉聲明體使用從零開始的變量——叫做_枚舉事件(enumeration cases)_，和任意數量的聲明，包括計算型屬性，實例方法，類型方法，構造器，類型別名，甚至其他枚舉，結構體，和類。枚舉聲明不能包含析構器或者協議聲明。
枚舉類型可以采用任何數量的協議，但是這些協議不能從類，結構體和其他的枚舉繼承。
不像類或者結構體。枚舉類型并不提供隱式的初始構造器，所有構造器必須顯式的聲明。構造器可以委托枚舉中的其他構造器，但是構造過程僅當構造器將一個枚事件指定給`self`才全部完成。
和結構體類似但是和類不同，枚舉是值類型：枚舉實例在賦予變量或常量時，或者被函數調用時被復制。 更多關于值類型的信息，參見結構體和枚舉都是值類型(Structures and Enumerations Are Value Types)一節。
可以擴展枚舉類型，正如在擴展聲明(Extension Declaration)中討論的一樣。
### 任意事件類型的枚舉
如下的形式聲明了一個包含任意類型枚舉時間的枚舉變量
> enum?`enumeration name`:?`adopted protocols`{
> case?`enumeration case 1`
> case?`enumeration case 2`(`associated value types`)
> }
這種形式的枚舉聲明在其他語言中有時被叫做_可識別聯合(discrinminated)_。
這種形式中，每一個事件塊由關鍵字`case`開始，后面緊接著一個或多個以逗號分隔的枚舉事件。每一個事件名必須是獨一無二的。每一個事件也可以指定它所存儲的指定類型的值，這些類型在_關聯值類型(associated values types)_的元組里被指定，立即書寫在事件 名后。獲得更多關于關聯值類型的信息和例子，請查看關聯值(Associated Values)一節。
枚舉有一個遞歸結構，就是說，枚舉有著枚舉類型自身實例的關聯值的事件。然而，枚舉類型的實例有值語義，意味著它們在內存中有著固定的位置。為了支持遞歸，編譯器必需插入一個間接層。
為間接使用特殊的枚舉事件，使用`indirect`聲明修飾符標記。
> enum Tree?{ case Empty indirect case Node(value: T, left: Tree, right:Tree) }
為了間接的使用一個枚舉的所有事件，使用`indirect`修飾符標記整個枚舉-當枚舉有許多事件且每個事件都需要使用`indirect`修飾符標記的時候這將非常便利。
一個被`indirect`修飾符標記的枚舉事件必需有一個關聯值。一個使用`indirect`修飾符標記的枚舉包含有著關聯值的事件和沒有關聯值的事件的混合。就是說，它不能包含任何也使用`indirect`修飾符標記的事件。
### 使用原始值類型事件的枚舉(Enumerations with Cases of a Raw-Value Type)
以下的形式聲明了一個包含相同基礎類型的枚舉事件的枚舉：
> enum?`enumeration name`:?`raw value type`,?`adopted protocols`{
> case?`enumeration case 1`?=?`raw value 1`
> case?`enumeration case 2`?=?`raw value 2`
> }
在這種形式中，每一個事件塊由`case`關鍵字開始，后面緊接著一個或多個以逗號分隔的枚舉事件。和第一種形式的枚舉事件不同，這種形式的枚舉事件包含一個同類型的基礎值，叫做_原始值(raw value)_。這些值的類型在_原始值類型(raw-value type)_中被指定，必須表示一個整數，浮點數，字符串，或者一個字符。特別是_原始值類型(raw-value type)_必需遵守`Equatable`類型的協議和下列形式中的一種字面量構造協議(literal-convertible protocols):整型字面量有`IntergerLiteralConvertible`，浮點行字面量有`FloatingPointLiteralConvertible`，包含任意數量字符的字符串型字面量有`StringLiteralConvertible`，僅包含一個單一字符的字符串型字面量有`ExtendedGraphemeClusterLiteralConvertible`。每一個事件必須有唯一的名字，必須有一個唯一的初始值。
如果初始值類型被指定為`Int`，則不必為事件顯式的指定值，它們會隱式的被標為值`0,1,2`等。每一個沒有被賦值的`Int`類型時間會隱式的賦予一個初始值，它們是自動遞增的。
~~~
num ExampleEnum: Int {
case A, B, C = 5, D
}
~~~
在上面的例子中，`ExampleEnum.A`的值是`0`，`ExampleEnum.B`的值是`1`。因為`ExampleEnum.C`的值被顯式的設定為`5`，因此`ExampleEnum.D`的值會自動增長為`6`。
如果原始值類型被指定為`String`類型，你不用明確的為事件指定值，每一個沒有指定的事件會隱式地用與事件名字相同的字符串指定。
> enum WeekendDay: String { case Saturday, Sunday }
在上面這個例子中，`WeekendDay.Saturday`的原始值是`"Saturday"`,`WeekendDay.Sunday`的原始值是`"Sunday"`。
擁有多種事件的原始值類型的枚舉含蓄地遵循定義在Swift標準庫中的`RawRepresentable`協議。所以，它們擁有一個原始值(`rawValue`)屬性和一個有著`init?(rawValue: RawValue)`簽名的可失敗構造器(a failable initializer)。可以使用原始值屬性去取的枚舉事件的原始值，就像在`ExampleEnum.B.rawValue`中一樣。如果有一個事件符合，也可以使用原始值去找到一個符合的事件，通過調用枚舉的可失敗構造器，如`ExampleEnum(rawValue: 5)`,這個可失敗構造器返回一個可選的事件。想得到更多的信息和關于原始值類型查看更多信息和獲取初始值類型事件的信息，參閱初始值原始值(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)列表_ 可選 _訪問級別修飾符_ 可選 _聯合式枚舉_ 枚舉聲明 → _特性(Attributes)列表_ 可選 _訪問級別修飾符_ 可選 _原始值式枚舉_ 聯合式枚舉 → indirect 可選 enum _枚舉名_ _泛型參數子句_ 可選 類型繼承子句_可選_ { _union-style-enum-members_ 可選 }
> union-style-enum-members → _union-style-enum-member_ _union-style-enum-members_ 可選
> union-style-enum-member → _聲明_ | _聯合式(Union Style)的枚舉case子句_
> 聯合式(Union Style)的枚舉case子句 → _特性(Attributes)列表_ 可選 indirect 可選 case _聯合式(Union Style)的枚舉case列表_
> 聯合式(Union Style)的枚舉case列表 → _聯合式(Union Style)的case_ | _聯合式(Union Style)的case_ , _聯合式(Union Style)的枚舉case列表_
> 聯合式(Union Style)的case → _枚舉的case名_ _元組類型_ 可選
> 枚舉名 → _標識符_
> 枚舉的case名 → _標識符_
> 原始值式枚舉 → enum _枚舉名_ _泛型參數子句_ 可選 _類型繼承子句_ { _原始值式枚舉成員列表_ }
> 原始值式枚舉成員列表 → _原始值式枚舉成員_ _原始值式枚舉成員列表_ 可選
> 原始值式枚舉成員 → _聲明_ | _原始值式枚舉case子句_
> 原始值式枚舉case子句 → _特性(Attributes)列表_ 可選 case _原始值式枚舉case列表_
> 原始值式枚舉case列表 → _原始值式枚舉case_ | _原始值式枚舉case_ , _原始值式枚舉case列表_
> 原始值式枚舉case → _枚舉的case名_ _原始值賦值_ 可選
> 原始值賦值 → = _原始值字面量_
> 原始值字面量 → 數字型字面量|字符串型字面量|布爾型字面量
## 結構體聲明
使用_結構體聲明(strucre declaration)_可以在程序里引入一個結構體類型。結構體聲明使用`struct`關鍵字，遵循如下的形式：
> struct?`structure name`:?`adopted protocols`?{
> `declarations`
> }
結構體內包含零或多個聲明_聲明(declarations)_。這些_聲明(declarations)_可以包括存儲型和計算型屬性，類型屬性，實例方法，類型方法，構造器，下標腳本，類型別名，甚至其他結構體，類，和枚舉聲明。結構體聲明不能包含析構器或者協議聲明。詳細討論和包含多種結構體聲明的實例，參見[類和結構體(Classes and Structures)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
結構體可以包含任意數量的協議，但是不能繼承自類，枚舉或者其他結構體。
有三種方法可以創建一個聲明過的結構體實例：
* 調用結構體內聲明的構造器，參照[構造器(Initializers)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
* 如果沒有聲明構造器，調用結構體的逐個構造器，詳情參見[Memberwise Initializers for Structure Types](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
* 如果沒有聲明析構器，結構體的所有屬性都有初始值，調用結構體的默認構造器，詳情參見[默認構造器(Default Initializers)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
結構體的構造過程參見[構造過程(Initiaization)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
結構體實例屬性可以用點(.)來獲得，詳情參見[獲得屬性(Accessing Properties)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
結構體是值類型；結構體的實例在被賦予變量或常量，被函數調用時被復制。獲得關于值類型更多信息，參見?[結構體和枚舉是值類型(Structures and Enumerations Are Value Types)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
可以使用擴展聲明來擴展結構體類型的行為，參見[擴展聲明(Extension Declaration)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
> 結構體聲明語法
> 結構體聲明 → _特性(Attributes)列表_ 可選 訪問級別修飾符_可選_ struct _結構體名稱_ _泛型參數子句_ 可選 _類型繼承子句_ 可選 _結構體主體_
> 結構體名稱 → _標識符_
> 結構體主體 → { _聲明(Declarations)列表_ 可選 }
## 類聲明
可以在程序中使用_類聲明(class declaration)_來引入一個類。類聲明使用關鍵字`class`，遵循如下的形式：
> class?`class name`:?`superclass`,?`adopted protocols`?{
> `declarations`
> }
一個類內包含零或多個_聲明(declarations)_。這些_聲明(declarations)_可以包括存儲型和計算型屬性，實例方法，類型方法，構造器，單獨的析構器，下標腳本，類型別名，甚至其他結構體，類，和枚舉聲明。類聲明不能包含協議聲明。詳細討論和包含多種類聲明的實例，參見類和結構體(Classes and Structures)一節。
一個類只能繼承一個父類，_超類(superclass)_，但是可以包含任意數量的協議。_超類(superclass)_第一次出現在_類名(class name)_和冒號后面，其后跟著_采用的協議(adopted protocols)_。泛型類可以繼承其它類型類和非泛型類，但是非泛型類只能繼承其它的非泛型類。當在冒號后面寫泛型超類的名稱時，必須寫那個泛型類的全名，包括它的泛型參數子句。
正如在初始化聲明(Initializer Declaration)談及的那樣，類可以有指定構造器和方便構造器。類的指定構造器必須初始化類所有的已聲明的屬性，它必須在超類構造器調用前被執行。
類可以重寫屬性，方法，下表腳本和它的超類構造器。重寫的屬性，方法，下標腳本，和指定構造器必須以`override`聲明修飾符標記。
為了要求子類去實現超類的構造器，使用`required`聲明修飾符去標記超類的構造器。在子類實現父類構造器時也必須使用`required`聲明修飾符去標記。
雖然_超類(superclass)_的屬性和方法聲明可以被當前類繼承，但是_超類(superclass)_聲明的指定構造器卻不能。這意味著，如果當前類重寫了超類的所有指定構造器，它就繼承了超類的方便構造器。Swift的類并不是繼承自一個全局基礎類。
有兩種方法來創建已聲明的類的實例：
* 調用類的一個構造器，參見[構造器(Initializers)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
* 如果沒有聲明構造器，而且類的所有屬性都被賦予了初始值，調用類的默認構造器，參見[默認構造器(Default Initializers)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
類實例屬性可以用點(.)來獲得，詳情參見[獲得屬性(Accessing Properties)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
類是引用類型；當被賦予常量或變量，函數調用時，類的實例是被引用，而不是復制。獲得更多關于引用類型的信息，[結構體和枚舉都是值類型(Structures and Enumerations Are Value Types)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
可以使用擴展聲明來擴展類的行為，參見[擴展聲明(Extension Declaration)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
> 類聲明語法
> 類聲明 → _特性(Attributes)列表_ 可選 訪問級別修飾符class _類名_ _泛型參數子句_ 可選 _類型繼承子句_ 可選 _類主體_
> 類名 → _標識符_
> 類主體 → { _聲明(Declarations)列表_ 可選 }
## 協議聲明(translated by 小一)
一個_協議聲明(protocol declaration)_為程序引入一個命名了的協議類型。協議聲明在一個全局訪問的區域使用`protocol`?關鍵詞來進行聲明并有下面這樣的形式：
> protocol?`protocol name`:?`inherited protocols`?{
> `protocol member declarations`
> }
協議的主體包含零或多個_協議成員聲明(protocol member declarations)_，這些成員描述了任何采用該協議必須滿足的一致性要求。特別的，一個協議可以聲明必須實現某些屬性、方法、初始化程序及下標腳本的一致性類型。協議也可以聲明專用種類的類型別名，叫做_關聯類型(associated types)_，它可以指定協議的不同聲明之間的關系。協議聲明不包括類，結構體，枚舉或者其它協議的聲明。協議成員聲明會在下面的詳情里進行討論。
協議類型可以從很多其它協議那繼承。當一個協議類型從其它協議那繼承的時候，來自其它協議的所有要求就集合了，而且從當前協議繼承的任何類型必須符合所有的這些要求。對于如何使用協議繼承的例子，查看協議繼承(Protocol Inheritance)
> 注意：
> 也可以使用協議合成類型集合多個協議的一致性要求，詳情參見協議合成類型(Protocol Composition Type)和協議合成(Protocol Composition)
可以通過采用在類型的擴展聲明中的協議來為之前聲明的類型添加協議一致性。在擴展中必須實現所有采用協議的要求。如果該類型已經實現了所有的要求，可以讓這個擴展聲明的主題留空。
默認地，符合某一個協議的類型必須實現所有聲明在協議中的屬性、方法和下標腳本。也就是說，可以用`optional`聲明修飾符標注這些協議成員聲明以指定它們的一致性類型實現是可選的。`optional`修飾符僅僅可以用于使用`objc`屬性標記過的協議。這樣的結果就是僅僅類類型可以采用并符合包含可選成員要求的協議。更多關于如何使用`optional`屬性的信息及如何訪問可選協議成員的指導——比如當不能肯定是否一致性的類型實現了它們——參見可選協議要求(Optional Protocol Requirements)
為了限制協議的采用僅僅針對類類型，需要強制使用`class`來標記協議，通過將`class`關鍵在寫在冒號后面的_繼承協議列表(inherited protocols)_的第一個位置。例如，下面的協議形式只能被類類型采用：
~~~
protocol SomeProtocol:class{
/* Protocol member go here */
}
~~~
任意繼承自需要標記有`class`協議的協議都可以智能地僅能被類類型采用。
> 注意：
> 如果協議已經用`object`屬性標記了，`class`條件就隱性地應用于該協議；沒有必要再明確地使用`class`條件來標記該協議了。
協議是命名的類型，因此它們可以以另一個命名類型出現在代碼的所有地方，就像[協議類型(Protocol as Types)](http://wiki.jikexueyuan.com/project/swift/chapter2/21_Protocols.html#protocols_as_types)里討論的那樣。然而不能構造一個協議的實例，因為協議實際上不提供它們指定的要求的實現。
可以使用協議來聲明一個類的代理的方法或者應該實現的結構，就像[委托(代理)模式(Delegation)](http://wiki.jikexueyuan.com/project/swift/chapter2/21_Protocols.html#delegation)描述的那樣。
> 協議(Protocol)聲明語法
> 協議聲明 → _特性(Attributes)列表_ 可選 _訪問級別修飾符_ 可選 protocol _協議名_ _類型繼承子句_ 可選 _協議主體_
> 協議名 → _標識符_
> 協議主體 → { _協議成員聲明(Declarations)列表_ 可選 }
> 協議成員聲明 → _協議屬性聲明_
> 協議成員聲明 → _協議方法聲明_
> 協議成員聲明 → _協議構造器聲明_
> 協議成員聲明 → _協議附屬腳本聲明_
> 協議成員聲明 → _協議關聯類型聲明_
> 協議成員聲明(Declarations)列表 → _協議成員聲明_ _協議成員聲明(Declarations)列表_ _可選_
### 協議屬性聲明
協議聲明了一致性類型必須在協議聲明的主體里通過引入一個_協議屬性聲明(protocol property declaraion)_來實現一個屬性。協議屬性聲明有一種特殊的類型聲明形式：
> var?`property name`:?`type`?{ get set }
同其它協議成員聲明一樣，這些屬性聲明僅僅針對符合該協議的類型聲明了`getter`和`setter`要求。結果就是不需要在協議里它被聲明的地方實現`getter`和`setter`。
`getter`和`setter`要求可以通過一致性類型以各種方式滿足。如果屬性聲明包含`get`和`set`關鍵詞，一致性類型就可以用可讀寫（實現了`getter`和`setter`）的存儲型變量屬性或計算型屬性，但是屬性不能以常量屬性或只讀計算型屬性實現。如果屬性聲明僅僅包含`get`關鍵詞的話，它可以作為任意類型的屬性被實現。比如說實現了協議的屬性要求的一致性類型，參見屬性要求(Property Requirements)
更多參見[變量聲明(Variabel Declaration)](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#variable_declaration)
> 協議屬性聲明語法
> _協議屬性聲明_?→? _變量聲明頭(Head)_?_變量名_?_類型標注_? _getter-setter關鍵字(Keyword)塊_
### 協議方法聲明
協議聲明了一致性類型必須在協議聲明的主體里通過引入一個協議方法聲明來實現一個方法。協議方法聲明和函數方法聲明有著相同的形式，包含如下兩條規則：它們不包括函數體，不能在類的聲明內為它們的參數提供初始值.舉例來說，符合的類型執行協議必需的方法。參見必需方法(Method Requirements)一節。
使用`static`聲明修飾符可以在協議聲明中聲明一個類或必需的靜態方法。執行這些方法的類用修飾符`class`聲明。相反的，執行這些方法的結構體必須以`static`聲明修飾符聲明。如果想使用擴展方法，在擴展類時使用`class`修飾符，在擴展結構體時使用`static`修飾符。
更多請參閱函數聲明(Function Declaration)。
> 協議方法聲明語法
> _協議方法聲明_?→?_函數頭_?_函數名_?_泛型參數子句_?_可選_?_函數簽名(Signature)_
### 協議構造器聲明
協議聲明了一致性類型必須在協議聲明的主體里通過引入一個協議構造器聲明來實現一個構造器。協議構造器聲明 除了不包含構造器體外，和構造器聲明有著相同的形式。
一個一致性類型可以通過實現一個非可失敗構造器或者`init!`可失敗構造器去滿足一個非可失敗協議構造器的需求。一個一致性類型通過實現任意類型的構造器可以滿足一個可失敗協議構造器的需求。
當一個類去實現一個構造器去滿足一個協議的構造器的需求，如果這個類還沒有用`final`聲明修飾符標記，這個構造器必需使用`required`聲明修飾符去標記。
更多請參閱構造器聲明(Initializer Declaration)。
> 協議構造器聲明語法
> _協議構造器聲明_?→?_構造器頭(Head)_?_泛型參數子句_?_可選_?_參數子句_
### 協議下標腳本聲明
協議聲明了一致性類型必須在協議聲明的主體里通過引入一個協議下標腳本聲明來實現一個下標腳本。協議下標腳本聲明對下標腳本聲明有一個特殊的形式：
> subscript (`parameters`) ->?`return type`?{ get set }
下標腳本聲明只為和協議一致的類型聲明了必需的最小數量的的getter和setter。如果下標腳本申明包含get和set關鍵字，一致的類型也必須有一個getter和setter語句。如果下標腳本聲明值包含get關鍵字，一致的類型必須_至少(at least)_包含一個getter語句，可以選擇是否包含setter語句。
更多參閱[下標腳本聲明(Subscript Declaration)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
> 協議附屬腳本聲明語法
> _協議附屬腳本聲明_?→?_附屬腳本頭(Head)_?_附屬腳本結果(Result)_?_getter-setter關鍵字(Keyword)塊_
### 協議相關類型聲明
協議聲明相關類型使用關鍵字`typealias`。相關類型為作為協議聲明的一部分的類型提供了一個別名。相關類型和參數語句中的類型參數很相似，但是它們在聲明的協議中包含`self`關鍵字。在這些語句中，`self`指代和協議一致的可能的類型。獲得更多信息和例子，查看關聯類型(Associated Types)一節或類型別名聲明(Type Alias Declaration)一節。
> 協議關聯類型聲明語法
> _協議關聯類型聲明_?→?_類型別名頭(Head)_?_類型繼承子句_?_可選_?_類型別名賦值_?_可選_
## 構造器聲明
_構造器(initializer)_聲明會為程序內的類，結構體或枚舉引入構造器。構造器使用關鍵字`init`來聲明，遵循兩條基本形式。
結構體，枚舉，類可以有任意數量的構造器，但是類的構造器的規則和行為是不一樣的。不像結構體和枚舉那樣，類有兩種結構體，designed initializers 和convenience initializers，參見[構造器(Initialization)](51353)一節。
如下的形式聲明了結構體，枚舉和類的指定構造器：
> init(`parameters`) {
> `statements`
> }
類的指定構造器將類的所有屬性直接初始化。如果類有超類，它不能調用該類的其他構造器,它只能調用超類的一個指定構造器。如果該類從它的超類處繼承了任何屬性，這些屬性在當前類內被賦值或修飾時，必須調用一個超類的指定構造器。
指定構造器可以在類聲明的上下文中聲明，因此它不能用擴展聲明的方法加入一個類中。
結構體和枚舉的構造器可以調用其他的已聲明的構造器，委托其中一個或所有的構造器進行初始化過程。
以`convenience`聲明修飾符來標記構造器聲明來聲明一個類的便利構造器：
> convenience init(`parameters`) {
> `statements`
> }
便利構造器可以將初始化過程委托給另一個便利構造器或類的一個指定構造器。這意味著，類的初始化過程必須 以一個將所有類屬性完全初始化的指定構造器的調用作為結束。便利構造器不能調用超類的構造器。
可以使用required聲明修飾符，將便利構造器和指定構造器標記為每個子類的構造器都必須實現的。一個子類的關于這個構造器的實現也必須使用`required`聲明修飾符標記。
默認情況下，聲明在超類的構造器沒有被子類繼承。也就是說，如果一個子類使用默認的值去構造它所有的存儲屬性，而且沒有定義任何自己的構造器，它將繼承超類的構造器。如果子類重寫所有超類的指定構造器，子類繼承超類的便利構造器。
和方法，屬性和下表腳本一樣，需要使用`override`聲明修飾符標記重寫了的制定構造器。
> 注意 如果使用`required`聲明修飾符去標記一個構造器，當在子類中重寫必要構造器時，也不要用`override`修飾符去標記構造器。
查看更多關于不同聲明方法的構造器的例子，參閱[構造過程(Initialization)](51353)一節。
### 可失敗構造器(Failable Initializers)
_可失敗構造器_是一種可以生成可選實例或者是一類構造器聲明的隱式解析可選實例(an implicitly unwrapped optional instance)類型。所以，構造區通過返回`nil`來指明構造過程失敗。
聲明可以生成可選實例的可失敗構造器，在構造器聲明的`init`關鍵字后加追加一個問號(`init?`)。聲明可生成隱式解析可選實例的可失敗構造器，在構造器聲明后追加一個嘆號(`init!`)。使用`init?`可失敗構造器生成結構體的一個可選實例的例子如下。
~~~
struct SomeStruct {
let string: String
//生成一個'SomeStruct'的可選實例
init?(input: String) {
if input.isEmpty {
// 棄用'self' 返回 'nil'
}
string = input
}
}
~~~
除非必需處理結果的可選性，可以使用調用非可失敗構造器的方式調用`init?`可失敗構造器。
~~~
if let actualInstance = SomeStruct(input: "Hello") {
//'SomeStruct'實例相關
} else {
//'SomeStruct'實例構造過程失敗，構造器返回'nil'
}
~~~
在實現構造體的任何時間，結構體或者枚舉的可失敗構造器可以返回`nil`。然而，類的可失敗構造器，僅在類的所有存儲屬性被構造之后且`self.init`或`super.init`被調用之后才返回`nil`（就是說，構造器的委托被執行）。
可失敗構造器可以委托任何種類的構造器。非可失敗可以委托其它非可失敗構造器或者`init!`可失敗構造器。
構造過程的失敗由構造器的委托產生。特別的，如果可失敗構造器代理一個構造器失敗且返回`nil`，那么之后被委托的構造器也會失敗且隱式的返回`nil`。如果非可失敗構造器代理`init!`可失敗構造器失敗了且返回`nil`，那么后出現一個運行時錯誤（如同使用`!`操作符去解析一個有著`nil`值的可選項）。
可失敗指定構造器可以在子類中任何一種指定構造器重寫。非可失敗指定構造器在子類中僅能通過非可失敗構造器被重寫。
得到更多的信息并且了解更多關于可失敗構造器的例子，請參閱可失敗構造器(Failable Initializer)
> 構造器聲明語法
> _構造器聲明_?→?_構造器頭(Head)_?_泛型參數子句_?_可選_?_參數子句_?_構造器主體_
> _構造器頭(Head)_?→? _特性(Attributes)列表_ ?_可選_? _聲明修飾符列表(modifiers)_ ?_可選_?init
> _構造器頭(Head)_?→? _特性(Attributes)列表_ ?_可選_? _聲明修飾符列表(modifiers)_ ?_可選_?init ?
> _構造器頭(Head)_?→? _特性(Attributes)列表_ ?_可選_? _聲明修飾符列表(modifiers)_ ?_可選_?init !?_構造器主體_?→? _代碼塊_
## 析構聲明
_析構聲明(deinitializer declaration)_為類聲明了一個析構器。析構器沒有參數，遵循如下的格式：
> deinit {
> `statements`
> }
當類沒有任何語句時將要被釋放時，析構器會自動的被調用。析構器在類的聲明體內只能被聲明一次——但是不能在 類的擴展聲明內，每個類最多只能有一個。
子類繼承了它的超類的析構器，在子類將要被釋放時隱式的調用。子類在所有析構器被執行完畢前不會被釋放。
析構器不會被直接調用。
查看例子和如何在類的聲明中使用析構器，參見[析構過程Deinitialization](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
> 析構器聲明語法
> _析構器聲明_?→?[ _特性(Attributes)列表_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/06_Attributes.html#attributes)?_可選_?deinit?[ _代碼塊_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#code_block)
## 擴展聲明
_擴展聲明(extension declaration)_用于擴展一個現存的類，結構體，枚舉的行為。擴展聲明使用關鍵字`extension`，遵循如下的規則：
> extension?`type name`:?`adopted protocols`?{
> `declarations`
> }
一個擴展聲明體包括零個或多個_聲明語句(declarations)_。這些_聲明語句(declarations)_可以包括計算型屬性，計算型類型屬性，實例方法，類型方法，構造器，下標腳本聲明，甚至其他結構體，類，和枚舉聲明。擴展聲明不能包含析構器，協議聲明，存儲型屬性，屬性監測器或其他的擴展屬性。詳細討論和查看包含多種擴展聲明的實例，參見[擴展(Extensions)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一節。
擴展聲明可以向現存的類，結構體，枚舉內添加_一致的協議(adopted protocols)_。擴展聲明不能向一個類中添加繼承的類，因此在_類型名稱_的冒號后面僅能指定一個協議列表。
屬性，方法，現存類型的構造器不能被它們類型的擴展所重寫。
擴展聲明可以包含構造器聲明，這意味著，如果擴展的類型在其他模塊中定義，構造器聲明必須委托另一個在 那個模塊里聲明的構造器來恰當的初始化。
> 擴展(Extension)聲明語法
> _擴展聲明_?→?[訪問級別修飾符](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)?_可選_?extension?[_類型標識_](http://wiki.jikexueyuan.com/project/swift/chapter3/03_Types.html#type_identifier)?[_類型繼承子句_](http://wiki.jikexueyuan.com/project/swift/chapter3/03_Types.html#type_inheritance_clause)?_可選_?[_extension-body_](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#extension_body)
> _extension-body_?→?{?[_聲明(Declarations)列表_](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#declarations)?_可選_?}
## 下標腳本聲明
_下標腳本(subscript)_聲明用于向特定類型添加附屬腳本支持，通常為訪問集合，列表和序列的元素時提供語法便利。附屬腳本聲明使用關鍵字`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 name)_和封閉的括號是可選的。如果使用了setter名稱，它會被當做傳給setter的變量的名稱。如果不使用setter名稱，那么傳給setter的變量的名稱默認是`value`。_setter名稱(setter name)_的類型必須與_返回類型(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)_](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#subscript_head)?[_附屬腳本結果(Result)_](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#subscript_result)?[ _代碼塊_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#code_block)
> _附屬腳本聲明_?→?[ _附屬腳本頭(Head)_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#subscript_head)?[ _附屬腳本結果(Result)_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#subscript_result)?[ _getter-setter塊_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#getter_setter_block)
> _附屬腳本聲明_?→?[ _附屬腳本頭(Head)_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#subscript_head)?[ _附屬腳本結果(Result)_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#subscript_result)?[ _getter-setter關鍵字(Keyword)塊_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#getter_setter_keyword_block)
> _附屬腳本頭(Head)_?→?[ _特性(Attributes)列表_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/06_Attributes.html#attributes)?_可選_?[ _聲明修飾符列表(declaration-modifiers)_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)?_可選_?subscript [ _參數子句_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#parameter_clause)
> _附屬腳本結果(Result)_?→?->?[ _特性(Attributes)列表_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/06_Attributes.html#attributes)?_可選_?[ _類型_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/03_Types.html#type)
## 運算符聲明(translated by 林)
_運算符聲明(operator declaration)_會向程序中引入中綴、前綴或后綴運算符，它使用關鍵字`operator`聲明。
可以聲明三種不同的綴性：中綴、前綴和后綴。操作符的_綴性(fixity)_描述了操作符與它的操作數的相對位置。
運算符聲明有三種基本形式，每種綴性各一種。運算符的綴性通過在`operator`關鍵字之前添加聲明修飾符`infix`，`prefix`或`postfix`來指定。每種形式中，運算符的名字只能包含[運算符(Operators)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)中定義的運算符字符。
下面的這種形式聲明了一個新的中綴運算符：
> infix operator?`operator name`?{
> precedence?`precedence level`
> associativity?`associativity`
> }
_中綴運算符(infix operator)_是二元運算符，它可以被置于兩個操作數之間，比如表達式`1 + 2`?中的加法運算符(`+`)。
中綴運算符可以可選地指定優先級，結合性，或兩者同時指定。
運算符的_優先級(precedence)_可以指定在沒有括號包圍的情況下，運算符與它的操作數如何緊密綁定的。可以使用上下文關鍵字`precedence`并_優先級(precedence level)_一起來指定一個運算符的優先級。_優先級(precedence level)_可以是0到255之間的任何一個數字(十進制整數)；與十進制整數字面量不同的是，它不可以包含任何下劃線字符。盡管優先級是一個特定的數字，但它僅用作與另一個運算符比較(大小)。也就是說，一個操作數可以同時被兩個運算符使用時，例如`2 + 3 * 5`，優先級更高的運算符將優先與操作數綁定。
運算符的_結合性(associativit)_可以指定在沒有括號包圍的情況下，優先級相同的運算符以何種順序被分組的。可以使用上下文關鍵字`associativity`并_結合性(associativity)_一起來指定一個運算符的結合性，其中_結合性_可以說是上下文關鍵字`left`，`right`或`none`中的任何一個。左結合運算符以從左到右的形式分組。例如，減法運算符(`-`)具有左結合性，因此`4 - 5 - 6`被以`(4 - 5) - 6`的形式分組，其結果為`-7`。 右結合運算符以從右到左的形式分組，對于設置為`none`的非結合運算符，它們不以任何形式分組。具有相同優先級的非結合運算符，不可以互相鄰接。例如，表達式`1 < 2 < 3`非法的。
聲明時不指定任何優先級或結合性的中綴運算符，它們的優先級會被初始化為100，結合性被初始化為`none`。
下面的這種形式聲明了一個新的前綴運算符：
> prefix operator?`operator name`{}
緊跟在操作數前邊的_前綴運算符(prefix operator)_是一元運算符，例如表達式`++i`中的前綴遞增運算符(`++`)。
前綴運算符的聲明中不指定優先級。前綴運算符是非結合的。
下面的這種形式聲明了一個新的后綴運算符：
> postfix operator?`operator name`{}
緊跟在操作數后邊的_后綴運算符(postfix operator)_是一元運算符，例如表達式`i++`中的前綴遞增運算符(`++`)。
和前綴運算符一樣，后綴運算符的聲明中不指定優先級。后綴運算符是非結合的。
聲明了一個新的運算符以后，需要聲明一個跟這個運算符同名的函數來實現這個運算符。如果在實現一個前綴或者后綴操作符，也必須使用相符的`prefix`或者`postfix`聲明修飾符標記函數聲明。如果實現中綴操作符，不需要使用`infix`聲明修飾符標記函數聲明。如何實現一個新的運算符，請參考[Custom Operators](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
> 運算符聲明語法
> _運算符聲明_?→?[ _前置運算符聲明_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#prefix_operator_declaration)?|?[ _后置運算符聲明_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#postfix_operator_declaration)?|?[ _中置運算符聲明_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#infix_operator_declaration)
> _前置運算符聲明_?→?prefix?運算符?[ _運算符_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/LexicalStructure.html#operator)?{?}
> _后置運算符聲明_?→?postfix?運算符?[ _運算符_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/LexicalStructure.html#operator)?{?}
> _中置運算符聲明_?→?infix?運算符?[ _運算符_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/LexicalStructure.html#operator)?{?[ _中置運算符屬性_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#infix_operator_attributes)?_可選_?}
> _中置運算符屬性_?→?[ _優先級子句_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#precedence_clause)?_可選_?[ _結和性子句_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#associativity_clause)?_可選_
> _優先級子句_?→?precedence?[ _優先級水平_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#precedence_level)
> _優先級水平_?→ 十進制整數 0 到 255
> _結和性子句_?→?associativity?[ _結和性_ ](http://wiki.jikexueyuan.com/project/swift/chapter3/05_Declarations.html#associativity)
> _結和性_?→?left?|?right?|?none
## 聲明修飾符
_聲明修飾符(Declaration modifiers)_是關鍵字或者說是上下文相關的關鍵字，它可以修改一個聲明的行為或者含義。可以在一個聲明的特性和引進該聲明的關鍵字之間，指定一個聲明修飾符，并寫下它的關鍵字或上下文相關的關鍵字。
`dynamic`?可以將該修飾符用于任何可以出現在Objective-C中的類成員上。當將`dynamic`修飾符用于一個成員聲明上時，對該成員的訪問總是由Objective-C的實時系統動態地安排，而永遠不會由編譯器內聯或去虛擬化。 因為當一個聲明被標識`dynamic`修飾符時，會由Objective-C的實時系統動態地安排，所以他們是被隱式的標識了`objc`特性的。
`final`
該修飾符用于修飾一個類或類中的屬性，方法，以及下標成員。如果用它修飾一個類，那么這個類則不能被繼承。如果用它修飾類中的屬性，方法或下標，則表示在子類中，它們不能被重寫。
`lazy`
該修飾符用于修飾類或結構體中的存儲型變量屬性，表示該屬性的初始值最多只被計算和存儲一次，且發生在第一次訪問它時。如何使用`lazy`特性的一個例子，請見：[惰性存儲型屬性(Lazy Stored Properties)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)。
`optional`
該修飾符用于修飾一個類或類中的屬性，方法，以及下標成員,表示遵循類型沒有被要求實現這些成員。 只能將`optional`修飾符用于被`objc`標識的協議。這樣一來，只有類類型可以適配或遵循擁有可選成員需求的協議。關于如何使用`optional`修飾符,以及如何訪問可選協議成員的指導(比如，不確定遵循類型是否已經實現了這些可選成員)，可以參見[可選成員需求(Optional Protocol Requirements)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一章
`required`
該修飾符用于修飾一個類的特定構造器或便捷構造器,表示該類所有的子類都需要實現該構造器。在子類實現該構造器時，同樣必須使用`required`修飾符修飾該構造器。
`weak`
`weak`修飾符用于修飾一個變量或一個存儲型變量屬性，表示該變量或屬性通過一個弱引用指向存儲其值的對象。該變量或屬性的類型必須是一個可選類類型。通過`weak`修飾符可避免強引用循環。關于`weak`修飾符的例子和更多信息，可以參見[弱引用(Weak References)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一章
### 訪問控制級別
Swift提供了三個級別的權限控制：`public`,?`internal`, 和?`private`。可以給聲明標識以下訪問級別修飾符中的一個以指定聲明的權限級別。訪問控制在[訪問控制(Access Control)](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一章有詳細說明。
`public`
修飾符用于修飾聲明時，表示該聲明可被同一個模塊中的代碼訪問。被`public`權限級別修飾符修飾的聲明，還可被其他模塊的代碼訪問，只要該模塊注入了該聲明所在的模塊。
`internal`
修飾符用于修飾聲明時，表示該聲明只能被同一模塊中的代碼訪問。默認的，絕大多數聲明會被隱式的標識上`internal`權限級別修飾符
`private`
修飾符用于修飾聲明時，表示該聲明只能被同一源文件中的代碼訪問。
以上的任意一個權限級別修飾符都可以有選擇的帶上一個參數，該參數由關鍵字`set`和一對括號組成（比如，`private(set)`）。當想要指明一個變量或下標腳注的setter的訪問級別要低于或等于該變量或下標腳注的實際訪問級別時，使用這種格式的權限級別修飾符，就像[Getters and Setters](http://wiki.jikexueyuan.com/project/swift/chapter3/TODO)一章中討論的一樣。
> 聲明修飾符的語法
>
> 聲明修飾符 →?class- |?convenience-|?dynamic- |?final- |?infix- |?lazy-?|?mutating- |?nonmutating- |optional- |?override- |?postfix|-?prefix-?|?required-?|?static- |?unowned-?|?unowned-(-safe-)- |unowned-(-unsafe-)-?|?weak-
>
> 聲明修飾符 → 權限級別修飾符-
>
> 訪問級別修飾符 →?internal- |?internal-(-set-)-
>
> 訪問級別修飾符 →?private-?|?private-(-set-)-
>
> 訪問級別修飾符 →?public-?|?public-(-set-)-
>
> 訪問級別修飾符 →?訪問級別修飾符(access-level-modeifier)?訪問級別修飾符列表(access-level-modeifiers) _可選_?-
- 介紹
- 歡迎使用 Swift
- 關于 Swift
- Swift 初見
- Swift 版本歷史記錄
- Swift1.0 發布內容
- Swift 教程
- 基礎部分
- 基本運算符
- 字符串和字符
- 集合類型
- 控制流
- 函數
- 閉包
- 枚舉
- 類和結構體
- 屬性
- 方法
- 下標腳本
- 繼承
- 構造過程
- 析構過程
- 自動引用計數
- 可選鏈
- 錯誤處理
- 類型轉換
- 嵌套類型
- 擴展
- 協議
- 泛型
- 權限控制
- 高級操作符
- 語言參考
- 關于語言參考
- 詞法結構
- 類型
- 表達式
- 語句
- 聲明
- 特性
- 模式
- 泛型參數
- 語法總結
- 蘋果官方Blog官方翻譯
- Access Control 權限控制的黑與白
- 造個類型不是夢-白話Swift類型創建
- WWDC里面的那個“大炮打氣球”
- Swift與C語言指針友好合作
- 引用類型和值類型的恩怨
- 訪問控制和Protected
- 可選類型完美解決占位問題