1. Algorithm: 每周至少做一个 LeetCode 的算法题

笔者的文章：

算法：二分法求平方根Sqrt(x)

题目

69. Sqrt(x)

Given a non-negative integer x, compute and return the square root of x.



Since the return type is an integer, the decimal digits are truncated, and only the integer part of the result is returned.



Example 1:



Input: x = 4
Output: 2



Example 2:



Input: x = 8
Output: 2



Explanation: The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned.

Constraints:

0 <= x <= 2^31 - 1



解题

二分法查找，平方小于等于x，则mid值有可能为最终结果，left = mid + 1；否则 right = mid - 1； 除法取整数，



    def mySqrt1(self, x: int) -> int:
        l, r, result = 0, x, x
        while l <= r:
            mid = l + (r - l) // 2
            midPlus = mid * mid
            if midPlus <= x:
                l = mid + 1
                result = mid
            else:
                r = mid - 1
        return result



下面这种接法也可以

class Solution:
    def mySqrt(self, x: int) -> int:
        l, r = 0, x
        while l <= r:
            mid = l + (r - l) // 2
            midPlus = mid * mid
            if midPlus <= x < (mid + 1) * (mid + 1):
                return mid
            elif midPlus > x:
                r = mid - 1
            else:
                l = mid + 1



Python中获取两数相除的商和余数

方法一：可以使用//求取两数相除的商、%求取两数相除的余数。[/在Python中获取的是相除的结果，一般为浮点数]

方法二：使用divmod()函数，获取商和余数组成的元祖



#!/usr/bin/python3
# -*- coding: utf-8 -*- 
a = 10
b = 4
div = a // b 
mod = a % b 
print("{} / {} = {} ... {}".format(a, b, div, mod))
print("{} / {} = {} ... {}".format(a, b, *divmod(a, b)))
# print
# 10 / 4 = 2 ... 2
# 10 / 4 = 2 ... 2



参考

https://blog.csdn.net/dfq12345/article/details/78198797



2. Review: 阅读并点评至少一篇英文技术文章

笔者博客：

翻译：Swift 5.1中的Protocol面向协议的编程教程：从入门到精通

说明

在此面向协议protocol的编程教程中，您将学习有关扩展extensions，默认实现和其他将抽象添加到代码中的技术。



协议是Swift的基本功能。它们在Swift标准库的结构中起着主导作用，并且是一种常见的抽象方法。它们为某些其他语言提供的界面提供了类似的体验。



本教程将向您介绍称为面向协议的编程的软件工程实践，这已成为Swift的基础。如果您正在学习Swift，这确实是您需要掌握的东西！



在本教程中，您将了解：



• 面向对象的编程和面向协议的编程之间的区别。

• 具有默认实现的协议。

• 扩展Swift标准库。

• 使用泛型进一步扩展协议。



你在等什么？是时候启动您的Swift引擎了！



1. 入门

假设您正在开发赛车视频游戏。您希望玩家能够驾驶汽车，骑摩托车和驾驶飞机。他们甚至可以骑不同的鸟（因为这是电子游戏），您可以随心所欲地驾驶！这里的关键是可以驱动或操纵许多不同的“事物”。



此类应用程序的一种常见方法是面向对象的编程，您可以在其中封装所有逻辑，然后将其继承给其他类。基本类中将包含“驱动”和“飞行员”逻辑。



您可以通过为每种车辆创建类来开始对游戏进行编程。现在在鸟概念中添加图钉。您稍后将进行处理。



在编写代码时，您会注意到Car并Motorcycle共享一些功能，因此创建了一个名为的基类MotorVehicle并将其添加到其中。Car并Motorcycle再继承MotorVehicle。您也设计称为基类Aircraft是Plane从继承。



您认为，“这很好。” 可是等等！您的赛车游戏设定为30XX年，有些汽车可以飞行。



现在，您面临困境。Swift不支持多重继承。您的飞行汽车如何从MotorVehicle和两者继承Aircraft？您是否创建了另一个合并了两个功能的基类？可能不是，因为没有干净简便的方法可以做到这一点。



谁能从这场灾难性的困境中拯救您的赛车游戏？面向协议Protocol的编程可以解救！

1.1 为什么要进行面向协议的编程？

