Swift 集合类型协议浅析（下）

本文字数： 1964 字

预计阅读时间： 8分钟

本篇是Swift集合类型协议浅析系列文章的下篇，在这篇文章中，我们将继续围绕集合类型协议展开讨论，侧重点更多地关注于String相关的周边协议。

StringProtocol

代表一个字符串，这个字符串是由字符构成的集合，StringProtocol协议抽象了字符串的使用场景，比如 uppercased()、lowercased()、comparable和collection 等。在标准库中，只有String和SubString类型遵循StringProtocol协议，可以直接使用==对SubString和String进行判断，不需要类型转换。

1let helloSwift = "Hello Swift"
2let swift = helloSwift[helloSwift.index(helloSwift.startIndex, offsetBy: 6)...]
3
4// comparing a substring to a string
5swift == "Swift"  // true

也可以遍历substring，或者从substring截取子字符串。在标准库里也有一小部分函数使用StringProtocol类型作为参数。比如把一个字符串转换为整型就是： init(text: StringProtocol) 。虽然你可能不关心是string和substring，但是使用StringProtocol作为参数类型，调用者就不用进行类型转换，对他们会友好很多。

CustomStringConvertible & CustomDebugStringConvertible

来看一个例子：

 1struct BankCard {
 2    let bankName: String
 3    let cardNumber: Int
 4}
 5let bankcard = BankCard(bankName: "CBC",cardNumber: 123232324565)
 6// BankCard(bankName: "CBC", cardNumber: 123232324565)
 7
 8extension BankCard: CustomStringConvertible {
 9    var description: String {
10        return "\(self.bankName) \(self.cardNumber)"
11    }
12}
13print(bankcard)
14// CBC 123232324565

1extension BankCard: CustomDebugStringConvertible {
2    var debugDescription: String {
3        return """
4        BankName: \(self.bankName)
5        CardNumber: \(self.cardNumber)
6        """
7} }

dump

 1func dump(_ value: T, name: String? = nil, indent: Int = 0, maxDepth: Int = .max, maxItems: Int = .max) -> T
 2
 3/* * - T：是要打印的参数，是一个范型，也就是支持输出各种类型 
 4
 5* - name： 默认是空白，如果加上则会在打印内容前加入这个name
 6
 7* - indent：缩进，默认是0，如果设置则会向前缩进相应的空白 
 8
 9* - maxDepth：最大深度，默认全部打印，可以根据层级需要设置这个参数 
10
11* - maxItems：最大条数，默认是全部打印，如果需要限制内容，可以设置这个参数
12
13 */

 1let names = ["apple", "orange", "banana"]
 2dump(names)
 3
 4print(names)
 5
 6let iPhones = ["iPhoneX": 9688, "iPhone8 plus": 7888, "iphone8": 6888]
 7dump(iPhones)
 8
 9//输出
10/*
11▿ 3 elements
12  - "apple"
13  - "orange"
14  - "banana"
15["apple", "orange", "banana"]
16▿ 3 key/value pairs
17  ▿ (2 elements)
18    - key: "iPhoneX"
19    - value: 9688
20  ▿ (2 elements)
21    - key: "iPhone8 plus"
22    - value: 7888
23  ▿ (2 elements)
24    - key: "iphone8"
25    - value: 6888
26*/

LosslessStringConvertible

遵循此协议的类型，可以被转换为String，同时与此相反，可以再从String转换回原始类型，没有任何信息丢失；

 1extension FlightCode: LosslessStringConvertible {
 2    public init?(_ description: String) {
 3        let components = description.split(separator: " ")
 4        guard components.count == 2,
 5            let airlineCode = components.first,
 6            let number = components.last,
 7            let flightNumber = Int(number)
 8        else {
 9            return nil
10        }
11        self.airlineCode = String(airlineCode)
12        self.flightNumber = flightNumber
13    }
14}
15let flight = FlightCode(airlineCode: "AA",
16                        flightNumber: 1)
17
18String(flight)
19// "AA 1"
20
21FlightCode(String(flight))
22// FlightCode(airlineCode: "AA", flightNumber: 1)

