deinit: 當一個類的實例即將被銷毀時，會調(diào)用這個方法。

class Person  
{  
    var name:String  
    var age:Int  
    var gender:String

    deinit  
    {  
        //從堆中釋放，并釋放的資源
    }  
}

extension：允許給已有的類、結(jié)構(gòu)體、枚舉、協(xié)議類型，添加新功能。

class Person  
{  
    var name:String = ""  
    var age:Int = 0  
    var gender:String = ""  
}

extension Person  
{  
    func printInfo()  
    {  
        print("My name is \(name), I'm \(age) years old and I'm a \(gender).")  
    }  
}

inout：將一個值傳入函數(shù)，并可以被函數(shù)修改，然后將值傳回到調(diào)用處，來替換初始值。適用于引用類型和值類型。 其實就是聲明參數(shù)為指針

func dangerousOp(_ error:inout NSError?)  
{  
    error = NSError(domain: "", code: 0, userInfo: ["":""])  
}

var potentialError:NSError?
dangerousOp(&potentialError)

//代碼運行到這里，potentialError 不再是 nil，而是已經(jīng)被初始化

internal：訪問控制權(quán)限，允許同一個模塊下的所有源文件訪問，如果在不同模塊下則不允許訪問。

public：可以被任何人訪問。但其他 module 中不可以被 override 和繼承，而在 module 內(nèi)可以被 override 和繼承。

open：訪問控制權(quán)限，允許在定義的模塊外也可以訪問源文件里的所有類，并進行子類化。對于類成員，允許在定義的模塊之外訪問和重寫。

open var foo:String? //這個屬性允許在 app 內(nèi)或 app 外重寫和訪問。在開發(fā)框架的時候，會應(yīng)用到這個訪問修飾符。

private：訪問控制權(quán)限，只允許實體在定義的類以及相同源文件內(nèi)的 extension 中訪問。

class Person  
{  
    private var jobTitle:String = ""  
}

// 當 extension 和 class 不在同一個源文件時
extension Person  
{
    // 無法編譯通過，只有在同一個源文件下才可以訪問
    func printJobTitle()  
    {  
        print("My job is \(jobTitle)")  
    }  
}

fileprivate：訪問控制權(quán)限，只允許在定義源文件中訪問。// 同文件中訪問

class Person  
{  
    fileprivate var jobTitle:String = ""  
}

extension Person  
{
    //當 extension 和 class 在同一個文件中時，允許訪問
    func printJobTitle()  
    {  
        print("My job is (jobTitle)")  
    }  
}

從高到低排序如下：
open > public > interal > fileprivate > private

static：用于定義類方法，在類型本身進行調(diào)用。此外還可以定義靜態(tài)成員。

class Person  
{  
    var jobTitle:String?

    static func assignRandomName(_ aPerson:Person)  
    {  
        aPerson.jobTitle = "Some random job"  
    }  
}

let somePerson = Person()  
Person.assignRandomName(somePerson)  
//somePerson.jobTitle 的值是 "Some random job"

在方法的 func 關(guān)鍵字之前加上關(guān)鍵字 static 或者 class 都可以用于指定類方法.不同的是用class關(guān)鍵字指定的類方法可以被子類重寫, 如下:
override class func work() { print("Teacher: University Teacher")}
但是用 static 關(guān)鍵字指定的類方法是不能被子類重寫的, 根據(jù)報錯信息: Class method overrides a 'final' class method.

我們可以知道被 static 指定的類方法包含 final 關(guān)鍵字的特性--防止被重寫.

struct：通用、靈活的結(jié)構(gòu)體，是程序的基礎(chǔ)組成部分，并提供了默認初始化方法。與 class 不同，當 struct 在代碼中被傳遞時，是被拷貝的，并不使用引用計數(shù)。除此之外，struct 沒有下面的這些功能：

• 使用繼承。
• 運行時的類型轉(zhuǎn)換。
• 使用析構(gòu)方法。