协议允许您将相似的方法，功能和属性分组。斯威夫特，您可以指定这些接口的保证class，struct和enum类型。只有class类型可以使用基类和继承。



Swift中协议的优点是对象可以符合多种协议。



以这种方式编写应用程序时，您的代码将变得更加模块化。将协议视为功能的构建块。通过使对象符合协议来添加新功能时，不会构建一个全新的对象。那很费时间。而是，添加不同的构造块，直到对象准备就绪为止。



将基类转换为协议可以解决您的视频游戏难题。使用协议，您可以创建FlyingCar同时符合MotorVehicle和的类Aircraft。整洁吧？



是时候动手操作了，并尝试了这个赛车概念。



2. 实战

2.1 首先打开Xcode，然后创建一个名为SwiftProtocols.playground的新游乐场。



然后添加以下代码：

protocol Bird {
  var name: String { get }
  var canFly: Bool { get }
}
protocol Flyable {
  var airspeedVelocity: Double { get }
}

使用Command-Shift-Return建立游乐场，以确保其正确编译。



这段代码定义了一个简单的协议Bird，带有属性name和canFly。然后定义一个名为的协议Flyable，该协议具有属性airspeedVelocity。



在过去的协议时代，开发人员将以Flyable基类作为开始，然后依靠对象继承来定义Bird和运行其他所有东西。



但是在面向协议的编程中，一切都从协议开始。此技术使您可以封装功能概念，而无需基类。



如您所见，这在定义类型时使整个系统更加灵活。

2.2 定义符合协议的类型

首先struct在运动场的底部添加以下定义：



struct FlappyBird: Bird, Flyable {
  let name: String
  let flappyAmplitude: Double
  let flappyFrequency: Double
  let canFly = true
  var airspeedVelocity: Double {
    3 * flappyFrequency * flappyAmplitude
  }
}

这段代码定义了一个新的struct名称FlappyBird，该名称同时符合Bird和Flyable协议。它airspeedVelocity是包含flappyFrequency和的计算属性flappyAmplitude。作为飞扬的，它返回true的canFly。



2.3 接下来，struct在运动场的底部添加以下两个定义：



struct Penguin: Bird {
  let name: String
  let canFly = false
}
struct SwiftBird: Bird, Flyable {
  var name: String { "Swift \(version)" }
  let canFly = true
  let version: Double
  private var speedFactor = 1000.0
  
  init(version: Double) {
    self.version = version
  }
  // Swift is FASTER with each version!
  var airspeedVelocity: Double {
    version * speedFactor
  }
}

Penguin是Bird，但不能飞行。好东西，您没有采用继承方法，而是制作了所有鸟Flyable！



使用协议，您可以定义功能组件并使任何相关对象符合它们。



然后您进行声明SwiftBird，但是在我们的游戏中有的不同版本SwiftBird。该version属性越高，其airspeedVelocity由计算属性定义的速度越快。



但是，您会看到有冗余。每种类型的项Bird都必须声明它是否存在，canFly即使Flyable您的系统中已经存在一个概念。几乎就像您需要一种定义协议方法的默认实现的方法一样。嗯，这就是协议扩展的用武之地。



2.4 使用默认实现扩展协议

协议扩展允许您定义协议的默认行为。要实现第一个，请在Bird协议定义下方插入以下内容：



extension Bird {
  // Flyable birds can fly!
  var canFly: Bool { self is Flyable }
}

此代码在上定义了扩展名Bird。它将默认行为设置为在类型符合协议时canFly返回。换句话说，任何鸟都不再需要显式声明它。它会像大多数鸟类一样飞翔。trueFlyableFlyablecanFly



现在删除let canFly = ...的FlappyBird，Penguin和SwiftBird。再次建造游乐场。您会注意到，游乐场仍然可以成功构建，因为协议扩展现在可以满足该要求。



2.5 枚举也可以玩

EnumSwift中的类型比C和C ++中的枚举功能强大得多。它们采用了仅传统上class或struct类型支持的许多功能，这意味着它们可以符合协议。



enum在游乐场的末尾添加以下定义：



enum UnladenSwallow: Bird, Flyable {
  case african
  case european
  case unknown
  
  var name: String {
    switch self {
    case .african:
      return "African"
    case .european:
      return "European"
    case .unknown:
      return "What do you mean? African or European?"
    }
  }
  
