翻譯:geek5nan 校對:dabing1022

協定


本頁包含內容:

Protocol(協定)用於統一方法和屬性的名稱,而不實作任何功能。協定能夠被類別,列舉,結構實作,滿足協定要求的類別,列舉,結構被稱為協定的遵循者

遵循者需要提供協定指定的成員,如屬性,方法,運算子,下標等。

協定的語法

協定的定義與類別,結構,列舉的定義非常相似,如下所示:

protocol SomeProtocol {
    // 協定內容
}

在類別,結構,列舉的名稱後加上協定名稱,中間以冒號:分隔即可實作協定;實作多個協定時,各協定之間用逗號,分隔,如下所示:

struct SomeStructure: FirstProtocol, AnotherProtocol {
    // 結構內容
}

當某個類別含有父類別的同時並實作了協定,應當把父類別放在所有的協定之前,如下所示:

class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol {
    // 類別的內容
}

屬性要求

協定能夠要求其遵循者必須含有一些特定名稱和型別實例屬性(instance property)類別屬性 (type property),也能夠要求屬性具有(設置權限)settable(存取權限)gettable,但它不要求屬性儲存型屬性(stored property)還是計算型屬性(calculate property)

如果協定要求屬性具有設置權限和存取權限,那常數儲存型屬性或者唯讀計算型屬性都無法滿足此要求。如果協定只要求屬性具有存取權限,那任何型別的屬性都可以滿足此要求,無論這些屬性是否具有設置權限。

通常前綴var關鍵字將屬性宣告為變數。在屬性宣告後寫上{ get set }表示屬性為可讀寫的。{ get }用來表示屬性為可讀的。即使你為可讀的屬性實作了setter方法,它也不會出錯。

protocol SomeProtocol {
    var musBeSettable : Int { get set }
    var doesNotNeedToBeSettable: Int { get }
}

用類別來實作協定時,使用class關鍵字來表示該屬性為類別成員;用結構或列舉實作協定時,則使用static關鍵字來表示:

protocol AnotherProtocol {
    class var someTypeProperty: Int { get set }
}

protocol FullyNamed {
    var fullName: String { get }
}

FullyNamed協定含有fullName屬性。因此其遵循者必須含有一個名為fullName,型別為String的可讀屬性。

struct Person: FullyNamed{
    var fullName: String
}
let john = Person(fullName: "John Appleseed")
//john.fullName 為 "John Appleseed"

Person結構含有一個名為fullName儲存型屬性,完整的遵循了協定。(若協定未被完整遵循,編譯時則會報錯)。

如下所示,Startship類別遵循FullyNamed協定:

class Starship: FullyNamed {
    var prefix: String?
    var name: String
    init(name: String, prefix: String? = nil ) {
        self.anme = name
        self.prefix = prefix
    }
    var fullName: String {
    return (prefix ? prefix ! + " " : " ") + name
    }
}
var ncc1701 = Starship(name: "Enterprise", prefix: "USS")
// ncc1701.fullName == "USS Enterprise"

Starship類別將fullName實作為可讀的計算型屬性。它的每一個實例都有一個名為name的必備屬性和一個名為prefix的可選屬性。 當prefix存在時,將prefix插入到name之前來為Starship構建fullName

方法要求

協定能夠要求其遵循者必備某些特定的實例方法類別方法。協定方法的宣告與普通方法宣告相似,但它不需要方法內容。

注意: 協定方法支援變長參數(variadic parameter),不支援預設參數(default parameter)

前綴class關鍵字表示協定中的成員為類別成員;當協定用於被列舉結構遵循時,則使用static關鍵字。如下所示:

protocol SomeProtocol {
    class func someTypeMethod()
}

protocol RandomNumberGenerator {
    func random() -> Double
}

RandomNumberGenerator協定要求其遵循者必須擁有一個名為random, 回傳值型別為Double的實例方法。(我們假設隨機數在[0,1]區間內)。

LinearCongruentialGenerator類別遵循RandomNumberGenerator協定,並提供了一個叫做線性同余生成器(linear congruential generator)的偽隨機數算法。

class LinearCongruentialGenerator: RandomNumberGenerator {
    var lastRandom = 42.0
    let m = 139968.0
    let a = 3877.0
    let c = 29573.0
    func random() -> Double {
        lastRandom = ((lastRandom * a + c) % m)
        return lastRandom / m
    }
}
let generator = LinearCongruentialGenerator()
println("Here's a random number: \(generator.random())")
// 輸出 : "Here's a random number: 0.37464991998171"
println("And another one: \(generator.random())")
// 輸出 : "And another one: 0.729023776863283"

