SwiftUI 学习笔记 11：协议和扩展

协议和面向协议的编程（POP）。

POP消除了大型，复杂的继承层次结构，并用可以组合在一起的更小，更简单的协议代替了它们。这确实是Tony Hoare多年前说的话的实现：“在每个大型程序中，都有一个小型程序试图退出。”

协议

协议是描述某物必须具有的属性和方法的一种方式。然后，你可以告诉Swift哪些类型使用该协议-这一过程称为采用或遵循协议。

例如，我们可以编写一个可以接受带有id属性的东西的函数，但是我们并不在乎使用什么类型的数据。我们将从创建一个Identifiable协议，该协议将要求所有符合条件的类型都具有一个id可以读取（“ get”）或写入（“ set”）的字符串：

1
2
3

protocol Identifiable {
    var id: String { get set }
}

我们无法创建该协议的实例-它是描述，而不是类型本身。但是我们可以创建一个符合它的结构：

1
2
3

struct User: Identifiable {
    var id: String
}

最后，我们将编写一个displayID()接受任何Identifiable对象的函数：

1
2
3

func displayID(thing: Identifiable) {
    print("My ID is \(thing.id)")
}

其他例子：

protocol Zhhoo{
    var url: String {get set}
}

struct Hooweb: Zhhoo {
    var url: String
}

func tozhhoo(adr: Zhhoo){
    print("Let's go to the \(adr.url) !")
}

var hooto = Hooweb(url: "zhhooo.com")
tozhhoo(adr: hooto)

其他例子：

protocol SuitableForKids {
	var minimumAge: Int { get set }
	var maximumAge: Int { get set }
}
protocol SupportsMultiplePlayers {
	var minimumPlayers: Int { get set }
	var maximumPlayers: Int { get set }
}
struct FamilyBoardGame: SuitableForKids, SupportsMultiplePlayers {
	var minimumAge = 3
	var maximumAge = 110
	var minimumPlayers = 1
	var maximumPlayers = 4
}

注意：
协议不能只设置仅set属性，允许仅get或者get set。

继承协议

协议可以被继承。与类不同，在顶部添加自己的自定义项之前，你可以同时从多个协议继承。

我们将定义三种协议：Payable需要使用符合类型的calculateWages()方法来实现方法，NeedsTraining需要使用符合类型的study()方法来实现方法以及HasVacation需要使用符合类型的takeVacation()方法来实现方法：

protocol Payable {
    func calculateWages() -> Int
}

protocol NeedsTraining {
    func study()
}

protocol HasVacation {
    func takeVacation(days: Int)
}

现在，我们可以创建一个Employee协议，将它们组合成一个协议。我们不需要在顶部添加任何内容，因此我们只需要写大括号即可：

1	protocol Employee: Payable, NeedsTraining, HasVacation { }

现在，我们可以使新类型符合该单一协议，而不是三个单独协议中的每个。

其他例子：

protocol Zhhoo {
    func towebsite() -> Int
}

protocol Chrome {
    func url()
}

protocol Mac {
    func link()
}

protocol go: Zhhoo,Chrome,Mac {}

其他例子：

protocol CarriesPassengers {
	var passengerCount: Int { get set }
}
protocol CarriesCargo {
	var cargoCapacity: Int { get set }
}
protocol Boat: CarriesPassengers, CarriesCargo {
	var name: String { get set }
}

扩展

扩展允许你向现有类型添加方法，以使它们执行原本不是设计要执行的操作。

例如，我们可以在Int类型中添加扩展名，以便它具有squared()返回当前数字乘以自身的方法，利用extension：

extension Int {
    func squared() -> Int {
        return self * self
    }
}

要尝试该方法，只需创建一个整数，你将看到它现在有一个squared()方法：

1 2	let number = 8 number.squared()

Swift不允许你在扩展中添加存储的属性，因此必须改用计算属性。例如，我们可以isEven向整数添加一个新的计算属性，如果该属性包含偶数，则返回true：

extension Int {
    var isEven: Bool {
        return self % 2 == 0
    }
}

其他例子：

extension String {
    mutating func append(_ other: String) {
        self += other
    }
}

var web = "https://"
web.append("zhhooo.com")
print(web)

其他例子：

extension Bool {
    func toggled() -> Bool {
        if self == true {
            return false
        } else {
            return true
        }
    }
}

var web = true
web.toggled()

其他例子：

extension Int {
	func clamped(min: Int, max: Int) -> Int {
		if (self > max) {
			return max
		} else if (self < min) {
			return min
		}
		return self
        
	}
}

协议扩展

协议可让你描述某物应具有的方法，但不提供内部代码。扩展使你可以在方法内部提供代码，但只影响一种数据类型–你不能同时将方法添加到许多类型中。

协议扩展解决了这两个问题：它们类似于常规扩展，除了扩展特定Int协议（如扩展整个协议）以使所有符合条件的类型都可以进行更改外，它们都可以扩展。

例如，这是一个数组和一个包含一些名称的集合：

1 2	let pythons = ["Eric", "Graham", "John", "Michael", "Terry", "Terry"] let beatles = Set(["John", "Paul", "George", "Ringo"])

Swift的数组和集合都符合称为的协议Collection，因此我们可以对该协议编写一个扩展，以添加一种summarize()方法来整齐地打印集合

extension Collection {
    func summarize() {
        print("There are \(count) of us:")

        for name in self {
            print(name)
        }
    }
}

无论Array和Set现在有一个方法，所以我们可以尝试一下：

1 2	pythons.summarize() beatles.summarize()

其他例子：

protocol Politician {
	var isDirty: Bool { get set }
	func takeBribe()
}
extension Politician {
	func takeBribe() {
		if isDirty {
			print("Thank you very much!")
		} else {
			print("Someone call the police!")
		}
	}
}

其他例子：

protocol Anime {
	var availableLanguages: [String] { get set }
	func watch(in language: String)
}
extension Anime {
	func watch(in language: String) {
		if availableLanguages.contains(language) {
			print("Now playing in \(language)")
		} else {
			print("Unrecognized language.")
		}
	}
}

其他例子：

protocol Mammal {
	func eat()
}
extension Mammal {
	func eat() {
		print("Time for dinner!")
	}
}

面向协议的编程

协议扩展可以为我们自己的协议方法提供默认实现。这使类型很容易符合协议，并允许使用一种称为“面向协议的编程”的技术–围绕协议和协议扩展来编写代码。

首先，这是一个称为的协议Identifiable，它要求任何符合条件的类型都具有id属性和identify()方法：

protocol Identifiable {
    var id: String { get set }
    func identify()
}

我们可以使每个符合条件的类型都编写自己的identify()方法，但是协议扩展允许我们提供默认值：

extension Identifiable {
    func identify() {
        print("My ID is \(id).")
    }
}

现在，当我们创建一个符合Identifiable它的类型时，它会identify()自动获取：

struct User: Identifiable {
    var id: String
}

let twostraws = User(id: "twostraws")
twostraws.identify()

总结

协议描述了一致性类型必须具有的方法和属性，但未提供这些方法的实现。
你可以在类似于类的其他协议之上构建协议。
扩展允许你将方法和计算属性添加到特定类型，例如Int。
协议扩展使你可以向协议添加方法和计算的属性。
面向协议的编程是一种将应用程序体系结构设计为一系列协议，然后使用协议扩展来提供默认方法实现的实践。

参考资料

查看下一天的SwiftUI学习笔记

关于100days英文课程