  var airspeedVelocity: Double {
    switch self {
    case .african:
      return 10.0
    case .european:
      return 9.9
    case .unknown:
      fatalError("You are thrown from the bridge of death!")
    }
  }
}

通过定义正确的属性，UnladenSwallow符合两国的协议Bird和Flyable。因为它是这样的遵循者，所以它也享有的默认实现canFly。



您是否真的认为涉及的教程airspeedVelocity可以忽略Monty Python参考资料？：]



2.6 覆盖默认行为

您的UnladenSwallow类型canFly通过遵守Bird协议自动收到了的实现。但是，你要UnladenSwallow.unknown回false了canFly。



您可以覆盖默认实现吗？你打赌 回到操场的尽头，添加一些新代码：



extension UnladenSwallow {
  var canFly: Bool {
    self != .unknown
  }
}

现在只有.african和.european返回true的canFly。试试看！在操场的尽头添加以下代码：



UnladenSwallow.unknown.canFly         // false
UnladenSwallow.african.canFly         // true
Penguin(name: "King Penguin").canFly  // false

建造游乐场，您会注意到它显示了上面注释中给出的值。



这样，您就可以像在面向对象编程中使用虚拟方法那样覆盖属性和方法。



2.7 扩展协议

您还可以使自己的协议与Swift标准库中的其他协议保持一致，并定义默认行为。将Bird协议声明替换为以下代码：



protocol Bird: CustomStringConvertible {
  var name: String { get }
  var canFly: Bool { get }
}
extension CustomStringConvertible where Self: Bird {
  var description: String {
    canFly ? "I can fly" : "Guess I'll just sit here :["
  }
}

符合CustomStringConvertible意味着您的类型需要具有description属性，以便String在需要时将其自动转换为属性。Bird您并未定义CustomStringConvertible将仅与类型关联的协议扩展，而不是将此属性添加到当前和将来的每种类型Bird。



在操场底部输入以下内容进行尝试：



UnladenSwallow.african

建立游乐场，您应该I can fly会在助手编辑器中看到“ ”出现。恭喜你！您已经扩展了协议。



2.8 对Swift标准库的影响

协议扩展不能像皮一样抓一磅重的椰子，但是如您所见，它们可以提供一种自定义和扩展命名类型功能的有效方法。Swift团队还采用协议来改进Swift标准库。



将此代码添加到游乐场的末尾：



let numbers = [10, 20, 30, 40, 50, 60]
let slice = numbers[1...3]
let reversedSlice = slice.reversed()
let answer = reversedSlice.map { $0 * 10 }
print(answer)

您也许可以猜出答案，但是可能令人惊讶的是所涉及的类型。



例如，slice不是Array<Int>而是ArraySlice<Int>。这种特殊的包装器类型充当原始数组的视图，提供了一种快速有效的方法来对较大数组的各个部分执行操作。同样，reversedSlice是的ReversedCollection<ArraySlice<Int>>另一个包装器类型，具有原始数组的视图。



幸运的是，开发Swift标准库的向导将map功能定义为Sequence协议的扩展，所有Collection类型都遵循该协议。这样一来，您map就Array可以像在上一样轻松地进行调用，ReversedCollection而不会注意到它们之间的差异。您很快就会借用这一重要的设计模式。



2.9 去比赛

到目前为止，您已经定义了几种符合的类型Bird。现在，您将在操场的尽头添加完全不同的内容：



class Motorcycle {
  init(name: String) {
    self.name = name
    speed = 200.0
  }
  var name: String
  var speed: Double
}

这个班级与鸟类或飞行无关。您只想让摩托车与企鹅竞赛。是时候将这些古怪的赛车手带到起跑线上了。

2.10 汇集全部

为了统一这些不同的类型，您需要一个通用的赛车协议。得益于一种称为追溯建模的好主意，您甚至可以在不触及原始模型定义的情况下进行管理。只需将以下内容添加到您的游乐场：