數(shù)據(jù)類型：struct是值類型，class是引用類型。
值類型變量直接包含數(shù)據(jù)，賦值時也是值拷貝，或者叫深拷貝，所以多個變量的操作不會相互影響。
引用類型變量存儲的是對數(shù)據(jù)的引用地址，后者稱為對象，賦值時，是將對象的引用地址復制過去，也叫淺拷貝，因此若多個變量指向同一個對象時，操作會相互影響。
值類型數(shù)據(jù)沒有引用計數(shù)，也就不會因為循環(huán)引用導致內(nèi)存泄漏，而引用類型存在引用計數(shù)，需要小心循環(huán)引用導致的內(nèi)存泄漏
拷貝時，struct是深拷貝，拷貝的是內(nèi)容，class則需要選用正確的深淺拷貝類型。

因為值類型數(shù)據(jù)是深拷貝，所以是線程安全的，而引用類型數(shù)據(jù)則不是

• property的初始化：初始化屬性時，class 需要創(chuàng)建一個帶形參的constructor；struct可以把屬性放在默認的constructor 的參數(shù)里。
• immutable變量：swift用var和let區(qū)分可變數(shù)據(jù)和不可變數(shù)據(jù)，struct遵循這個特性；對class則不適用。
• mutating function：struct 的 function 改變 property 時，需加上 mutating，而 class 不用。
• 速度：struct分配在棧中，class分配在堆中，也就意味著struct更迅速。
• NSUserDefaults：struct 不能被序列化成 NSData 對象，class可以。
• 繼承： struct不可以繼承，class可以繼承。
• swift與oc混合開發(fā)時，oc調(diào)用swift需要繼承NSObject，這就導致了class可以繼承，所以可以調(diào)用class，但struct不能繼承，所以不能調(diào)用struct

typealias：給代碼中已經(jīng)存在的類，取別名。

typealias JSONDictionary = [String: AnyObject]

func parseJSON(_ deserializedData:JSONDictionary){}

defer：用于在程序離開當前作用域之前，執(zhí)行一段代碼。 // dafer 是倒敘 先加入后執(zhí)行

• 關(guān)閉文件

  func foo() {
    let fileDescriptor = open(url.path, O_EVTONLY)
    defer {
      close(fileDescriptor)
    }
    // use fileDescriptor...
  }
  

• 加/解鎖：下面是 swift 里類似 Objective-C 的 synchronized block 的一種寫法，可以使用任何一個 NSObject 作 lock

  func foo() {
    objc_sync_enter(lock)
    defer { 
      print("003")  
      objc_sync_exit(lock) 
    }
    defer { 
      print("002")   
    }
    print("001")    
    // do something...
  }
  

defer 的執(zhí)行時機:

defer 的執(zhí)行時機緊接在離開作用域之后，但是是在其他語句之前。這個特性為 defer 帶來了一些很“微妙”的使用方式。比如從 0 開始的自增：

class Foo {
    var num = 0
    func foo() -> Int {
        defer { num += 1 }
        return num
    }
    
    // 沒有 `defer` 的話我們可能要這么寫
    // func foo() -> Int {
    //    num += 1
    //    return num - 1
    // }
}

let f = Foo()
f.foo() // 0
f.foo() // 1
f.num   // 2

fallthrough：顯式地允許從當前 case 跳轉(zhuǎn)到下一個相鄰 case 繼續(xù)執(zhí)行代碼。

let box = 1

switch box  
{  
    case 0:  
    print("Box equals 0")  
    fallthrough  
    case 1:  
    print("Box equals 0 or 1")  
    default:  
    print("Box doesn't equal 0 or 1")  
    // Box equals 0 和 Box equals 0 or 1  都執(zhí)行了
}

guard：當有一個以上的條件不滿足要求時，將離開當前作用域。同時還提供解包可選類型的功能。

private func printRecordFromLastName(userLastName: String?)
{  
    guard let name = userLastName, name != "Null" else  
    {  
        //userLastName = "Null"，需要提前退出
        return  
    }
    //繼續(xù)執(zhí)行代碼
    print(dataStore.findByLastName(name))  
}

