关于swiftassociatedtype的信息

本篇文章给大家谈谈swiftassociatedtype，以及对应的知识点，小编致力于为用户带来全面可靠的币圈信息，希望对各位有所帮助！

因为swift中的协议(protocol)采用的是“Associated Types”的方式来实现泛型功能的，通过associatedtype关键字来声明一个类型的占位符作为协议定义的一部分。

查看文档我们发现，Swift的数组是一个结构体类型，它遵守了CollectionType、MutableCollectionType、_DstructorSafeContainer协议，其中最重要的就是CollectionType协议，数组的一些主要功能都是通过这个协议实现的。而CollectionType协议又遵守Indexable和SequenceType这两个协议。而在这两个协议中，SequenceType协议是数组、字典等集合类型最重要的协议，在文档中解释了SequenceType是一个可以通过for…in循环迭代的类型，实现了这个协议，就可以for…in循环了。

A type that can be iterated with a for…in loop.

而SequenceType是建立在GeneratorType基础上的，sequence需要GeneratorType来告诉它如何生成元素。

GeneratorType

GeneratorType协议有两部分组成：

它需要有一个Element关联类型，这也是它产生的值的类型。

它需要有一个next方法。这个方法返回Element的可选对象。通过这个方法就可以一直获取下一个元素，直到返回nil，就意味着已经获取到了所有元素。

/// Encapsulates iteration state and interface for iteration over a

/// sequence.

///

/// – Note: While it is safe to copy a generator, advancing one

/// copy may invalidate the others.

///

/// Any code that uses multiple generators (or `for`…`in` loops)

/// over a single sequence should have static knowledge that the

/// specific sequence is multi-pass, either because its concrete

/// type is known or because it is constrained to `CollectionType`.

/// Also, the generators must be oained by distinct calls to the

/// sequence’s `generate()` method, rather than by copying.

public protocol GeneratorType {

/// The type of element generated by `self`.

associatedtype Element

/// Advance to the next element and return it, or `nil` if no next

/// element exists.

///

/// – Requires: `next()` has not been applied to a copy of `self`

/// since the copy was made, and no preceding call to `self.next()`

/// has returned `nil`. Specific implementations of this protocol

/// are encouraged to respond to violations of this requirement by

/// calling `preconditionFailure(“…”)`.

@warn_unused_result

public mutating func next() – Self.Element?

}

我把自己实现的数组命名为MYArray，generator为MYArrayGenerator，为了简单，这里通过字典来存储数据，并约定字典的key为从0开始的连续数字。就可以这样来实现GeneratorType:

/// 需保准dic的key是从0开始的连续数字

struct MYArrayGeneratorT: GeneratorType {

private let dic: [Int: T]

private var index = 0

init(dic: [Int: T]) {

self.dic = dic

}

mutating func next() – T? {

let element = dic[index]

index += 1

return element

}

}

这里通过next方法的返回值，隐式地为Element赋值。显式地赋值可以这样写typealias Element = T。要使用这个生成器就非常简单了：

let dic = [0: “XiaoHong”, 1: “XiaoMing”]

var generator = MYArrayGenerator(dic: dic)

while let elment = generator.next() {

print(elment)

}

// 打印的结果：

// XiaoHong

// XiaoMing

SequenceType

有了generator，下面就可以实现SequenceType协议了。SequenceType协议也是主要有两部分：

需要有一个Generator关联类型，它要遵守GeneratorType。

要实现一个generate方法，返回一个Generator。同样的，我们可以通过制定generate方法的方法类型来隐式地设置Generator：

struct MYArrayT: SequenceType {

private let dic: [Int: T]

func generate() – MYArrayGeneratorT {

return MYArrayGenerator(dic: dic)

}

}

这样我们就可以创建一个MYArray实例，并通过for循环来迭代：

let dic = [0: “XiaoHong”, 1: “XiaoMing”, 2: “XiaoWang”, 3: “XiaoHuang”, 4: “XiaoLi”]

let array = MYArray(dic: dic)

for value in array {

print(value)

}

let names = array.map { $0 }

当然，目前这个实现还存在很大的隐患，因为传入的字典的key是不可知的，虽然我们限定了必须是Int类型，但无法保证它一定是从0开始，并且是连续，因此我们可以通过修改初始化方法来改进：

init(elements: T…) {

dic = [Int: T]()

elements.forEach { dic[dic.count] = $0 }

}

然后我们就可以通过传入多参数来创建实例了：

let array = MYArray(elements: “XiaoHong”, “XiaoMing”, “XiaoWang”, “XiaoHuang”, “XiaoLi”)

再进一步，通过实现ArrayLiteralConvertible协议，我们可以像系统的Array数组一样，通过字面量来创建实例：

let array = [“XiaoHong”, “XiaoMing”, “XiaoWang”, “XiaoHuang”, “XiaoLi”]

**还有一个数组的重要特性，就是通过下标来取值，这个特性我们可以通过实现subscript方法来实现：

extension MYArray {

subscript(idx: Int) – Element {

precondition(idx dic.count, “Index out of bounds”)

return dic[idx]!

}

}

print(array[3]) // XiaoHuang

至此，一个自定义的数组就基本实现了，我们可以通过字面量来创建一个数组，可以通过下标来取值，可以通过for循环来遍历数组，可以使用map、forEach等高阶函数。

小结

要实现一个数组的功能，主要是通过实现SequenceType协议。SequenceType协议有一个Generator实现GeneratorType协议，并通过Generator的next方法来取值，这样就可以通过连续取值，来实现for循环遍历了。同时通过实现ArrayLiteralConvertible协议和subscript，就可以通过字面量来创建数组，并通过下标来取值。