// 1
protocol Racer {
  var speed: Double { get }  // speed is the only thing racers care about
}
// 2
extension FlappyBird: Racer {
  var speed: Double {
    airspeedVelocity
  }
}
extension SwiftBird: Racer {
  var speed: Double {
    airspeedVelocity
  }
}
extension Penguin: Racer {
  var speed: Double {
    42  // full waddle speed
  }
}
extension UnladenSwallow: Racer {
  var speed: Double {
    canFly ? airspeedVelocity : 0.0
  }
}
extension Motorcycle: Racer {}
// 3
let racers: [Racer] =
  [UnladenSwallow.african,
   UnladenSwallow.european,
   UnladenSwallow.unknown,
   Penguin(name: "King Penguin"),
   SwiftBird(version: 5.1),
   FlappyBird(name: "Felipe", flappyAmplitude: 3.0, flappyFrequency: 20.0),
   Motorcycle(name: "Giacomo")]

这是这样做的：



1. 首先，定义协议Racer。该协议定义了您的游戏中可以竞争的所有内容。

2. 然后，Racer使所有内容都符合，以便我们所有现有的类型都可以竞争。某些类型（例如）Motorcycle琐碎地符合。其他的（例如UnladenSwallow）则需要更多的逻辑。无论哪种方式，当您完成操作时，都会得到一堆符合标准的Racer类型。

3. 在起始处使用所有类型时，现在创建一个Array<Racer>，其中包含您所创建的每种类型的实例。



建立操场检查所有编译。

2.11 最高速度

是时候编写一个确定赛车手最高速度的函数了。将以下代码添加到游乐场的末尾：



func topSpeed(of racers: [Racer]) -> Double {
  racers.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}
topSpeed(of: racers) // 5100

此函数使用Swift标准库函数max查找速度最高的赛车并返回。如果用户在中传入空值Array，则返回0.0 racers。



建立操场，您会看到您先前创建的赛车的最大速度确实是5100。



2.12 使它更通用

假设Racers规模很大，您只想找到一部分参与者的最高速度。解决的办法是改变topSpeed(of:)以采取任何Sequence不是具体的东西Array。



使用topSpeed(of:)以下功能替换您现有的实现：



// 1
func topSpeed<RacersType: Sequence>(of racers: RacersType) -> Double
    /*2*/ where RacersType.Iterator.Element == Racer {
  // 3
  racers.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}

这可能看起来有点吓人，但它是如何分解的：



1. RacersType是此函数的通用类型。它可以是符合Swift标准库Sequence协议的任何类型。

2. 该where子句指定的Element类型Sequence必须符合您的Racer协议才能使用此功能。

3. 实际的功能主体与以前相同。



现在，将以下代码添加到操场的底部：



topSpeed(of: racers[1...3]) // 42

建立游乐场，您将看到输出为42的答案。该函数现在适用于任何Sequence类型，包括ArraySlice。



2.13 使它更迅速

这是一个秘密：您可以做得更好。在操场的尽头添加以下内容：



extension Sequence where Iterator.Element == Racer {
  func topSpeed() -> Double {
    self.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
  }
}
racers.topSpeed()        // 5100
racers[1...3].topSpeed() // 42

从Swift标准库剧本中借用，您现在已经扩展了Sequence自身以具有topSpeed()功能。该功能是很容易发现的，只有当你是在处理一个应用Sequence的Racer类型。



2.14 协议比较器

Swift协议的另一个功能是如何表示操作员要求，例如的对象相等==或如何比较>和的对象<。您知道这笔交易吧–在您的游乐场底部添加以下代码：



protocol Score {
  var value: Int { get }
}
struct RacingScore: Score {
  let value: Int
}

拥有Score协议意味着您可以编写以相同方式对待所有分数的代码。但是，通过使用不同的具体类型（例如）RacingScore，您不会将这些分数与样式分数或可爱分数混为一谈。谢谢，编译器！



您希望分数具有可比性，以便您可以判断谁得分最高。在Swift 3之前，开发人员需要添加全局运算符功能以符合这些协议。今天，您可以将这些静态方法定义为模型的一部分。通过替换的定义，这样做Score，并RacingScore有以下情况：



protocol Score: Comparable {
  var value: Int { get }
}
struct RacingScore: Score {
  let value: Int
  
  static func <(lhs: RacingScore, rhs: RacingScore) -> Bool {
    lhs.value < rhs.value
  }
}

真好！您已经将所有逻辑封装RacingScore在一个地方。Comparable只需要您为小于运算符提供一个实现。其余要比较的运算符（例如大于），具有Swift标准库基于小于运算符提供的默认实现。



