Swift学习：2.22 泛型
|
参考Swift 官方教程《The Swift Programming Language》中文版
泛型泛型代码可以让你写出根据自我需求定义、适用于任何类型的，灵活且可重用的函数和类型。它的可以让你避免重复的代码，用一种清晰和抽象的方式来表达代码的意图。 泛型是 Swift 强大特征中的其中一个，许多 Swift 标准库是通过泛型代码构建出来的。事实上，泛型的使用贯穿了整本语言手册，只是你没有发现而已。例如，Swift 的数组和字典类型都是泛型集。你可以创建一个 泛型所解决的问题这里是一个标准的，非泛型函数 func swapTwoInts(inout a: Int,inout b: Int) {
let temporaryA = a
a = b
b = temporaryA
}
这个函数使用写入读出（in-out）参数来交换
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt,&anotherInt)
println("someInt is now (someInt),and anotherInt is now (anotherInt)")
// 输出 "someInt is now 107,and anotherInt is now 3"
func swapTwoStrings(inout a: String,inout b: String) {
let temporaryA = a
a = b
b = temporaryA
}
func swapTwoDoubles(inout a: Double,inout b: Double) {
let temporaryA = a
a = b
b = temporaryA
}
你可能注意到 但实际应用中通常需要一个用处更强大并且尽可能的考虑到更多的灵活性单个函数，可以用来交换两个任何类型值，很幸运的是，泛型代码帮你解决了这种问题。（一个这种泛型函数后面已经定义好了。）
泛型函数
func swapTwoValues<T>(inout a: T,inout b: T) {
let temporaryA = a
a = b
b = temporaryA
}
func swapTwoInts(inout a: Int,inout b: Int) func swapTwoValues<T>(inout a: T,inout b: T)
这个函数的泛型版本使用了占位类型名字（通常此情况下用字母 另外一个不同之处在于这个泛型函数名后面跟着的占位类型名字（T）是用尖括号括起来的（
在下面的两个例子中, var someInt = 3
var anotherInt = 107
swapTwoValues(&someInt,&anotherInt)
// someInt is now 107,and anotherInt is now 3
var someString = "hello"
var anotherString = "world"
swapTwoValues(&someString,&anotherString)
// someString is now "world",and anotherString is now "hello"
类型参数在上面的 一旦一个类型参数被指定，那么其可以被使用来定义一个函数的参数类型（如 你可支持多个类型参数，命名在尖括号中，用逗号分开。 命名类型参数在简单的情况下，泛型函数或泛型类型需要指定一个占位类型（如上面的 如果你使用多个参数定义更复杂的泛型函数或泛型类型，那么使用更多的描述类型参数是非常有用的。例如，Swift 字典（Dictionary）类型有两个类型参数，一个是键，另外一个是值。如果你自己写字典，你或许会定义这两个类型参数为
泛型类型通常在泛型函数中，Swift 允许你定义你自己的泛型类型。这些自定义类、结构体和枚举作用于任何类型，如同 这部分向你展示如何写一个泛型集类型--
下图展示了一个栈的压栈(push)/出栈(pop)的行为：
这里展示了如何写一个非泛型版本的栈， struct IntStack {
var items = Int[]()
mutating func push(item: Int) {
items.append(item)
}
mutating func pop() -> Int {
return items.removeLast()
}
}
这个结构体在栈中使用一个 上面所展现的 这里是一个相同代码的泛型版本： struct Stack<T> {
var items = [T]()
mutating func push(item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
}
注意到
当创建一个新单例并初始化时， 通过用一对紧随在类型名后的尖括号里写出实际指定栈用到类型，创建一个 var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
stackOfStrings.push("cuatro")
// 现在栈已经有4个string了
下图将展示 从栈中 let fromTheTop = stackOfStrings.pop()
// fromTheTop is equal to "cuatro",and the stack now contains 3 strings
下图展示了如何从栈中pop一个值的过程： 由于 类型约束
例如，Swift 的 这个需求强制加上一个类型约束作用于 当你创建自定义泛型类型时，你可以定义你自己的类型约束，当然，这些约束要支持泛型编程的强力特征中的多数。抽象概念如 类型约束语法你可以写一个在一个类型参数名后面的类型约束，通过冒号分割，来作为类型参数链的一部分。这种作用于泛型函数的类型约束的基础语法如下所示（和泛型类型的语法相同）： func someFunction<T: SomeClass,U: SomeProtocol>(someT: T,someU: U) {
// function body goes here
}
上面这个假定函数有两个类型参数。第一个类型参数 类型约束行为这里有个名为 func findStringIndex(array: [String],valueToFind: String) -> Int? {
for (index,value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
let strings = ["cat","dog","llama","parakeet","terrapin"]
if let foundIndex = findStringIndex(strings,"llama") {
println("The index of llama is (foundIndex)")
}
// 输出 "The index of llama is 2"
如果只是针对字符串而言查找在数组中的某个值的索引，用处不是很大，不过，你可以写出相同功能的泛型函数 这里展示如何写一个你或许期望的 func findIndex<T>(array: T[],valueToFind: T) -> Int? {
for (index,value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
上面所写的函数不会编译。这个问题的位置在等式的检查上， 不过，所有的这些并不会让我们无从下手。Swift 标准库中定义了一个 任何 func findIndex<T: Equatable>(array: T[],value) in enumerate(array) {
if value == valueToFind {
return index
}
}
return nil
}
let doubleIndex = findIndex([3.14159,0.1,0.25],9.3)
// doubleIndex is an optional Int with no value,because 9.3 is not in the array
let stringIndex = findIndex(["Mike","Malcolm","Andrea"],"Andrea")
// stringIndex is an optional Int containing a value of 2
关联类型(Associated Types)当定义一个协议时，有的时候声明一个或多个关联类型作为协议定义的一部分是非常有用的。一个关联类型作为协议的一部分，给定了类型的一个占位名（或别名）。作用于关联类型上实际类型在协议被实现前是不需要指定的。关联类型被指定为 关联类型行为这里是一个 protocol Container {
typealias ItemType
mutating func append(item: ItemType) var count: Int { get }
subscript(i: Int) -> ItemType { get }
}
这个协议没有指定容器里item是如何存储的或何种类型是允许的。这个协议只指定三个任何遵循 任何遵循 为了定义这三个条件， 为了达到此目的， 这里是一个早前IntStack类型的非泛型版本，遵循Container协议： struct IntStack: Container {
// IntStack的原始实现
var items = [Int]()
mutating func push(item: Int) {
items.append(item)
}
mutating func pop() -> Int {
return items.removeLast()
}
// 遵循Container协议的实现
typealias ItemType = Int
mutating func append(item: Int) {
self.push(item)
}
var count: Int {
return items.count
}
subscript(i: Int) -> Int {
return items[i]
}
}
此外， 感谢Swift类型参考，你不用在 你也可以生成遵循 struct Stack<T>: Container {
// original Stack<T> implementation
var items = [T]()
mutating func push(item: T) {
items.append(item)
}
mutating func pop() -> T {
return items.removeLast()
}
// conformance to the Container protocol
mutating func append(item: T) {
self.push(item)
}
var count: Int {
return items.count
}
subscript(i: Int) -> T {
return items[i]
}
}
这个时候，占位类型参数 扩展一个存在的类型为一指定关联类型在使用扩展来添加协议兼容性中有描述扩展一个存在的类型添加遵循一个协议。这个类型包含一个关联类型的协议。 Swift的 extension Array: Container {}
如同上面的泛型 Where 语句类型约束能够确保类型符合泛型函数或类的定义约束。 对关联类型定义约束是非常有用的。你可以在参数列表中通过where语句定义参数的约束。一个 下面的例子定义了一个名为 被检查的两个 func allItemsMatch< C1: Container,C2: Container where C1.ItemType == C2.ItemType,C1.ItemType: Equatable> (someContainer: C1,anotherContainer: C2) -> Bool {
// 检查两个Container的元素个数是否相同
if someContainer.count != anotherContainer.count {
return false
}
// 检查两个Container相应位置的元素彼此是否相等
for i in 0..<someContainer.count {
if someContainer[i] != anotherContainer[i] {
return false
}
}
// 如果所有元素检查都相同则返回true
return true
}
这个函数用了两个参数： 这个函数的类型参数列紧随在两个类型参数需求的后面：
第三个和第四个要求被定义为一个 这些要求意思是：
第三个和第四个要求结合起来的意思是 这些要求能够使
检查完之后，函数通过 如果循环体结束后未发现没有任何的不匹配，那表明两个容器匹配，函数返回 这里演示了allItemsMatch函数运算的过程： var stackOfStrings = Stack<String>()
stackOfStrings.push("uno")
stackOfStrings.push("dos")
stackOfStrings.push("tres")
var arrayOfStrings = ["uno","dos","tres"]
if allItemsMatch(stackOfStrings,arrayOfStrings) {
println("All items match.")
} else {
println("Not all items match.")
}
// 输出 "All items match."
上面的例子创建一个 （编辑：李大同） 【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容! |