1.guard關(guān)鍵字必須使用在函數(shù)中。
2.guard關(guān)鍵字必須和else同時出現(xiàn)。
3.guard關(guān)鍵字只有條件為false的時候才能走else語句 相反執(zhí)行后邊語句。

repeat：在使用循環(huán)的判斷條件之前，先執(zhí)行一次循環(huán)中的代碼。類似于 do while 循環(huán)

repeat
{
print("Always executes at least once before the condition is considered")
}
while 1 > 2

where：要求關(guān)聯(lián)類型必須遵守特定協(xié)議，或者類型參數(shù)和關(guān)聯(lián)類型必須保持一致。也可以用于在 case 中提供額外條件，用于滿足控制表達式。

• 增加判斷條件

for i in 0…3 where i % 2 == 0  
{  
    print(i) //打印 0 和 2  
}

• 協(xié)議使用where， 只有基類實現(xiàn)了當前協(xié)議才能添加擴展。 換個說法， 多個類實現(xiàn)了同一個協(xié)議，該語法根據(jù)類名分別為這些類添加擴展， 注意是分別(以類名區(qū)分)?。?！

protocol SomeProtocol {
    func someMethod()
}
class A: SomeProtocol {
    let a = 1
       func someMethod() {
       print("call someMethod")
    }
}
class B {
    let a = 2
}
//基類A繼承了SomeProtocol協(xié)議才能添加擴展
extension SomeProtocol where Self: A {
    func showParamA() {
        print(self.a)
    }
}
//反例，不符合where條件
extension SomeProtocol where Self: B {
    func showParamA() {
        print(self.a)
    }
}
let objA = A()
let objB = B()  //類B沒實現(xiàn)SomeProtocol， 所有沒有協(xié)議方法
objA.showParamA()  //輸出1

as：類型轉(zhuǎn)換運算符，用于嘗試將值轉(zhuǎn)成其它類型。

• as : 數(shù)值類型轉(zhuǎn)換

  let age = 28 as Int
  let money = 20 as CGFloat
  let cost = (50 / 2) as Double
  

  switch person1 { 
  case let person1 as Student: 
      print("是Student類型，打印學生成績單...") 
  case let person1 as Teacher: 
      print("是Teacher類型，打印老師工資單...") 
  default: break
  }
  

• as!:向下轉(zhuǎn)型（Downcasting）時使用。由于是強制類型轉(zhuǎn)換，如果轉(zhuǎn)換失敗會報 runtime 運行錯誤。

  let a = 13 as! String
  print(a)
  //會crash
  

  let a = 13 as? String
  print(a)
  //輸出為nil
  

is：類型檢查運算符，用于確定實例是否為某個子類類型。

class Person {}  
class Programmer : Person {}  
class Nurse : Person {}

let people = [Programmer(), Nurse()]

for aPerson in people  
{  
    if aPerson is Programmer  
    {  
        print("This person is a dev")  
    }  
    else if aPerson is Nurse  
    {  
        print("This person is a nurse")  
    }  
}

nil：在 Swift 中表示任意類型的無狀態(tài)值。

Swift的nil和OC中的nil不一樣.在OC中,nil是一個指向不存在對象的指針.而在Swift中,nil不是指針,它是一個不確定的值.用來表示值缺失.任何類型的optional都可以被設(shè)置為nil. 而在OC中,基本數(shù)據(jù)類型和結(jié)構(gòu)體是不能被設(shè)置為nil的. 給optional的常量或者變量賦值為nil.來表示他們的值缺失情況.一個optional常量或者變量如果在初始化的時候沒有被賦值,他們自動會設(shè)置成nil.

class Person{}  
struct Place{}

//任何 Swift 類型或?qū)嵗梢詾?nil
var statelessPerson:Person? = nil  
var statelessPlace:Place? = nil  
var statelessInt:Int? = nil  
var statelessString:String? = nil

super：在子類中，暴露父類的方法、屬性、下標。

class Person  
{  
    func printName()  
    {  
        print("Printing a name. ")  
    }  
}

class Programmer : Person  
{  
    override func printName()  
    {  
        super.printName()  
        print("Hello World!")  
    }  
}