在游乐场底部使用以下代码行测试新发现的操作员技能：



RacingScore(value: 150) >= RacingScore(value: 130) // true

建立游乐场，您会注意到答案是true预期的。您现在可以比较分数！

2.15 变异功能

到目前为止，您实现的每个示例都演示了如何添加功能。但是，如果您想让协议定义一些可以改变对象外观的东西，该怎么办？您可以通过在协议中使用变异方法来做到这一点。



在操场的底部，添加以下新协议：



protocol Cheat {
  mutating func boost(_ power: Double)
}

这定义了一种协议，可使您的类型作弊。怎么样？通过增加您认为合适的任何东西。



接下来，在扩展上创建SwiftBird符合Cheat以下代码的扩展：



extension SwiftBird: Cheat {
  mutating func boost(_ power: Double) {
    speedFactor += power
  }
}

在这里，您实现boost(_:)并speedFactor通过power传入来增加值。您添加了mutating关键字以struct使它的值之一将在此函数中更改。



将以下代码添加到操场上，以了解其工作原理：



var swiftBird = SwiftBird(version: 5.0)
swiftBird.boost(3.0)
swiftBird.airspeedVelocity // 5015
swiftBird.boost(3.0)
swiftBird.airspeedVelocity // 5030

在这里，您创建了一个SwiftBird可变的a，并将其速度提高了3，然后又提高了3。建造游乐场，您应注意，每次提升时airspeedVelocity的SwiftBird都增加了。



3. 然后去哪儿？

使用本教程顶部或底部的下载材料按钮下载完整的Playground。



至此，您已经通过创建简单协议并使用协议扩展对其进行了扩展，从而测试了面向协议编程的功能。使用默认实现，您可以为现有协议提供常见和自动的行为。这就像更好地像基类一样，因为它们也可以应用于struct和enum类型。



您还已经看到协议扩展可以扩展并为Swift标准库，Cocoa，Cocoa Touch或任何第三方库中的协议提供默认行为。



要继续学习有关协议的更多信息，请阅读Swift的官方文档。



您可以在Apple的开发人员门户上观看有关面向协议编程的WWDC精彩会议。它提供了对所有背后理论的深入探索。



