iOS学习笔记47 Swift(七)泛型-白红宇

一、Swift泛型介绍

泛型是为Swift编程灵活性的一种语法，在函数、枚举、结构体、类中都得到充分的应用，它的引入可以起到占位符的作用，当类型暂时不确定的，只有等到调用函数时才能确定具体类型的时候可以引入泛型。

我们之前实际上已经使用过泛型，例如：Swift的Array和Dictionary类型都是泛型集。

你可以创建一个Int数组，也可创建一个String数组，或者甚至于可以是任何其他Swift的类型数据数组。同样的，你也可以创建存储任何指定类型的字典(Dictionary)，而且这些类型可以是没有限制的。

我们为什么要使用泛型呢？下面有个例子可以简单说明使用泛型的好处

//定义一个函数，要求追加数组数据到指定一个数组中func appendIntToArray(src:[Int],inout dest:[Int]){	// 遍历并加到数组后边	for element in src{		dest.append(element)	}}//使用copyIntArray添加整形数组数据var arr = [2,5]appendIntToArray([12,9], dest: &arr)print(arr) // [2,5,12,9]//那么再要求让你实现添加字符串呢，好吧重写一个func appendStringToArray(src:[String],inout dest:[String]){	for element in src{		dest.append(element)	}}//使用copyStringArray添加字符串数组数据var strArr = ["oc","swift"]appendStringToArray(["php", "C#"], dest: &strArr)print(strArr) // ["oc", "swift", "php", "C#"]//如果有需要你实现添加其他类型呢？//是不是每个类型都需要写一个对应的函数去实现，那这样就太复杂了！这时候我们就需要使用泛型//定义泛型函数，在普通函数名后面加上
    
     ，T是个类型占用符，可以表示任何类型func appendArray
     
      (src:[T],inout dest:[T]){	for element in src	{		dest.append(element)	}}//看到如此强大了吧？然后随意使用var arr2 = [5,8]appendArray([9,58], dest: &arr2) //appendArray自动识别要添加的数组数据类型print(arr2) //[5, 8, 9, 58]var strArr2 = ["renhairui","hello"]appendArray(["nihao", "helloworld"], dest: &strArr2)print(strArr2) //["renhairui", "hello", "nihao", "helloworld"]var doubleArr = [1.2,3.4]appendArray([6.5,1.0], dest: &doubleArr)print(doubleArr) //[1.2, 3.4, 6.5, 1.0]复制代码

我的理解：泛型就是先占坑，具体占坑做什么，随你

二、Swift泛型使用

Swift泛型相关使用可分为以下几点：

泛型函数

泛型类型

泛型约束

泛型协议

1. 泛型函数，函数参数或返回值类型用泛型表示