let aDev = Programmer()  
aDev.printName() //打印 Printing a name. Hello World!

self：任何類型的實例都擁有的隱式屬性，等同于實例本身。此外還可以用于區(qū)分函數(shù)參數(shù)和成員屬性名稱相同的情況。

class Person  
{  
    func printSelf()  
    {  
        print("This is me: \(self)")  
    }  
}

let aPerson = Person()  
aPerson.printSelf() //打印 "This is me: Person"

Self：在協(xié)議中，表示遵守當前協(xié)議的實體類型。

protocol Printable  
{  
    func printTypeTwice(otherMe:Self)  
}

struct Foo : Printable  
{  
    func printTypeTwice(otherMe: Foo)  
    {  
        print("I am me plus \(otherMe)")  
    }  
}

let aFoo = Foo()  
let anotherFoo = Foo()

aFoo.printTypeTwice(otherMe: anotherFoo) //打印 I am me plus Foo()

_：用于匹配或省略任意值的通配符。

for _ in 0..<3  
{  
    print("Just loop 3 times, index has no meaning")  
}

另外一種用法：

let _ = Singleton() //忽略不使用的變量

convenience：

在 Swift 中，為保證安全性，init 方法只能調(diào)用一次，且在 init 完成后，保證所有非 Optional 的屬性都已經(jīng)被初始化。

每個類都有指定的初始化方法：designated initializer，這些初始化方法是子類必須調(diào)用的，為的就是保證父類的屬性都初始化完成了。

而如果不想實現(xiàn)父類的 designated initializer，可以添加 convenience 關(guān)鍵字，自己實現(xiàn)初始化邏輯。
convenience 初始化不能調(diào)用父類的初始化方法，只能調(diào)用同一個類中的 designated initializer。
由于 convenience 初始化不安全，所以 Swift 不允許 convenience initializer 被子類重寫，限制其作用范圍。

class People {
    var name: String
    init(name: String) {
        self.name = name
    }
}

通過extension給原有的People類增加init方法:

// 使用convenience增加init方法
extension People {
    convenience init(smallName: String) {
        self.init(name: smallName)
    }
}

接下來，Student類繼承父類People

class Student: People {
    var grade: Int
    
    init(name: String, grade: Int) {
        self.grade = grade
        super.init(name: name)
        // 無法調(diào)用
        // super.init(smallName: name)
    }
    
    // 可以被重寫 
    override init(name: String) {
        grade = 1
        super.init(name: name)
    }
    
    // 無法重寫，編譯不通過
    override init(smallName: String) {
        grade = 1
        super.init(smallName: smallName)
    }
}

子類對象調(diào)用父類的convenience的init方法：只要在子類中實現(xiàn)重寫了父類convenience方法所需要的init方法的話，我們在子類中就可以使用父類的convenience初始化方法了

class People {
    
    var name: String
    
    init(name: String) {
        self.name = name
    }
}
// 使用convenience增加init方法
extension People {
    convenience init(smallName: String) {
        self.init(name: smallName)
    }
}


// 子類
class Teacher: People {
    
    var course: String
    
    init(name: String, course: String) {
        self.course = course
        super.init(name: name)
    }
    
    override init(name: String) {
        self.course = "math"
        super.init(name: name)
    }
}

// 調(diào)用convenience的init方法
let xiaoming = Teacher(smallName: "xiaoming")

• 總結(jié)：子類的designated初始化方法必須調(diào)用父類的designated方法，以保證父類也完成初始化。

required

對于某些我們希望子類中一定實現(xiàn)的designated初始化方法，我們可以通過添加required關(guān)鍵字進行限制，強制子類對這個方法重寫。
required修飾符的使用規(guī)則:

• required修飾符只能用于修飾類初始化方法。
• 當子類含有異于父類的初始化方法時（初始化方法參數(shù)類型和數(shù)量異于父類），子類必須要實現(xiàn)父類的required初始化方法，并且也要使用required修飾符而不是override。
• 當子類沒有初始化方法時，可以不用實現(xiàn)父類的required初始化方法。

    class MyClass {
        var str:String
        required init(str:String) {
            self.str = str
        }
    }
    class MySubClass:MyClass
    {
        init(i:Int) {
            super.init(str:String(i))
        }
        
    }
    // 編譯錯誤
    MySubClass(i: 123)

