泛型到底是什么？
熟悉OC的朋友 一定对id 这个类型有所了解 这个就是个万能的类型 通过指针可以指向任何类
typedef struct objc_object *id;
struct objc_object { Class isa; };
OC有运行时 在运行期间 可以把任何类型传递给id类型 用的时候强转一下不就可以了
Swift是一门强类型的语言 系统要指定他的类型 才能做处理 比如我们写个两个值交换的方法
var oldValue = 1
var newValue = 2
changeValue(oldValue: &oldValue, newValue: &newValue)
print("oldValue === \(oldValue) newValue === (\(newValue))")
//inout 传递的参数内存地址
func changeValue(oldValue:inout Int , newValue:inout Int) {
let value = oldValue
oldValue = newValue
newValue = value
}
oldValue === 2 newValue === (1)
可以看出上面的方法 帮我们交换了两个值
这个时候如果 oldValue 想变成Double类型怎么办呢？
很简单我们在添加一个方法
func changeValue(oldValue:inout Double , newValue:inout Double)
这样问题解决了 但是如果有更多种类型 也想调用这个方法 我们难道要反复去创建同样的方法？ 这很显然代码冗余过高 特别封装共用类的时候 这样明显不可取 看看系统是怎么来帮我解决的吧。
数组 它可以添加各种值类型 来看看它的定义
public struct Array<Element>
<Element> 泛型定义格式
Element 就是一个泛型 可以是任何类型 系统推断出类型后 在指定类型 这样数组就可以添加各种值类型的数据。
我们来改善下上面的方法
func changeValue<Element>(oldValue:inout Element , newValue:inout Element) {
let value = oldValue
oldValue = newValue
newValue = value
}
var oldValue = 1
var newValue = 2
changeValue(oldValue: &oldValue, newValue: &newValue)
print("oldValue === \(oldValue) newValue === (\(newValue))")
var oldStr = "wo"
var newStr = "ni"
changeValue(oldValue: &oldStr , newValue: &newStr)
print("oldStr === \(oldStr ) newStr === (\(newStr))")
oldValue === 2 newValue === (1)
oldStr === ni newStr === (wo)
泛型<> 中间的名字采用驼峰法 可以任意指定名字
上面在方法中用到了泛型 下面我们来看泛型类型
struct Stack<Element> {
var items = [Element]()
//泛型类型
var firstItm:Element? {
return items.first
}
mutating func push(item:Element) {
items.append(item)
}
mutating func pop()->Element {
return items.removeLast()
}
}
var stack = Stack<String>()
stack.push(item: "2")
stack.push(item: "3")
stack.push(item: "4")
let removeValue = stack.pop()
print("removeValue = \(removeValue) firstValue = \(stack.firstItm ?? "")")
removeValue = 4 firstValue = 2
泛型可以作用任何类型 当然我们可以给他一定的约束 给它一个范围
public struct Dictionary<Key, Value> where Key : Hashable
来看下Dictionary的定义 key value两个泛型 where条件 Key : Hashable 给key 泛型一个约束 key必须是可哈希的
这个约束可以指定 某个类 某个协议
//协议约束使用 Swift标准库中定义了一个Equatable协议，该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持Equatable协议。
func findIndex<T:Equatable>(array:[T],valueToFind:T) -> Int? {
var index = 0
for value in array {
if value == valueToFind {
return index
} else {
index = index + 1
}
}
return nil
}
let doubleIndex = findIndex(array: [3.14159, 9.3, 0.25], valueToFind: 9.3)
if let index = doubleIndex {
print("查找到索引为:\(index)")
} else {
print("数组中没有对应数值")
}
查找到索引为:1
定义协议的时候 有时候想留有一个 可扩展的类型 后面我们可以赋予他任何类型来让我们使用 这个时候可以用到 关联类型 在我们后续使用的时候 想指定它是什么类型就是什么类型
定义一个协议 associatedtype 关联类型关键字
protocol Flysyer {
//声明一个关联类型 后续指定任何类型
associatedtype type
mutating func append(data:type)
var count:Int{get}
subscript(i:Int)->type{get}
}
var took = FlyTook<Double>()
took.append(data: 0.55)
took.append(data: 0.88)
print("data ======= \(took[1])")
data ======= 0.88
上面我们定义的类型都比较广泛 除了类型的约束 如果想进一步缩减类型范围 我们可以添加一些约束条件 通过 Where 这样定义的泛型类型更加准确 方便日后使用
系统中也有很多地方用到了where
public mutating func replaceSubrange<C>(_ subrange: Range<Int>, with newElements: C) where Element == C.Element, C : Collection
参照案例 我们也写个方法
func equalTwoValue<data:Flysyer , newData:Flysyer>(one:data,two:newData) where data.type == newData.type , data.type:Equatable {
var haveBool = false
var indexArr:[Int] = Array()
for i in 0..<one.count {
for y in 0..<two.count {
if one[i] == two[y] {
indexArr.append(i)
haveBool = true
}
}
}
if !haveBool {
print("查找不到相同数据")
}else {
print("查找到相同数据 下标在数组中----\(indexArr)")
}
}
var tookOne = FlyTook<Double>()
tookOne.append(data: 0.55)
tookOne.append(data: 0.66)
tookOne.append(data: 0.77)
tookOne.append(data: 0.88)
var tookTwo = FlyTook<Double>()
tookTwo.append(data: 0.77)
equalTwoValue(one: tookOne, two: tookTwo)
查找到相同数据 下标在数组中----[2]