ExpressibleByUnicodeScalarLiteral,ExpressibleByExtendedGraphemeClusterLiteral,ExpressibleByStringLiteral

String字面量使用引号表示，当封闭的值包含单个字符集群时，同样的语法也可以表示字符集群文字；当封闭的值包含单个字符值时，同样的语法也可以表示Unicode标量文字。

1// ExpressibleByUnicodeScalarLiteral 
2let unicodeScalar: Unicode.Scalar = "A"
3
4// ExpressibleByExtendedGraphemeClusterLiteral 
5let character: Character = "A"
6
7// ExpressibleByStringLiteral 
8let string: String = "A"

可扩展的字形集群

每一个Swift的Character类型实例都表示了单一的扩展字形集群。扩展字形集群是一个或者多个有序的Unicode标量（当组合起来时）产生的单个人类可读字符。举例来说，字母é以单个Unicode标量é(LATIN SMALL LETTER E WITH ACUTE，或者U+00E9)表示。总之，同样的字母也可以用一对标量——一个标准的字母e(LATINSMALL LETTER E，或者说U+0065)，以及COMBINING ACUTE ACCENT标量(U+0301)表示。COMBINING ACUTE ACCENT标量会以图形方式应用到它前边的标量上，当Unicode文本渲染系统渲染时，就会把e转换为é来输出。

在这两种情况中，字母é都会作为单独的Swift Character值以扩展字形集群来表示。在前者中，集群包含了一个单独的标量；后者，则是两个标量的集群。

1let eAcute: Character = "\u{E9}" // é
2let combinedEAcute: Character = "\u{65}\u{301}" // e followed by 
3// eAcute is é, combinedEAcute is é

扩展字形集群是一种非常灵活的把各种复杂脚本字符作为单一Character值来表示的方法。比如说韩文字母中的音节能被表示为复合和分解序列两种，这两种表示在Swift中都完全合格于单一Character值：

1let precomposed: Character = "\u{D55C}" // 한
2let decomposed: Character = "\u{1112}\u{1161}\u{11AB}" // ᄒ, ᅡ, ᆫ
3// precomposed is 한, decomposed is 한

继承关系：

所以初始化一个Unicode.Scalar通过包含多个scalar标量的字面量，或者多个字符字面量期望转成一个字符，都会失败。

1("ABC" as Unicode.Scalar) // Error
2("ABC" as Character) // Error

通过字面量初始化特定类型

 1extension URL: ExpressibleByStringLiteral {
 2    public init(stringLiteral value: String) {
 3        guard let url = URL(string: "\(value)") else {
 4            preconditionFailure("This url: \(value) is not invalid")
 5        }
 6        self = url
 7    }
 8}
 9
10let url:URL = "https://www.baidu.com"
11
12print(url)
13
14//let urls = URL.init(string: "https://www.baidu.com")

ExpressibleByStringInterpolation

字符串插值是Swift5的新特性；通常，字符串文字中的内插值被转换为字符串，使用String(describing:)；通过遵循ExpressibleBy

StringInterpolation协议（这个协议继承ExpressibleByStringLiteral），这个类型可以定义StringInterpolation通过字面量改变插值行为。

ExpressibleByStringLiteral

三个方法需要实现：

1init(stringLiteral value: String)
2init(extendedGraphemeClusterLiteral value: String)
3init(unicodeScalarLiteral value: String)

ExpressibleByStringInterpolation

1init(stringInterpolation: StringInterpolation)

参考：

[1].https://swift.gg/2019/04/22/swift5-stringinterpolation-part1/

[2].https://academy.realm.io/cn/posts/try-swift-soroush-khanlou-sequence-collection/

[3].https://swift.gg/2017/02/20/why-is-dictionary-not-a-mutablecollection/