在其Swift进化提案中阅读有关操作符一致性的基本原理。您可能还想了解有关SwiftCollection协议的更多信息，并[学习如何构建自己的协议](https://www.raywenderlich.com/139591/building-custom-collection-swift)。



与任何编程范例一样，很容易变得过于旺盛并将其用于所有事物。克里斯·艾德霍夫（Chris Eidhof）的这篇有趣的博客文章提醒读者，他们应该提防银弹解决方案。不要在各处仅因为“使用协议”。



参考

https://www.raywenderlich.com/6742901-protocol-oriented-programming-tutorial-in-swift-5-1-getting-started



3. Tips: 学习至少一个技术技巧

笔者的文章：

翻译：protocol的高阶用法，在Swift 5中使用协议protocol构建自定义集合Collection

说明

Array，Dictionary并且Set是Swift标准库中捆绑的常用集合类型。但是，如果他们没有立即提供您的应用所需的一切，该怎么办？别担心。您可以使用Swift标准库中的协议创建自己的自定义集合！



Swift中的集合带有大量方便的实用程序，可用于遍历它们，对其进行过滤等。除了使用自定义集合之外，您还可以将所有业务逻辑添加到自己的代码中。但是，这会使您的代码肿，难以维护并且无法复制标准库提供的内容。



幸运的是，Swift提供了功能强大的收集协议，因此您可以创建自己的收集类型，这些收集类型专门为满足应用程序的需求而量身定制。您只需实现这些协议即可带来Swift集合的强大功能。



在本教程中，您将从头开始构建一个multiset，也称为bag。



在此过程中，您将学习如何：



• 采用这些协议：Hashable，Sequence，Collection，CustomStringConvertible，ExpressibleByArrayLiteral和ExpressibleByDictionaryLiteral。

• 为您的集合创建自定义初始化。

• 使用自定义方法改进自定义集合。



是时候跳进去了！



1. 实战

1.1 创建 Bag.playground

接下来，将以下代码添加到您的游乐场：



struct Bag<Element: Hashable> {
}

就像这样，“爸爸有了一个全新的包”！



您Bag是需要Hashable元素类型的通用结构。通过要求Hashable元素，您可以比较和存储O（1）时间复杂度的唯一值。这意味着无论其内容的大小如何，Bag都将以恒定的速度执行。另外，请注意，您正在使用struct;; 就像Swift对标准集合所做的那样，这会强制执行值语义。



ABag之所以像a Set，是因为它不存储重复的值。不同之处在于：ABag保留任何重复值的连续计数，而aSet则不保留。

像购物清单一样考虑它。如果您想要多个，则不要多次列出。您只需在项目旁边写上您想要的号码。



要对此建模，请Bag在您的游乐场中添加以下属性：



// 1
fileprivate var contents: [Element: Int] = [:]
// 2
var uniqueCount: Int {
  return contents.count
}
// 3
var totalCount: Int {
  return contents.values.reduce(0) { $0 + $1 }
}

这些是所需的基本属性Bag。这是每个人的工作：



1. contents：使用aDictionary作为内部数据结构。这对于a非常Bag有用，因为它强制执行用于存储元素的唯一键。每个元素的值就是其计数。请注意，您将此属性标记为fileprivate对Bag外部隐藏其内部工作。

2. uniqueCount：返回唯一项的数量，忽略其单独数量。例如，一个Bag包含4个橙子和3个苹果的a将返回uniqueCount2。

3. totalCount：返回中的项目总数Bag。在上面的示例中，totalCount将返回7。



1.2 添加编辑方法

现在，您将实现一些方法来编辑的内容Bag。



添加添加方法

在刚添加的属性下面添加以下方法：



// 1
mutating func add(_ member: Element, occurrences: Int = 1) {
  // 2
  precondition(occurrences > 0,
    "Can only add a positive number of occurrences")
  // 3
  if let currentCount = contents[member] {
    contents[member] = currentCount + occurrences
  } else {
    contents[member] = occurrences
  }
}

这是这样做的：



1. add（_：occurrences :)：提供一种向中添加元素的方法Bag。它具有两个参数：通用类型Element，和可选的出现次数。将方法标记为，mutating以便可以修改contents实例变量。

2. precondition（_：_ :)：需要大于0的出现。如果此条件为假，则执行停止，String并且遵循该条件的将会出现在游乐场调试器中。

本部分检查包装袋中是否已存在该元素。如果是这样，它将增加计数。如果没有，它将创建一个新元素。



注意：您将precondition在本教程中通篇使用，以确保Bag按预期使用。您还将precondition用作健全性检查，以确保添加功能时一切正常。逐步执行此操作将使您避免意外破坏以前运行的功能。



现在您已经可以将元素添加到Bag实例中，还需要一种方法来删除它们。



1.3 实现删除方法

在下面添加以下方法add(_:occurrences:)：

mutating func remove(_ member: Element, occurrences: Int = 1) {
  // 1
  guard 
    let currentCount = contents[member],
    currentCount >= occurrences 
    else {
      return
  }
  // 2
  precondition(occurrences > 0,
    "Can only remove a positive number of occurrences")
  // 3
  if currentCount > occurrences {
    contents[member] = currentCount - occurrences
  } else {
    contents.removeValue(forKey: member)
  }
}

请注意，remove(:occurrences:)其参数与相同add(:occurrences:)。运作方式如下：



1. 首先，它检查该元素是否存在，以及它至少具有调用者要删除的出现次数。如果不是，则该方法返回。

2. 接下来，确保要删除的出现次数大于0。

3. 最后，它检查元素的当前计数是否大于要删除的出现次数。如果更大，则通过从当前计数中减去要删除的出现次数来设置元素的新计数。如果不大于，则currentCount和出现次数相等，它将完全删除该元素。



现在Bag做不了什么。您无法访问其内容，也无法使用任何有用的收集方法（例如map，等）对您的集合进行操作filter。



但是，一切都不会丢失！Swift提供了制作Bag合法集合所需的工具。您只需要遵循一些协议即可。



1.4 采用协议

在Swift中，协议定义了一组属性和方法，这些属性和方法必须在采用它的对象中实现。要采用协议，只需在您的定义之后添加一个冒号，class或struct后跟您要采用的协议名称。声明采用协议后，请在对象上实现所需的变量和方法。完成后，您的对象将符合协议。



