swift扩展extension – Swift最新教程

上一章Swift教程请查看：swift类型转换

现有类、结构或枚举类型的功能可以在扩展的帮助下添加，可以使用扩展添加类型功能，但无法使用扩展覆盖功能。

Swift扩展功能

• 添加计算属性和计算类型属性
• 定义实例和类型方法。
• 提供新的初始值设定项。
• 定义下标
• 定义和使用新的嵌套类型
• 使现有类型符合协议

扩展用关键字“extension”声明

语法

extension SomeType {
    // 可以在这里添加新功能
 }

现有类型还可以通过扩展添加，使其成为协议标准，其语法类似于类或结构的语法。

extension SomeType: SomeProtocol, AnotherProtocol {
    // 这里描述了协议需求
 }

计算属性

计算的“实例”和“类型”属性也可以在扩展的帮助下扩展。

extension Int {
    var add: Int {return self + 100 }
    var sub: Int { return self - 10 }
    var mul: Int { return self * 10 }
    var div: Int { return self / 5 }
 }
 
 let addition = 3.add
 print("+ \(addition)")
 
 let subtraction = 120.sub
 print("- \(subtraction)")
 
 let multiplication = 39.mul
 print("x \(multiplication)")
 
 let division = 55.div
 print("/ \(division)")
 
 let mix = 30.add + 34.sub
 print("混合 \(mix)")

初始化器

Swift提供了通过扩展向现有类型添加新初始化器的灵活性。用户可以添加自己的自定义类型来扩展已经定义的类型，还可以添加其他初始化选项。扩展只支持init()，扩展不支持deinit()。

struct sum {
    var num1 = 100, num2 = 200
 }
 
 struct diff {
    var no1 = 200, no2 = 100
 }
 
 struct mult {
    var a = sum()
    var b = diff()
 }
 
 let calc = mult()
 print ("x block \(calc.a.num1, calc.a.num2)")
 print("x block \(calc.b.no1, calc.b.no2)")
 
 let memcalc = mult(a: sum(num1: 300, num2: 500),b: diff(no1: 300, no2: 100))
 print("x block \(memcalc.a.num1, memcalc.a.num2)")
 print("x block \(memcalc.b.no1, memcalc.b.no2)")
 
 extension mult {
    init(x: sum, y: diff) {
       let X = x.num1 + x.num2
       let Y = y.no1 + y.no2
    }
 }
 
 let a = sum(num1: 100, num2: 200)
 print("sum Block:\( a.num1, a.num2)")
 
 let b = diff(no1: 200, no2: 100)
 print("diff Block: \(b.no1, b.no2)")

方法

在扩展的帮助下，新的实例方法和类型方法可以进一步添加到子类中。

extension Int {
    func topics(summation: () -> ()) {
       for _ in 0..<self {
          summation()
       }
    }
 }
 
 4.topics(summation: {
    print("扩展Block")
 })
 
 3.topics(summation: {
    print("类型转换Block")
 })

topics()函数接受类型为'(sum:()→())’的参数，以表示该函数不接受任何参数，也不返回任何值。要多次调用该函数，需要初始化for块，并初始化对带有topic()的方法的调用。

变异的实例方法

实例方法也可以在声明为扩展时进行修改。

修改self或其属性的结构和枚举方法必须将实例方法标记为突变，就像对原始实现中的方法进行突变一样。

extension Double {
    mutating func square() {
       let pi = 3.1415
       self = pi * self * self
    }
 }
 
 var Trial1 = 3.3
 Trial1.square()
 print("Area: \(Trial1)")
 
 var Trial2 = 5.8
 Trial2.square()
 print("Area: \(Trial2)")
 
 var Trial3 = 120.3
 Trial3.square()
 print("Area: \(Trial3)")

下标

通过扩展也可以向已经声明的实例添加新的下标。

extension Int {
    subscript(var multtable: Int) -> Int {
       var no1 = 1
       while multtable > 0 {
          no1 *= 10
          --multtable
       }
       return (self / no1) % 10
    }
 }
 
 print(12[0])
 print(7869[1])
 print(786543[2])

嵌套类型

类、结构和枚举实例的嵌套类型也可以在扩展的帮助下扩展。

extension Int {
    enum calc {
       case add
       case sub
       case mult
       case div
       case anything
    }
    var print: calc {
       switch self {
          case 0:
             return .add
          case 1:
             return .sub
          case 2:
             return .mult
          case 3:
             return .div
          default:
             return .anything
       }
    }
 }
 
 func result(numb: [Int]) {
    for i in numb {
       switch i.print {
          case .add:
             print(" 10 ")
          case .sub:
             print(" 20 ")
          case .mult:
             print(" 30 ")
          case .div:
             print(" 40 ")
          default:
             print(" 50 ")
       }
    }
 }
 result(numb: [0, 1, 2, 3, 4, 7])