突變方法要求

能在方法函式內部改變實例型別的方法稱為突變方法。在值型別(Value Type)(譯者注:特指結構和列舉)中的的函式前綴加上mutating關鍵字來表示該函式允許改變該實例和其屬性的型別。 這一變換過程在實例方法(Instance Methods)章節中有詳細描述。

(譯者注:類別中的成員為參考型別(Reference Type),可以方便的修改實例及其屬性的值而無需改變型別;而結構列舉中的成員均為值型別(Value Type),修改變數的值就相當於修改變數的型別,而Swift預設不允許修改型別,因此需要前綴mutating關鍵字用來表示該函式中能夠修改型別)

注意: 用class實作協定中的mutating方法時,不用寫mutating關鍵字;用結構列舉實作協定中的mutating方法時,必須寫mutating關鍵字。

如下所示,Togglable協定含有toggle函式。根據函式名稱推測,toggle可能用於切換或恢復某個屬性的狀態。mutating關鍵字表示它為突變方法

protocol Togglable {
    mutating func toggle()
}

當使用列舉結構來實作Togglabl協定時,必須在toggle方法前加上mutating關鍵字。

如下所示,OnOffSwitch列舉遵循Togglable協定,OnOff兩個成員用於表示當前狀態

enum OnOffSwitch: Togglable {
    case Off, On
    mutating func toggle() {
        switch self {
        case Off:
            self = On
        case On:
            self = Off
        }
    }
}
var lightSwitch = OnOffSwitch.Off
lightSwitch.toggle()
//lightSwitch 現在的值為 .On

協定型別

協定本身不實作任何功能,但你可以將它當做型別來使用。

使用場景:

  • 作為函式,方法或建構器中的參數型別,回傳值型別
  • 作為常數,變數,屬性的型別
  • 作為陣列,字典或其他容器中的元素型別

注意: 協定型別應與其他型別(Int,Double,String)的寫法相同,使用駝峰式

class Dice {
    let sides: Int
    let generator: RandomNumberGenerator
    init(sides: Int, generator: RandomNumberGenerator) {
        self.sides = sides
        self.generator = generator
    }
    func roll() -> Int {
        return Int(generator.random() * Double(sides)) +1
    }
}

這裡定義了一個名為 Dice的類別,用來代表桌游中的N個面的骰子。

Dice含有sidesgenerator兩個屬性,前者用來表示骰子有幾個面,後者為骰子提供一個隨機數生成器。由於後者為RandomNumberGenerator的協定型別。所以它能夠被賦值為任意遵循該協定的型別。

此外,使用建構器(init)來代替之前版本中的setup操作。建構器中含有一個名為generator,型別為RandomNumberGenerator的形參,使得它可以接收任意遵循RandomNumberGenerator協定的型別。

roll方法用來模擬骰子的面值。它先使用generatorrandom方法來創建一個[0-1]區間內的隨機數種子,然後加工這個隨機數種子生成骰子的面值。

如下所示,LinearCongruentialGenerator的實例作為隨機數生成器傳入Dice建構器

var d6 = Dice(sides: 6,generator: LinearCongruentialGenerator())
for _ in 1...5 {
    println("Random dice roll is \(d6.roll())")
}
//輸出結果
//Random dice roll is 3
//Random dice roll is 5
//Random dice roll is 4
//Random dice roll is 5
//Random dice roll is 4

委托(代理)模式

委托是一種設計模式,它允許類別或結構將一些需要它們負責的功能交由(委托)給其他的型別。

委托模式的實作很簡單: 定義協定封裝那些需要被委托的函式和方法, 使其遵循者擁有這些被委托的函式和方法

委托模式可以用來響應特定的動作或接收外部資料源提供的資料,而無需要知道外部資料源的型別。

下文是兩個基於骰子遊戲的協定:

protocol DiceGame {
    var dice: Dice { get }
    func play()
}

protocol DiceGameDelegate {
    func gameDidStart(game: DiceGame)
    func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll:Int)
    func gameDidEnd(game: DiceGame)
}

DiceGame協定可以在任意含有骰子的遊戲中實作,DiceGameDelegate協定可以用來追蹤DiceGame的遊戲過程。

如下所示,SnakesAndLaddersSnakes and Ladders(譯者注:控制流程章節有該遊戲的詳細介紹)遊戲的新版本。新版本使用Dice作為骰子,並且實作了DiceGameDiceGameDelegate協定