>注意：您可以在我们的面向协议的编程教程中了解有关协议的更多信息。



这是一个简单的例子。当前，Bag对象在Playground的结果侧栏中几乎没有显示任何信息。



将以下代码添加到运动场的末尾（结构外部）以Bag进行操作：

var shoppingCart = Bag<String>()
shoppingCart.add("Banana")
shoppingCart.add("Orange", occurrences: 2)
shoppingCart.add("Banana")
shoppingCart.remove("Orange")

然后按Command-Shift-Enter执行操场。



这将创建一个Bag带有少量水果的新产品。如果您查看运动场调试器，则会看到对象类型，但不包含任何内容。

1.5 采用CustomStringConvertible

幸运的是，Swift为CustomStringConvertible这种情况提供了协议！在的大括号后添加以下内容Bag：

extension Bag: CustomStringConvertible {
  var description: String {
    return String(describing: contents)
  }
}

符合CustomStringConvertible要求实现名为的单个属性description。此属性返回特定实例的文本表示形式。



您将在此处放置创建代表数据的字符串所需的任何逻辑。因为Dictionary符合CustomStringConvertible，您只需将description调用委派给即可contents。



按Command-Shift-Enter再次运行游乐场。



看一下新改进的调试信息shoppingCart：

太棒了！现在，在向中添加功能时Bag，您将能够验证其内容。



大！创建功能强大的原生集合类型时，您就在途中。接下来是初始化。



1.6 创建初始化器

非常烦人的是，您必须一次添加一个元素。您应该能够Bag通过传递要添加的对象集合来初始化自己。



将以下代码添加到运动场的末尾（但请注意，这尚不能编译）：



let dataArray = ["Banana", "Orange", "Banana"]
let dataDictionary = ["Banana": 2, "Orange": 1]
let dataSet: Set = ["Banana", "Orange", "Banana"]
var arrayBag = Bag(dataArray)
precondition(arrayBag.contents == dataDictionary,
  "Expected arrayBag contents to match \(dataDictionary)")
var dictionaryBag = Bag(dataDictionary)
precondition(dictionaryBag.contents == dataDictionary,
  "Expected dictionaryBag contents to match \(dataDictionary)")
var setBag = Bag(dataSet)
precondition(setBag.contents == ["Banana": 1, "Orange": 1],
  "Expected setBag contents to match \(["Banana": 1, "Orange": 1])")

您可能会期望这样创建一个Bag。但是它不会编译，因为您尚未定义接受其他集合的初始化程序。无需为每种类型显式创建初始化方法，而是使用generics。



totalCount在实现的下面添加以下方法Bag：

// 1
init() { }
// 2
init<S: Sequence>(_ sequence: S) where
  S.Iterator.Element == Element {
  for element in sequence {
    add(element)
  }
}
// 3
init<S: Sequence>(_ sequence: S) where
  S.Iterator.Element == (key: Element, value: Int) {
  for (element, count) in sequence {
    add(element, occurrences: count)
  }
}

这是您刚刚添加的内容：



1. 首先，您创建了一个空的初始化程序。定义其他init方法时，需要添加此内容。

2. 接下来，您添加了一个初始化程序，该初始化程序接受符合Sequence协议的所有内容，其中该序列的元素与的元素相同Bag。这涵盖了Array和Set类型。您遍历顺序传递的内容，并一次添加每个元素。

3. 此后，您添加了一个类似的初始化程序，但是它接受type的元组(Element, Int)。一个例子是Dictionary。在这里，您遍历序列中的每个元素并添加指定的计数。



再次按Command-Shift-Enter即可运行游乐场。请注意，您之前在底部添加的代码现在可以使用。



1.7 初始化集合

这些通用的初始化程序为Bag对象提供了更多种类的数据源。但是，它们确实需要您首先创建传递给初始化程序的集合。



为了避免这种情况，Swift提供了两种协议来启用序列文字的初始化。文字为您提供了一种无需显式创建对象即可写数据的简便方法。



为此，请首先将以下代码添加到游乐场的末尾：（注意：在添加所需的协议之前，这也会产生错误。）

var arrayLiteralBag: Bag = ["Banana", "Orange", "Banana"]
precondition(arrayLiteralBag.contents == dataDictionary,
  "Expected arrayLiteralBag contents to match \(dataDictionary)")