會報錯，因為你沒有實現(xiàn)父類中必須實現(xiàn)的方法。正確的寫法：

    class MyClass {
        var str:String
        required init(str:String) {
            self.str = str
        }
    }
    class MySubClass:MyClass
    {
        init(i:Int) {
            super.init(str:String(i))
        }
        required init(str: String) {
            fatalError("init(str:) has not been implemented")
        }
    }
    // 編譯錯誤
    MySubClass(i: 123)

從上面的代碼中，不難看出子類需要添加異于父類的初始化方法，必須要重寫有required的修飾符的初始化方法，并且也要使用required修飾符而不是override，請千萬注意！

如果子類中并沒有不同于父類的初始化方法，Swift會默認使用父類的初始化方法:

class MyClass{
    var str: String?
    required init(str: String?) {
        self.str = str
    }
}
class MySubClass: MyClass{
}
var MySubClass(str: "hello swift")

在這種情況下，編譯器不會報錯，因為如果子類沒有任何初始化方法時，Swift會默認使用父類的初始化方法。

以#開頭的關(guān)鍵字

#available：基于平臺參數(shù)，通過 if，while，guard 語句的條件，在運行時檢查 API 的可用性。

if #available(iOS 10, *)  
{  
    print("iOS 10 APIs are available")  
}

#colorLiteral：在 playground 中使用的字面表達式，用于創(chuàng)建顏色選取器，選取后賦值給變量。

let aColor = #colorLiteral //創(chuàng)建顏色選取器

#column：一種特殊的字面量表達式，用于獲取字面量表示式的起始列數(shù)。

class Person  
{  
    func printInfo()  
    {  
        print("Some person info - on column \(#column)")
    }  
}

let aPerson = Person()  
aPerson.printInfo() //Some person info - on column 47

#function：特殊字面量表達式，返回函數(shù)名稱。在方法中，返回方法名。在屬性的 getter 或者 setter 中，返回屬性名。在特殊的成員中，比如 init 或 subscript 中，返回關(guān)鍵字名稱。在文件的最頂層時，返回當前所在模塊名稱。

class Person
{
    func printInfo()
    {
        print("Some person info - inside function \(#function)")
    }
}

let aPerson = Person()
aPerson.printInfo() //Some person info - inside function printInfo()

#line：特殊字面量表達式，用于獲取當前代碼的行數(shù)。

class Person  
{  
    func printInfo()  
    {  
        print("Some person info - on line number \(#line)")
    }  
}

let aPerson = Person()  
aPerson.printInfo() //Some person info - on line number 5

#selector：用于創(chuàng)建 Objective-C selector 的表達式，可以靜態(tài)檢查方法是否存在，并暴露給 Objective-C。