class SnakesAndLadders: DiceGame {
    let finalSquare = 25
    let dic = Dice(sides: 6, generator: LinearCongruentialGenerator())
    var square = 0
    var board: Int[]
    init() {
        board = Int[](count: finalSquare + 1, repeatedValue: 0)
        board[03] = +08; board[06] = +11; borad[09] = +09; board[10] = +02
        borad[14] = -10; board[19] = -11; borad[22] = -02; board[24] = -08
    }
     var delegate: DiceGameDelegate?
     func play() {
         square = 0
         delegate?.gameDidStart(self)
         gameLoop: while square != finalSquare {
             let diceRoll = dice.roll()
             delegate?.game(self,didStartNewTurnWithDiceRoll: diceRoll)
             switch square + diceRoll {
             case finalSquare:
                 break gameLoop
             case let newSquare where newSquare > finalSquare:
                 continue gameLoop
             default:
             square += diceRoll
             square += board[square]
             }
         }
         delegate?.gameDIdEnd(self)
     }
}

遊戲的初始化設置(setup)SnakesAndLadders類別的建構器(initializer)實作。所有的遊戲邏輯被轉移到了play方法中。

注意: 因為delegate並不是該遊戲的必備條件,delegate被定義為遵循DiceGameDelegate協定的可選屬性

DicegameDelegate協定提供了三個方法用來追蹤遊戲過程。被放置於遊戲的邏輯中,即play()方法內。分別在遊戲開始時,新一輪開始時,遊戲結束時被呼叫。

因為delegate是一個遵循DiceGameDelegate的可選屬性,因此在play()方法中使用了可選鏈來呼叫委托方法。 若delegate屬性為nil, 則委托呼叫優雅地失效。若delegate不為nil,則委托方法被呼叫

如下所示,DiceGameTracker遵循了DiceGameDelegate協定

class DiceGameTracker: DiceGameDelegate {
    var numberOfTurns = 0
    func gameDidStart(game: DiceGame) {
        numberOfTurns = 0
        if game is SnakesAndLadders {
            println("Started a new game of Snakes and Ladders")
        }
        println("The game is using a \(game.dice.sides)-sided dice")
    }
    func game(game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) {
        ++numberOfTurns
        println("Rolled a \(diceRoll)")
    }
    func gameDidEnd(game: DiceGame) {
        println("The game lasted for \(numberOfTurns) turns")
    }
}

DiceGameTracker實作了DiceGameDelegate協定的方法要求,用來記錄遊戲已經進行的輪數。 當遊戲開始時,numberOfTurns屬性被賦值為0;在每新一輪中遞加;遊戲結束後,輸出列印遊戲的總輪數。

gameDidStart方法從game參數獲取遊戲資訊並輸出。game在方法中被當做DiceGame型別而不是SnakeAndLadders型別,所以方法中只能存取DiceGame協定中的成員。

DiceGameTracker的執行情況,如下所示:

let tracker = DiceGameTracker()
let game = SnakesAndLadders()
game.delegate = tracker
game.play()
// Started a new game of Snakes and Ladders
// The game is using a 6-sided dice
// Rolled a 3
// Rolled a 5
// Rolled a 4
// Rolled a 5
// The game lasted for 4 turns

在擴展中添加協定成員

即便無法修改源程式碼,依然可以通過擴展(Extension)來擴充已存在型別(譯者注: 類別,結構,列舉等)。擴展可以為已存在的型別添加屬性方法下標協定等成員。詳情請在擴展章節中查看。

注意: 通過擴展為已存在的型別遵循協定時,該型別的所有實例也會隨之添加協定中的方法

TextRepresentable協定含有一個asText,如下所示:

protocol TextRepresentable {
    func asText() -> String
}

通過擴展為上一節中提到的Dice類別遵循TextRepresentable協定

extension Dice: TextRepresentable {
    cun asText() -> String {
        return "A \(sides)-sided dice"
    }
}

從現在起,Dice型別的實例可被當作TextRepresentable型別:

let d12 = Dice(sides: 12,generator: LinearCongruentialGenerator())
println(d12.asText())
// 輸出 "A 12-sided dice"

SnakesAndLadders類別也可以通過擴展的方式來遵循協定:

extension SnakeAndLadders: TextRepresentable {
    func asText() -> String {
        return "A game of Snakes and Ladders with \(finalSquare) squares"
    }
}
println(game.asText())
// 輸出 "A game of Snakes and Ladders with 25 squares"

通過擴展補充協定宣告