var dictionaryLiteralBag: Bag = ["Banana": 2, "Orange": 1]
precondition(dictionaryLiteralBag.contents == dataDictionary,
  "Expected dictionaryLiteralBag contents to match \(dataDictionary)")

上面的代码是使用Array和Dictionary文字而不是对象进行初始化的示例。



现在，要使它们起作用，请在扩展名下面添加以下两个扩展CustomStringConvertible名：

// 1
extension Bag: ExpressibleByArrayLiteral {
  init(arrayLiteral elements: Element...) {
    self.init(elements)
  }
}
// 2
extension Bag: ExpressibleByDictionaryLiteral {
  init(dictionaryLiteral elements: (Element, Int)...) {
    self.init(elements.map { (key: $0.0, value: $0.1) })
  }
}

1. ExpressibleByArrayLiteral用于根据Bag数组样式文字创建一个。在这里，您可以使用之前创建的初始化程序，并传入elements集合。

2. ExpressibleByDictionaryLiteral除了字典样式文字外，其功能相同。该映射将元素转换为初始化程序期望的命名元组。



随着Bag看起来更像一个原生的集合类型，它的时间去真正的魔力。



2. 了解自定义集合

您现在已经学到了足够的知识，可以理解什么是自定义集合：您定义的集合对象同时符合Sequence和Collection协议。



在上一节中，您定义了一个初始化程序，该初始化程序接受符合Sequence协议的集合对象。Sequence表示一种类型，该类型提供对其元素的顺序，迭代访问。您可以将序列视为一系列项目，让您一次遍历每个元素。

迭代是一个简单的概念，但是此功能为您的对象提供了巨大的功能。它允许您执行各种强大的操作，例如：



1. map（_ :)：使用提供的闭包转换序列中的每个元素后，返回结果数组。

2. filter（_ :)：返回满足提供的闭包谓词的元素数组。

3. sorted（by :)：返回基于提供的闭包谓词排序的元素数组。



上面是常用的方法。要查看所有可用的方法Sequence，请查看Apple的Sequence Protocol文档。



2.1 加强无损迭代

一个警告：Sequence不需要符合性的类型是非破坏性的。这意味着在迭代之后，无法保证将来的迭代将从头开始。如果您计划多次迭代数据，那将是一个巨大的问题。



要执行无损迭代，您的对象需要符合Collection协议。



Collection继承自Indexable和Sequence。

主要区别在于，集合是可以多次遍历并按索引访问的序列。



遵循，您将免费获得许多方法和属性Collection。一些例子是：



1. isEmpty：返回一个布尔值，指示集合是否为空。

2. first：返回集合中的第一个元素。

3. count：返回集合中元素的数量。



根据集合中元素的类型，还有更多可用的方法。在Apple的“收集协议”文档中进行检查。



抓住Bag并采用这些协议！



2.2 采用Sequence Protocol序列协议

对集合类型执行的最常见操作是遍历其元素。例如，将以下内容添加到游乐场的末尾：

for element in shoppingCart {
  print(element)
}

与Array和一样Dictionary，您应该可以循环浏览Bag。这将无法编译，因为当前Bag类型不符合Sequence。



现在修复该问题。

2.3 符合Sequence Protocol

在ExpressibleByDictionaryLiteral扩展名后添加以下内容：

extension Bag: Sequence {
  // 1
  typealias Iterator = DictionaryIterator<Element, Int>
  // 2
  func makeIterator() -> Iterator {
    // 3
    return contents.makeIterator()
  }
}

不需要太多的钱去遵守Sequence。在上面的代码中，您：



1. 创建一个typealias命名Iterator为DictionaryIterator。Sequence要求它知道如何迭代序列。DictionaryIterator是Dictionary对象用来遍历其元素的类型。您使用此类型是因为Bag将其基础数据存储在中Dictionary。

2. 定义makeIterator()为返回Iterator用于逐步浏览序列中每个元素的方法。

3. 通过委派给makeIterator()on来返回迭代器，该迭代器contents本身符合Sequence。



这就是您需要Bag遵循的所有条件Sequence！



您现在可以遍历a的每个元素Bag并获取每个对象的计数。在上一个for-in循环之后，将以下内容添加到运动场的末尾：