//靜態(tài)檢查，確保 doAnObjCMethod 方法存在  
control.sendAction(#selector(doAnObjCMethod), to: target, forEvent: event)

dynamic && @objc

@objc

OC 是基于運行時，遵循了 KVC 和動態(tài)派發(fā)，而 Swift 為了追求性能，在編譯時就已經(jīng)確定，而不需要在運行時的，在 Swift 類型文件中，為了解決這個問題，需要暴露給 OC 使用的任何地方（類，屬性，方法等）的生命前面加上 @objc 修飾符
如果用 Swift 寫的 class 是繼承 NSObject 的話， Swift 會默認自動為所有非 private 的類和成員加上@objc

在Swift中，我們在給button添加點擊事件時，對應(yīng)的點擊事件的觸發(fā)方法就需要用@objc來修飾

dynamic

Swift 中的函數(shù)可以是靜態(tài)調(diào)用，靜態(tài)調(diào)用會更快。當函數(shù)是靜態(tài)調(diào)用的時候，就不能從字符串查找到對應(yīng)的方法地址了。這樣 Swift 跟 Objective-C 交互時，Objective-C 動態(tài)查找方法地址，就有可能找不到 Swift 中定義的方法。

這樣就需要在 Swift 中添加一個提示關(guān)鍵字，告訴編譯器這個方法是可能被動態(tài)調(diào)用的，需要將其添加到查找表中。這個就是關(guān)鍵字 dynamic 的作用。

didSet

屬性觀察者，當值存儲到屬性后馬上調(diào)用。

var data = [1,2,3]  
{  
    didSet  
    {  
        tableView.reloadData()  
    }  
}

final

防止方法、屬性、下標被重寫。

final class Person {}  
class Programmer : Person {} //編譯錯誤
 

get

返回成員的值。還可以用在計算型屬性上，間接獲取其它屬性的值。

class Person  
{  
    var name:String  
    {  
        get { return self.name }  
        set { self.name = newValue}  
    }
 
    var indirectSetName:String  
    {  
        get  
        {  
            if let aFullTitle = self.fullTitle  
            {  
                return aFullTitle  
            }  
            return ""  
        }
 
        set (newTitle)  
        {  
            //如果沒有定義 newTitle，可以使用 newValue
            self.fullTitle = "(self.name) :(newTitle)"  
        }
    }  
}
 

infix

指明一個用于兩個值之間的運算符。如果一個全新的全局運算符被定義為 infix，還需要指定優(yōu)先級。

let twoIntsAdded = 2 + 3
 

indirect

指明在枚舉類型中，存在成員使用相同枚舉類型的實例作為關(guān)聯(lián)值的情況。

indirect enum Entertainment  
{  
    case eventType(String)  
    case oneEvent(Entertainment)  
    case twoEvents(Entertainment, Entertainment)  
}
 
let dinner = Entertainment.eventType("Dinner")  
let movie = Entertainment.eventType("Movie")
 
let dateNight = Entertainment.twoEvents(dinner, movie)
 

lazy

指明屬性的初始值，直到第一次被使用時，才進行初始化。

class Person  
{  
    lazy var personalityTraits = {  
        //昂貴的數(shù)據(jù)庫開銷  
        return ["Nice", "Funny"]  
    }()  
}
let aPerson = Person()  
aPerson.personalityTraits //當 personalityTraits 首次被訪問時，數(shù)據(jù)庫才開始工作

left

指明運算符的結(jié)合性是從左到右。在沒有使用大括號時，可以用于正確判斷同一優(yōu)先級運算符的執(zhí)行順序。

//"-" 運算符的結(jié)合性是從左到右
10-2-4 //根據(jù)結(jié)合性，可以看做 (10-2) - 4
 

mutating

允許在方法中修改結(jié)構(gòu)體或者枚舉實例的屬性值。

struct Person  
{  
    var job = ""
 
    mutating func assignJob(newJob:String)  
    {  
        self = Person(job: newJob)  
    }  
}
 
var aPerson = Person()  
aPerson.job //""
 
aPerson.assignJob(newJob: "iOS Engineer at Buffer")  
aPerson.job //iOS Engineer at Buffer
 

none

是一個沒有結(jié)合性的運算符。不允許這樣的運算符相鄰出現(xiàn)。

//"<" 是非結(jié)合性的運算符
1 < 2 < 3 //編譯失敗
 

nonmutating

指明成員的 setter 方法不會修改實例的值，但可能會有其它后果。

enum Paygrade  
{  
    case Junior, Middle, Senior, Master
 
    var experiencePay:String?  
    {  
        get  
        {  
            database.payForGrade(String(describing:self))  
        }
 
        nonmutating set  
        {  
            if let newPay = newValue  
            {  
                database.editPayForGrade(String(describing:self), newSalary:newPay)  
            }  
        }  
    }  
}
 
let currentPay = Paygrade.Middle
 
//將 Middle pay 更新為 45k, 但不會修改 experiencePay 值
currentPay.experiencePay = "$45,000"

optional

用于指明協(xié)議中的可選方法。遵守該協(xié)議的實體類可以不實現(xiàn)這個方法。

@objc protocol Foo  
{  
    func requiredFunction()  
    @objc optional func optionalFunction()  
}
 
class Person : Foo  
{  
    func requiredFunction()  
    {  
        print("Conformance is now valid")  
    }  
}

override

指明子類會提供自定義實現(xiàn)，覆蓋父類的實例方法、類型方法、實例屬性、類型屬性、下標。如果沒有實現(xiàn)，則會直接繼承自父類。

class Person  
{  
    func printInfo()  
    {  
        print("I'm just a person!")  
    }  
}
 
class Programmer : Person  
{  
    override func printInfo()  
    {  
        print("I'm a person who is a dev!")  
    }  
}
 
let aPerson = Person()  
let aDev = Programmer()
 
aPerson.printInfo() //打印 I'm just a person!  
aDev.printInfo() //打印 I'm a person who is a dev!

postfix

位于值后面的運算符。

var optionalStr:String? = "Optional"  
print(optionalStr!)

precedence

指明某個運算符的優(yōu)先級高于別的運算符，從而被優(yōu)先使用。

infix operator ~ { associativity right precedence 140 }  
4 ~ 8

prefix

位于值前面的運算符。

var anInt = 2  
anInt = -anInt //anInt 等于 -2
 

required

確保編譯器會檢查該類的所有子類，全部實現(xiàn)了指定的構(gòu)造器方法。

class Person  
{  
    var name:String?
 
    required init(_ name:String)  
    {  
        self.name = name  
    }  
}
 
class Programmer : Person  
{  
    //如果不實現(xiàn)這個方法，編譯不會通過
    required init(_ name: String)  
    {  
        super.init(name)  
    }  
}

right

指明運算符的結(jié)合性是從右到左的。在沒有使用大括號時，可以用于正確判斷同一優(yōu)先級運算符的順序。

//"??" 運算符結(jié)合性是從右到左
var box:Int?  
var sol:Int? = 2
 
let foo:Int = box ?? sol ?? 0 //Foo 等于 2
 

set

通過獲取的新值來設(shè)置成員的值。同樣可以用于計算型屬性來間接設(shè)置其它屬性。如果計算型屬性的 setter 沒有定義新值的名稱，可以使用默認的 newValue。

class Person  
{  
    var name:String  
    {  
        get { return self.name }  
        set { self.name = newValue}  
    }
 
    var indirectSetName:String  
    {  
        get  
        {  
            if let aFullTitle = self.fullTitle  
            {  
                return aFullTitle  
            }  
            return ""  
        }
 
        set (newTitle)  
        {  
            //如果沒有定義 newTitle，可以使用 newValue
            self.fullTitle = "(self.name) :(newTitle)"  
        }  
    }  
}
 

Type

表示任意類型的類型，包括類類型、結(jié)構(gòu)類型、枚舉類型、協(xié)議類型。

class Person {}  
class Programmer : Person {}
 
let aDev:Programmer.Type = Programmer.self

unowned

讓循環(huán)引用中的實例 A 不要強引用實例 B。前提條件是實例 B 的生命周期要長于 A 實例。

class Person  
{  
    var occupation:Job?  
}
 
//當 Person 實例不存在時，job 也不會存在。job 的生命周期取決于持有它的 Person。
class Job  
{  
    unowned let employee:Person
 
    init(with employee:Person)  
    {  
        self.employee = employee  
    }  
}

weak

允許循環(huán)引用中的實例 A 弱引用實例 B ，而不是強引用。實例 B 的生命周期更短，并會被先釋放。

class Person  
{  
    var residence:House?  
}
 
class House  
{  
    weak var occupant:Person?  
}
 
var me:Person? = Person()  
var myHome:House? = House()
 
me!.residence = myHome  
myHome!.occupant = me
 
me = nil  
myHome!.occupant // myHome 等于 nil
 

willSet

屬性觀察者，在值存儲到屬性之前調(diào)用。

class Person  
{  
    var name:String?  
    {  
        willSet(newValue) {print("I've got a new name, it's (newValue)!")}  
    }  
}
 
let aPerson = Person()  
aPerson.name = "Jordan" //在賦值之前，打印 "I've got a new name, it's Jordan!"

原文地址