當一個型別已經實作了協定中的所有要求,卻沒有宣告時,可以通過擴展來補充協定宣告:

struct Hamster {
    var name: String
    func asText() -> String {
        return "A hamster named \(name)"
    }
}
extension Hamster: TextRepresentabl {}

從現在起,Hamster的實例可以作為TextRepresentable型別使用

let simonTheHamster = Hamster(name: "Simon")
let somethingTextRepresentable: TextRepresentabl = simonTheHamester
println(somethingTextRepresentable.asText())
// 輸出 "A hamster named Simon"

注意: 即時滿足了協定的所有要求,型別也不會自動轉變,因此你必須為它做出明顯的協定宣告

集合中的協定型別

協定型別可以被集合使用,表示集合中的元素均為協定型別:

let things: TextRepresentable[] = [game,d12,simoTheHamster]

如下所示,things陣列可以被直接遍歷,並呼叫其中元素的asText()函式:

for thing in things {
    println(thing.asText())
}
// A game of Snakes and Ladders with 25 squares
// A 12-sided dice
// A hamster named Simon

thing被當做是TextRepresentable型別而不是DiceDiceGameHamster等型別。因此能且僅能呼叫asText方法

協定的繼承

協定能夠繼承一到多個其他協定。語法與類別的繼承相似,多個協定間用逗號,分隔

protocol InheritingProtocol: SomeProtocol, AnotherProtocol {
    // 協定定義
}

如下所示,PrettyTextRepresentable協定繼承了TextRepresentable協定

protocol PrettyTextRepresentable: TextRepresentable {
    func asPrettyText() -> String
}