//泛型函数定义式func 函数名
    <泛型1,泛型2,…>
     (形参列表)->返回值类型{    //函数体...}复制代码

泛型函数使用实例

//定义一个泛型函数，把2个参数的值进行交换func swapTwoValues
    
     (inout valueOne: T, inout valueTwo: T) {	let temporaryA = valueOne	valueOne = valueTwo	valueTwo = temporaryA}//交换2个整形变量var oneInt = 3var twoInt = 107swapTwoValues(&oneInt, valueTwo: &twoInt)print("oneInt = \(oneInt), twoInt = \(twoInt)")//打印：oneInt = 107, twoInt = 3//交换2个字符串变量var oneStr = "hello"var twoStr = "world"swapTwoValues(&oneStr, valueTwo: &twoStr)print("oneStr = \(oneStr), twoStr = \(twoStr)")//打印：oneStr = world, twoStr = hello复制代码

2. 泛型类型，在定义类型时使用泛型

使用也和泛型函数差不多，就是在类型名后面加上<泛型1,泛型2,…>，然后在类型里面直接使用泛型即可

//定义一个泛型结构体，用于压栈和出栈，泛型类型可以使用到类、结构体、枚举等各种类型struct Stack
    
      {	//栈在这里是个数组存储形式，数组中存储的数据类型是泛型类型    var items = [T]()	//因为压栈会修改实例值，需要加上mutationg关键字    mutating func push(item: T) {        items.append(item)    }	//因为出栈会修改实例值，需要加上mutationg关键字    mutating func pop() -> T {        return items.removeLast()    }}//创建一个字符串栈，栈里面存的是字符串var stackOfStrings = Stack
     
      ()stackOfStrings.push("uno")stackOfStrings.push("dos")stackOfStrings.push("tres")stackOfStrings.push("cuatro")print("出栈：\(stackOfStrings.pop())，栈中还剩：\(stackOfStrings.items)")print("出栈：\(stackOfStrings.pop())，栈中还剩：\(stackOfStrings.items)")print("出栈：\(stackOfStrings.pop())，栈中还剩：\(stackOfStrings.items)")/* 打印：出栈：cuatro，栈中还剩：["uno", "dos", "tres"]出栈：tres，栈中还剩：["uno", "dos"]出栈：dos，栈中还剩：["uno"]*///创建一个整形栈，栈里面存的是整形var stackOfInt = Stack
      
       ()stackOfInt.push(12)stackOfInt.push(32)stackOfInt.push(45)stackOfInt.push(35)print("出栈：\(stackOfInt.pop())，栈中还剩：\(stackOfInt.items)")print("出栈：\(stackOfInt.pop())，栈中还剩：\(stackOfInt.items)")print("出栈：\(stackOfInt.pop())，栈中还剩：\(stackOfInt.items)")/* 打印：出栈：35，栈中还剩：[12, 32, 45]出栈：45，栈中还剩：[12, 32]出栈：32，栈中还剩：[12]*/复制代码

3. 泛型约束，为泛型类型添加约束

泛型约束大致分为以下几种：

继承约束，泛型类型必须是某个类的子类类型

协议约束，泛型类型必须遵循某些协议

条件约束，泛型类型必须满足某种条件

约束的大概使用格式

//继承约束使用格式func 函数名
    <泛型: 继承父类>
     (参数列表) -> 返回值 {    //函数体，泛型类型是某个类的子类类型}//协议约束使用格式func 函数名
     <泛型: 协议>
      (参数列表) -> 返回值 {    //函数体，泛型类型遵循某些协议}//条件约束使用格式func 函数名
      <泛型1, 泛型2 where 条件>
       (参数列表) -> 返回值 {    //函数体，泛型类型满足某些条件}复制代码

继承约束使用范例

//定义一个父类，动物类class Animal{	//动物都会跑	func run(){		print("Animal run")	}}//定义狗类，继承动物类class Dog: Animal {	override func run(){
   //重写父类方法		print("Dog run")	}}//定义猫类，继承动物类class Cat: Animal {	override func run(){
   //重写父类方法		print("Cat run")	}}//定义泛型函数，接受一个泛型参数，要求该泛型类型必须继承Animalfunc AnimalRunPint
    
     (animal:T){	animal.run() //继承了Animal类的子类都有run方法可以调用}AnimalRunPint(Dog())AnimalRunPint(Cat())/* 打印：Dog runCat run*/复制代码

协议约束使用范例

Swift标准库中定义了一个Equatable协议，该协议要求任何遵循的类型实现等式符(==)和不等符(!=)对任何两个该类型进行比较。所有的Swift标准类型自动支持Equatable协议。

//定义泛型函数，为泛型添加协议约束，泛型类型必须遵循Equatable协议func findIndex
    
     (array: [T], valueToFind: T) -> Int? {	var index = 0    for value in array {        if value == valueToFind {
   //因为遵循了Equatable协议，所以可以进行相等比较            return index        } else {			index++		}    }    return nil}//在浮点型数组中进行查找，Double默认遵循了Equatable协议let doubleIndex = findIndex([3.14159, 0.1, 0.25], valueToFind: 9.3)if let index = doubleIndex {	print("在浮点型数组中寻找到9.3，寻找索引为\(index)")} else {	print("在浮点型数组中寻找不到9.3")}//在字符串数组中进行查找，String默认遵循了Equatable协议let stringIndex = findIndex(["Mike", "Malcolm", "Andrea"], valueToFind: "Andrea")if let index = stringIndex {	print("在字符串数组中寻找到Andrea，寻找索引为\(index)")} else {	print("在字符串数组中寻找不到Andrea")}/* 打印：在浮点型数组中寻找不到9.3在字符串数组中寻找到Andrea，寻找索引为2*/复制代码

4. 泛型协议和条件约束

上面的Equatable协议实际上不是普通的协议，而是泛型协议，假设泛型类型必须遵循一个协议，此时就必须在协议中引入一个关联类型来解决。

//定义一个泛型协议，和其他泛型使用方式不同，这里泛型是以关联类型形式使用的protocol Stackable{    //声明一个关联类型，使用typealias关键字    typealias ItemType    mutating func push(item:ItemType)    mutating func pop() -> ItemType} struct Stack
    
     :Stackable{    var store = [T]()    mutating func push(item:T){
   //实现协议的push方法要求        store.append(item)    }    mutating func pop() -> T {
   //实现协议的pop方法要求        return store.removeLast()    }}//创建Stack结构体，泛型类型为Stringvar stackOne = Stack
     
      ()stackOne.push("hello")stackOne.push("swift")stackOne.push("world")let t = stackOne.pop()print("t = \(t)") //结果：t = world//添加泛型条件约束，C1和C2必须遵循Stackable协议，而且C1和C2包含的泛型类型要一致func pushItemOneToTwo
      
       (inout stackOne: C1, inout stackTwo: C2) {
   //因为C1和C2都遵循了Stackable协议，才有ItemType属性可以调用	let item = stackOne.pop()	stackTwo.push(item)}//定义另外一个结构体类型，同样实现Stackable协议，实际上里面的实现和Stack一样struct StackOther
       
        : Stackable{    var store = [T]()    mutating func push(item:T){
   //实现协议的push方法要求        store.append(item)    }    mutating func pop() -> T {
   //实现协议的pop方法要求        return store.removeLast()    }}//创建StackOther结构体，泛型类型为Stringvar stackTwo = StackOther
        
         ()stackTwo.push("where")//虽然stackOne和stackTwo类型不一样，但泛型类型一样，也同样遵循了Stackable协议pushItemOneToTwo(&stackOne, stackTwo: &stackTwo )print("stackOne = \(stackOne.store), stackTwo = \(stackTwo.store)")//打印：stackOne = ["hello"], stackTwo = ["where", "swift"]复制代码