Swift3 扩展( extension )

Swift 提供了 extension 关键字为一个已有的类、结构体或枚举类型添加扩展，添加新功能

扩展可以对一个类型添加新的功能，但是不能重写已有的功能

Swift 中的扩展可以：

  • 添加计算型属性和计算型静态属性
  • 定义实例方法和类型方法
  • 提供新的构造器
  • 定义下标
  • 定义和使用新的嵌套类型
  • 使一个已有类型符合某个协议

语法

Swift 使用 extension 关键字声明扩展的语法格式如下

  1. extension SomeType
  2. {
  3.     //加到 SomeType 的新功能写到这里
  4. }

一个扩展可以扩展一个已有类型，使其能够适配一个或多个协议，语法格式如下：

  1. extension SomeType: SomeProtocol, AnotherProctocol
  2. {
  3.     // 协议实现写到这里
  4. }

计算型属性

扩展(extension) 可以向已有类型添加计算型实例属性和计算型类型属性

下面的代码向 Int 类型添加了 5 个计算型实例属性并扩展其功能

  1. import Cocoa
  3. extension Int
  4. {
  5.    var add: Int { return self + 10 }
  6.    var sub: Int { return self - 10 }
  7.    var mul: Int { return self * 10 }
  8.    var div: Int { return self / 10 }
  9. }
  11. let addition = 5.add
  12. print("加法运算后的值：\(addition)")
  14. let subtraction = 100.sub
  15. print("减法运算后的值：\(subtraction)")
  17. let multiplication = 49.mul
  18. print("乘法运算后的值：\(multiplication)")
  20. let division = 60.div
  21. print("除法运算后的值: \(division)")
  23. let mix = 40.add + 45.sub
  24. print("混合运算结果：\(mix)")

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 加法运算后的值：15
  3. 减法运算后的值：90
  4. 乘法运算后的值：490
  5. 除法运算后的值: 6
  6. 混合运算结果：85

使用 extension 添加构造器

扩展可以向已有类型添加新的构造器

新的构造器可以让我们扩展其它类型，将你自己的定制类型作为构造器参数，或者提供该类型的原始实现中没有包含的额外初始化选项

扩展可以向类中添加新的便利构造器 init()，但是它们不能向类中添加新的指定构造器或析构函数 deinit() 

  1. import Cocoa
  3. struct sum
  4. {
  5.     var first  = 100
  6.     var second = 200
  7. }
  9. struct diff
  10. {
  11.     var first_num = 200
  12.     var second_num = 100
  13. }
  15. struct mult
  16. {
  17.     var aa = sum()
  18.     var bb = diff()
  19. }
  22. extension mult
  23. {
  24.     init(x: sum, y: diff)
  25.     {
  26.         _ = x.first + x.second
  27.         _ = y.first_num + y.second_num
  28.     }
  29. }
  32. let sum_n  = sum(first: 200, second: 500)
  33. let diff_n = diff(first_num: 100, second_num: 500)
  35. let mult_r = mult(x: sum_n, y: diff_n)
  36. print("Mult sum\(mult_r.aa.first, mult_r.aa.second)")
  37. print("Mult diff\(mult_r.bb.first_num, mult_r.bb.second_num)")

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. Mult sum(100, 200)
  3. Mult diff(200, 100)

使用 extension 添加方法

扩展可以向已有类型添加新的实例方法和类型方法

下面的代码向 Int 类型添加一个名为 topics 的新实例方法

  1. import Cocoa
  3. extension Int
  4. {
  5.     func title (_ summation: () -> ())
  6.     {
  7.         for _ in 0..<self {
  8.             summation()
  9.         }
  10.     }
  11. }
  13. 2.title({print("扩展模块内")})
  15. 3.title({print("内型转换模块内")})

title 方法使用了一个没有参数也没有返回值得 () -> () 类型的单参数

给 Int 定义该扩展之后，我们就可以对任意整数调用 title方法,实现的功能则是多次执行某任务：

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 扩展模块内
  3. 扩展模块内
  4. 内型转换模块内
  5. 内型转换模块内
  6. 内型转换模块内

使用 extension 添加可改变实例属性方法

可以通过扩展添加的实例方法也可以修改该实例本身

结构体和枚举类型中修改 self 或 属性 的方法必须将该实例方法标注为 mutating

下面的代码向 Swift 的 Int 类型添加了一个新的名为 square 的修改方法，来实现原始值的平方计算

  1. import Cocoa
  3. extension Int
  4. {
  5.     mutating func square()
  6.     {
  7.         self = self * self
  8.     }
  9. }
  11. var num1 = 9
  12. num1.square()
  13. print("9 的平方为: \(num1)")
  16. var num2 = 7
  17. num2.square()
  18. print("5 的平方为: \(num2)")
  21. var num3 = 180
  22. num3.square()
  23. print("180 的平方为: \(num3)")

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 9 的平方为: 81
  3. 5 的平方为: 49
  4. 180 的平方为: 32400

使用 extension 添加索引下标

使用 extension 扩展可以向一个已有类型添加新下标，使得我们的类实例可以像访问数组元素一样用下标来索引值

索引下标从 0 开始

下面的代码向类型 Int 添加了一个整型下标索引下标 [n] 返回对应位数的数字

  1. import Cocoa
  3. extension Int
  4. {
  5.     subscript(multtable: Int) -> Int
  6.     {
  7.         var step = 1
  8.         var bit = multtable
  9.         while bit > 0 {
  10.             step *= 10
  11.             bit = bit-1
  12.         }
  13.         return (self / step ) % 10
  14.     }
  15. }
  17. print(120[0])
  18. print(985[1])
  19. print(2048576[3])

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. 0
  3. 8
  4. 8

使用 extension 添加嵌套类型

扩展可以向已有的类、结构体和枚举添加新的嵌套类型

  1. import Cocoa
  3. extension Int
  4. {
  5.     enum calc
  6.     {
  7.         case add
  8.         case sub
  9.         case mult
  10.         case div
  11.         case anything
  12.     }
  14.     var print: calc 
  15.     {
  16.         switch self
  17.         {
  18.         case 0:
  19.             return .add
  20.         case 1:
  21.             return .sub
  22.         case 2:
  23.             return .mult
  24.         case 3:
  25.             return .div
  26.         default:
  27.             return .anything
  28.         }
  29.     }
  30. }
  32. func result(_ numb: [Int])
  33. {
  34.     for i in numb {
  35.         switch i.print {
  36.         case .add:
  37.             print("add ")
  38.         case .sub:
  39.             print("sub ")
  40.         case .mult:
  41.             print("mult ")
  42.         case .div:
  43.             print("div ")
  44.         default:
  45.             print("no design ")
  47.         }
  48.     }
  49. }
  51. result([0, 1, 2, 3, 4, 7])

编译运行以上 Swift 范例，输出结果为

  1. $ swift main.swift
  2. add 
  3. sub 
  4. mult 
  5. div 
  6. no design 
  7. no design