遵循``PrettyTextRepresentable協定的同時,也需要遵循TextRepresentable`協定。

如下所示,用擴展SnakesAndLadders遵循PrettyTextRepresentable協定:

extension SnakesAndLadders: PrettyTextRepresentable {
    func asPrettyText() -> String {
        var output = asText() + ":\n"
        for index in 1...finalSquare {
            switch board[index] {
                case let ladder where ladder > 0:
                output += "▲ "
            case let snake where snake < 0:
                output += "▼ "
            default:
                output += "○ "
            }
        }
        return output
    }
}

for in中迭代出了board陣列中的每一個元素:

  • 當從陣列中迭代出的元素的值大於0時,用表示
  • 當從陣列中迭代出的元素的值小於0時,用表示
  • 當從陣列中迭代出的元素的值等於0時,用表示

任意SankesAndLadders的實例都可以使用asPrettyText()方法。

println(game.asPrettyText())
// A game of Snakes and Ladders with 25 squares:
// ○ ○ ▲ ○ ○ ▲ ○ ○ ▲ ▲ ○ ○ ○ ▼ ○ ○ ○ ○ ▼ ○ ○ ▼ ○ ▼ ○

協定合成

一個協定可由多個協定采用protocol<SomeProtocol, AnotherProtocol>這樣的格式進行組合,稱為協定合成(protocol composition)

舉個範例:

protocol Named {
    var name: String { get }
}
protocol Aged {
    var age: Int { get }
}
struct Person: Named, Aged {
    var name: String
    var age: Int
}
func wishHappyBirthday(celebrator: protocol<Named, Aged>) {
    println("Happy birthday \(celebrator.name) - you're \(celebrator.age)!")
}
let birthdayPerson = Person(name: "Malcolm", age: 21)
wishHappyBirthday(birthdayPerson)
// 輸出 "Happy birthday Malcolm - you're 21!

Named協定包含String型別的name屬性;Aged協定包含Int型別的age屬性。Person結構遵循了這兩個協定。

wishHappyBirthday函式的形參celebrator的型別為protocol<Named,Aged>。可以傳入任意遵循這兩個協定的型別的實例

注意: 協定合成並不會生成一個新協定型別,而是將多個協定合成為一個臨時的協定,超出範圍後立即失效。

檢驗協定的一致性

使用is檢驗協定一致性,使用as將協定型別向下轉換(downcast)為的其他協定型別。檢驗與轉換的語法和之前相同(詳情查看型別檢查):

  • is運算子用來檢查實例是否遵循了某個協定
  • as?回傳一個可選值,當實例遵循協定時,回傳該協定型別;否則回傳nil
  • as用以強制向下轉換型。
@objc protocol HasArea {
    var area: Double { get }
}

注意: @objc用來表示協定是可選的,也可以用來表示暴露給Objective-C的程式碼,此外,@objc型協定只對類別有效,因此只能在類別中檢查協定的一致性。詳情查看Using Siwft with Cocoa and Objectivei-c

class Circle: HasArea {
    let pi = 3.1415927
    var radius: Double
    var area:≈radius }
    init(radius: Double) { self.radius = radius }
}
class Country: HasArea {
    var area: Double
    init(area: Double) { self.area = area }
}

CircleCountry都遵循了HasArea協定,前者把area寫為計算型屬性(computed property),後者則把area寫為儲存型屬性(stored property)。

如下所示,Animal類別沒有實作任何協定

class Animal {
    var legs: Int
    init(legs: Int) { self.legs = legs }
}

Circle,Country,Animal並沒有一個相同的基類別,所以采用AnyObject型別的陣列來裝載在它們的實例,如下所示:

let objects: AnyObject[] = [
    Circle(radius: 2.0),
    Country(area: 243_610),
    Animal(legs: 4)
]

如下所示,在迭代時檢查object陣列的元素是否遵循HasArea協定:

for object in objects {
    if let objectWithArea = object as? HasArea {
        println("Area is \(objectWithArea.area)")
    } else {
        println("Something that doesn't have an area")
    }
}
// Area is 12.5663708
// Area is 243610.0
// Something that doesn't have an area

當陣列中的元素遵循HasArea協定時,通過as?運算子將其可選綁定(optional binding)objectWithArea常數上。

objects陣列中元素的型別並不會因為向下轉型而改變,當它們被賦值給objectWithArea時只被視為HasArea型別,因此只有area屬性能夠被存取。

可選協定要求

可選協定含有可選成員,其遵循者可以選擇是否實作這些成員。在協定中使用@optional關鍵字作為前綴來定義可選成員。

可選協定在呼叫時使用可選鏈,詳細內容在可選鏈章節中查看。

someOptionalMethod?(someArgument)一樣,你可以在可選方法名稱後加上?來檢查該方法是否被實作。可選方法可選屬性都會回傳一個可選值(optional value),當其不可存取時,?之後語句不會執行,並回傳nil

注意: 可選協定只能在含有@objc前綴的協定中生效。且@objc的協定只能被類別遵循。

Counter類別使用CounterDataSource型別的外部資料源來提供增量值(increment amount),如下所示:

@objc protocol CounterDataSource {
    @optional func incrementForCount(count: Int) -> Int
    @optional var fixedIncrement: Int { get }
}

CounterDataSource含有incrementForCount可選方法fiexdIncrement可選屬性

注意: CounterDataSource中的屬性和方法都是可選的,因此可以在類別中宣告但不實作這些成員,儘管技術上允許這樣做,不過最好不要這樣寫。

Counter類別含有CounterDataSource?型別的可選屬性dataSource,如下所示:

@objc class Counter {
    var count = 0
    var dataSource: CounterDataSource?
    func increment() {
        if let amount = dataSource?.incrementForCount?(count) {
            count += amount
        } else if let amount = dataSource?.fixedIncrement? {
            count += amount
        }
    }
}

count屬性用於儲存當前的值,increment方法用來為count賦值。

increment方法通過可選鏈,嘗試從兩種可選成員中獲取count

  1. 由於dataSource可能為nil,因此在dataSource後邊加上了?標記來表明只在dataSource非空時才去呼叫incrementForCount`方法。
  2. 即使dataSource存在,但是也無法保證其是否實作了incrementForCount方法,因此在incrementForCount方法後邊也加有?標記。

在呼叫incrementForCount方法後,Int可選值通過可選綁定(optional binding)自動拆包並賦值給常數amount

incrementForCount不能被呼叫時,嘗試使用可選屬性``fixedIncrement來代替。

ThreeSource實作了CounterDataSource協定,如下所示:

class ThreeSource: CounterDataSource {
    let fixedIncrement = 3
}

使用ThreeSource作為資料源開實例化一個Counter

var counter = Counter()
counter.dataSource = ThreeSource()
for _ in 1...4 {
    counter.increment()
    println(counter.count)
}
// 3
// 6
// 9
// 12

TowardsZeroSource實作了CounterDataSource協定中的incrementForCount方法,如下所示:

class TowardsZeroSource: CounterDataSource {
func incrementForCount(count: Int) -> Int {
        if count == 0 {
            return 0
        } else if count < 0 {
            return 1
        } else {
            return -1
        }
    }
}

下邊是執行的程式碼:

counter.count = -4
counter.dataSource = TowardsZeroSource()
for _ in 1...5 {
    counter.increment()
    println(counter.count)
}
// -3
// -2
// -1
// 0
// 0