專案地址 https://github.com/webabcd/IosDemo
作者 webabcd

望其項背 iOS - swift: extension 擴充套件：為指定型別擴充新的屬性，方法，下標，協議實現，巢狀型別，為指定結構體擴充新的初始化器，為指定類擴充新的初始化器，為指定型別新增泛型的型別約束（通過 where : 約束泛型屬於某個類或某個協議，通過 where == 約束泛型屬於某個值型別），為指定協議擴充新的邏輯（所有實現此協議的型別，都會自動擴充此處的新邏輯）

示例如下:

SwiftView14.swift

/*
 * 本例用於演示 extension 擴充套件
 * 為指定型別擴充新的屬性，方法，下標，協議實現，巢狀型別，為指定結構體擴充新的初始化器，為指定類擴充新的初始化器，為指定型別新增泛型的型別約束（通過 where : 約束泛型屬於某個類或某個協議，通過 where == 約束泛型屬於某個值型別），為指定協議擴充新的邏輯（所有實現此協議的型別，都會自動擴充此處的新邏輯）
 *
 * 注：extension 用於擴充某型別的功能，但是不能擴充新的可儲存的屬性，也不能 override 已有功能
 */

import SwiftUI

struct SwiftView14: View {
    
    var result: String = ""
    
    init() {
        result = sample1() // 為指定型別擴充新的屬性，方法，下標
        result += "\n"
        result += sample2() // 為指定型別擴充新的協議實現，巢狀型別，為指定結構體擴充新的初始化器
        result += "\n"
        result += sample3() // 為指定型別新增泛型的型別約束（通過 where : 約束泛型屬於某個類或某個協議，通過 where == 約束泛型屬於某個值型別），為指定類擴充新的初始化器
        result += "\n"
        result += sample4() // 為指定協議擴充新的邏輯（所有實現此協議的型別，都會自動擴充此處的新邏輯）
    }

    var body: some View {
        VStack {
            HStack {
                Text(result)
                Spacer()
            }
            Spacer()
        }
    }
    
    func sample1() -> String {
        let a = 3.14
        let b = a.intValue // 3
        let c = a.toInt() // 3
        let d = a[2] // 6
        
        return "\(b), \(c), \(d)"
    }

    func sample2() -> String {
        let a = SwiftView14_Struct1(age: 40)
        let b = a.name
        let c = a.getMessage()
        let d = a.getMyEnum()
        
        return "\(b), \(c), \(d)"
    }
    
    func sample3() -> String {
        let a = SwiftView14_Class1<String>(name: "webabcd")
        let b = a.name
        let c = a.age
        
        return "\(b), \(c)"
    }
    
    func sample4() -> String {
        let a = SwiftView14_Class2(name: "webabcd")
        let b = a.getMessage()
        
        return "\(b)"
    }
}


// 通過 extension 為指定型別擴充新的屬性，方法，下標
extension Double {
    var intValue: Int {
        return Int(self)
    }
    
    func toInt() -> Int {
        return Int(self)
    }
    
    subscript(a: Int) -> Int {
        return Int(self) * a
    }
}


protocol SwiftView14_Protocol1 {
    func getMessage() -> String
}
struct SwiftView14_Struct1 {
    var name: String = "webabcd"
}
// 通過 extension 為指定型別擴充新的協議實現，巢狀型別，為指定結構體擴充新的初始化器
extension SwiftView14_Struct1: SwiftView14_Protocol1 { // 擴充新的協議實現
    init(age: Int) { // 為結構體擴充新的初始化器（為類擴充新的初始化器會有一些不一樣，後面會說）
        self.name = "\(self.name) \(age)"
    }
    
    func getMessage() -> String {
        return self.name
    }
    
    func getMyEnum() -> MyEnum {
        return .e1
    }
    enum MyEnum { // 擴充新的巢狀型別
        case e1, e2, e3
    }
    
    // 注：不能擴充新的可儲存的屬性，比如下面這句會報錯 Extensions must not contain stored properties
    // var xxx = 100
}


class SwiftView14_Class1<T> {
    var name: T
    var age: Int
    init(name: T, age: Int) {
        self.name = name
        self.age = age
    }
}
// 通過 extension 為指定型別新增泛型的型別約束（通過 where : 約束泛型屬於某個類或某個協議），為指定類擴充新的初始化器
extension SwiftView14_Class1 where T: Equatable {
    // 注：不能擴充新的可儲存的屬性，比如下面這句會報錯 Extensions must not contain stored properties
    // var xxx = 100

    convenience init(name: T) { // 為類擴充新的初始化器
        // 注意：這裡訪問不了 self.name 之類的（extension 結構體是可以的），只能呼叫 self.init()，所以 init() 要用 convenience 修飾
        self.init(name: name, age: 100)
    }
}
// 通過 extension 為指定型別新增泛型的型別約束（通過 where == 約束泛型屬於某個值型別）
extension SwiftView14_Class1 where T == String {

}


protocol SwiftView14_Protocol2 {
    var name: String { get set }
}
struct SwiftView14_Class2: SwiftView14_Protocol2 {
    var name: String
}
// 通過 extension 為指定協議擴充新的邏輯（所有實現此協議的型別，都會自動擴充此處的新邏輯）
// 也就是說通過此方式可以在協議中實現具體邏輯，而在協議定義中是做不到這一點的
extension SwiftView14_Protocol2 {
    func getMessage() -> String {
        return self.name
    }
}

 

專案地址 https://github.com/webabcd/IosDemo
作者 webabcd