CollectionType

上面我们为了弄清楚SequenceType的实现原理，通过实现SequenceType和GeneratorType来实现数组，但实际上Swift系统的Array类型是通过实现CollectionType来获得这些特性的，而CollectionType协议又遵守Indexable和SequenceType这两个协议。并扩展了两个关联类型Generator和SubSequence，以及9个方法，但这两个关联类型都是默认值，而且9个方法也都在协议扩展中有默认实现。因此，我们只需要为Indexable协议中要求的 startIndex 和 endIndex 提供实现，并且实现一个通过下标索引来获取对应索引的元素的方法。只要我们实现了这三个需求，我们就能让一个类型遵守 CollectionType 了。因此这个自定义的数组可以这样实现：

struct MYArrayElement: CollectionType {

private var dic: [Int: Element]

init(elements: Element…) {

dic = [Int: Element]()

elements.forEach { dic[dic.count] = $0 }

}

var startIndex: Int { return 0 }

var endIndex: Int { return dic.count }

subscript(idx: Int) – Element {

precondition(idx endIndex, “Index out of bounds”)

return dic[idx]!

}

}

extension MYArray: ArrayLiteralConvertible {

init(arrayLiteral elements: Element…) {

dic = [Int: Element]()

elements.forEach { dic[dic.count] = $0 }

}

}

Swift中的协议(protocol)采用的是“Associated Types”的方式来实现泛型功能的，通过associatedtype关键字来声明一个类型的占位符作为协议定义的一部分。

swift中的协议(protocol)采用的是“Associated Types”的方式来实现泛型功能的，通过associatedtype关键字来声明一个类型的占位符作为协议定义的一部分。swift的协议不支持下面的定义方式：

protocol GeneratorTypeElement {

public mutating func next() – Element?

}

而是应该使用这样的定义方式：

protocol GeneratorType {

associatedtype Element

public mutating func next() – Self.Element?

}

在swift中，class、struct、enums都可以是用参数化类型来表达泛型的，只有在协议中需要使用associatedtype关键字来表达参数化类型。为什么协议不采用T这样的语法形式呢？我查看了很多讨论，原因大概总结为一下两点：

采用语法T的参数化方式的泛型其实定义了整个类型的家族，在概念上这对于一个可以具体实现的类型(class、struct、enums)是有意义的，比方说ArrayInt,ArrayString。但对于协议来说，协议表达的含义是single的。你只会实现一次GeneratorType，而不会实现一个GeneratorTypeString协议，接着又实现另外一个GeneratorTypeInt协议。

协议在swift中有两个目的，第一个目的是用来实现多继承(swift语言被设计为单继承的），第二个目的是强制实现者必须准守自己所指定的泛型约束。关键字associatedtype是用来实现第二个目的的。在GeneratorType中由associatedtype指定的Element，是用来控制next()方法的返回类型的。而不是用来指定GeneratorType的类型的。

我们可以用一个例子进一步解释一下第二个观点

public protocol Automobile {

associatedtype FuelType

associatedtype ExhaustType

func drive(fuel: FuelType) – ExhaustType

}

public protocol Fuel {

associatedtype ExhaustType

func consume() – ExhaustType

}

public protocol Exhaust {

init()

func emit()

}

我们定义了三个协议，机动车(Automobile)、燃料(Fuel)、尾气(Exhaust),因为Automobile涉及到燃料和尾气所以它内定义了两个关联类型FuelType和ExhaustType，Fuel燃烧后会排放Exhaust，所以在Fuel内定义了关联类型ExhaustType。而Exhaust不需要关联类型。

下面我们做三个具体的实现：

public struct UnleadedGasolineE: Exhaust: Fuel {

public func consume() – E {

print(“…consuming unleaded gas…”)

return E()

}

}

public struct CleanExhaust: Exhaust {

public init() {}

public func emit() {

print(“…this is some clean exhaust…”)

}

}

public class CarF: Fuel,E: Exhaust where F.ExhaustType == E: Automobile {

public func drive(fuel: F) – E {

return fuel.consume()

}

}

我们重点关注Car的定义，我们之所以在Car的定义中同时使用了两种占位符F和E，就是为了给这两个占位符所代表的类型增加约束，因为我们使用一种燃料，必然要排放这种燃料所对应的尾气。于是我们这样使用Car

var car = CarUnleadedGasolineCleanExhaust, CleanExhaust()

car.drive(UnleadedGasolineCleanExhaust()).emit()

CarUnleadedGasolineCleanExhaust, CleanExhaust在这里成为了一种具体的类型，从Car的意义上来看，燃料成为Car类型的一部分是无可厚非的，因为汽车本身就是可以用燃料进行类型区分的吗。

但尾气成为Car类型的一部分真的有意义吗？从现实生活当中看，这是没有意义，因为尾气一定尊属与某种燃料类型，用燃料做为类型的一部分已经足够了。尾气成为类型的一部分问题出在了，我们需要在技术上进行泛型约束。

我们现在来调整一下Car的实现部分。

public class CarF: Fuel: Automobile {

public func drive(fuel: F) – F.ExhaustType {

return fuel.consume()

}

}

在新的定义中，我们把E从参数中去掉，而是换作为drive方法的返回值。这样的效果是非常明显的，因为E的存在就是为了泛型约束，让其作为返回值是完全可以实现这种约束。而且有没有使其成为类型一部分的副作用。我们现在就可以这样获得一个Car的实例了。

var fusion = CarUnleadedGasolineCleanExhaust()

都看完了嘛？相信现在您对swiftassociatedtype有一个初级的认识了吧！也可以收藏小编页面获取更多知识哟！区块链、虚拟币，我们是认真的！