iOS學習筆記47 Swift(七)泛型

執著丶執念發表於2018-06-02
iOS筆記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>，T是個型別佔用符，可以表示任何型別
func appendArray<T>(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. 泛型函式
  2. 泛型型別
  3. 泛型約束
  4. 泛型協議
1. 泛型函式，函式引數或返回值型別用泛型表示
//泛型函式定義式
func 函式名<泛型1,泛型2,…>(形參列表)->返回值型別
{
    //函式體...
}
複製程式碼
泛型函式使用例項
//定義一個泛型函式，把2個引數的值進行交換
func swapTwoValues<T>(inout valueOne: T, inout valueTwo: T) {
	let temporaryA = valueOne
	valueOne = valueTwo
	valueTwo = temporaryA
}
//交換2個整形變數
var oneInt = 3
var twoInt = 107
swapTwoValues(&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<T> {
	//棧在這裡是個陣列儲存形式，陣列中儲存的資料型別是泛型型別
    var items = [T]()
	//因為壓棧會修改例項值，需要加上mutationg關鍵字
    mutating func push(item: T) {
        items.append(item)
    }
	//因為出棧會修改例項值，需要加上mutationg關鍵字
    mutating func pop() -> T {
        return items.removeLast()
    }
}
//建立一個字串棧，棧裡面存的是字串
var stackOfStrings = Stack<String>()
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<Int>()
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. 泛型約束，為泛型型別新增約束

泛型約束大致分為以下幾種：
  1. 繼承約束，泛型型別必須是某個類的子類型別
  2. 協議約束，泛型型別必須遵循某些協議
  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")
	}
}
//定義泛型函式，接受一個泛型引數，要求該泛型型別必須繼承Animal
func AnimalRunPint<T:Animal>(animal:T){
	animal.run() //繼承了Animal類的子類都有run方法可以呼叫
}
AnimalRunPint(Dog())
AnimalRunPint(Cat())
/* 列印：
Dog run
Cat run
*/
複製程式碼
協議約束使用範例

Swift標準庫中定義了一個Equatable協議，該協議要求任何遵循的型別實現等式符(==)和不等符(!=)對任何兩個該型別進行比較。所有的Swift標準型別自動支援Equatable協議。

//定義泛型函式，為泛型新增協議約束，泛型型別必須遵循Equatable協議
func findIndex<T: Equatable>(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<T>:Stackable{
    var store = [T]()
    mutating func push(item:T){//實現協議的push方法要求
        store.append(item)
    }
    mutating func pop() -> T {//實現協議的pop方法要求
        return store.removeLast()
    }
}
//建立Stack結構體，泛型型別為String
var stackOne = Stack<String>()
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<C1: Stackable, C2: Stackable 
		where C1.ItemType == C2.ItemType>(inout stackOne: C1, inout stackTwo: C2) 
{//因為C1和C2都遵循了Stackable協議，才有ItemType屬性可以呼叫
	let item = stackOne.pop()
	stackTwo.push(item)
}
//定義另外一個結構體型別，同樣實現Stackable協議，實際上裡面的實現和Stack一樣
struct StackOther<T>: Stackable{
    var store = [T]()
    mutating func push(item:T){//實現協議的push方法要求
        store.append(item)
    }
    mutating func pop() -> T {//實現協議的pop方法要求
        return store.removeLast()
    }
}
//建立StackOther結構體，泛型型別為String
var stackTwo = StackOther<String>()
stackTwo.push("where")
//雖然stackOne和stackTwo型別不一樣，但泛型型別一樣，也同樣遵循了Stackable協議
pushItemOneToTwo(&stackOne, stackTwo: &stackTwo )
print("stackOne = \(stackOne.store), stackTwo = \(stackTwo.store)")
//列印：stackOne = ["hello"], stackTwo = ["where", "swift"]
複製程式碼

有什麼問題可以在下方評論區中提出！O(∩_∩)O哈！

相關文章