目录

• 版本
• 扩展
• 计算型属性
• 方法
• 构造器
• 下标
• 嵌套类型

版本

Xcode 11.3.1
Swift 5.1.3

扩展

扩展可以给一个现有的类、结构体、枚举、还有协议添加新的功能，但是不能重写已有的功能。
Swift 中的扩展可以：

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

语法

extension SomeType {
  // 在这里给 SomeType 添加新的功能
}

计算型属性

扩展可以给现有类型添加计算型实例属性和计算型类属性。
1. 计算型实例属性

extension Int {
    
    var add: Int {
        return self + 10
    }
    
    var sub: Int {
        return self - 10
    }
}

let addition = 15.add
let substraction = 15.sub
print(addition, substraction)
// 25 5

2. 计算型类属性

struct AA {
    static var num = 10
}

extension AA {
    static var aad: Int {
        return self.num + 10
    }
}

let aa = 5.add
print(aa)
// 15

之前说过， 扩展不能添加存储型属性。比如在上面的例子中，给 AA 的类属性 num 添加如下扩展，会导致编译报错：

    static var num: Int {
        return self.num + 10
    }

方法

扩展可以给现有类型添加新的实例方法和类方法。
1. 实例方法

class Counter {
    
    var count = 0
}

extension Counter {
    func increment() -> Int {
        return count + 1
    }
}

let counter = Counter()
let currentCount = counter.increment()
print(currentCount)
// 1

2. 类方法

extension Int {
    static func printFunc() {
        print("我被打印了")
    }
}

Int.printFunc()
// 我被打印了

构造器

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

struct Size {
    var width = 0.0, height = 0.0
}

struct Point {
    var x = 0.0, y = 0.0
}

struct Rect {
    var origin = Point()
    var size = Size()
}

extension Rect {
    init(center: Point, size: Size) {
        let originX = center.x - (size.width / 2)
        let originY = center.y - (size.height / 2)
        self.init(origin: Point(x: originX, y: originY), size: size)
    }
}

let centerRect = Rect(center: Point(x: 5.0, y: 5.0), size: Size(width: 4.0, height: 4.0))
print(centerRect.origin)
// Point(x: 3.0, y: 3.0)

因为 Rect 结构体给所有的属性 (origin和size) 都提供了默认值，所以它自动获得了一个默认构造器和一个成员构造器。这些构造器可以用来创建新的 Rect 实例。
这个新的构造器首先根据提供的 center 和 size 计算一个适当的原点。然后这个构造器调用结构体自带的成员构造器 init(origin:size:)，它会将新的 origin 和 size 值储存在适当的属性中。

下标

扩展可以给现有的类型添加新的下标。
下面的例子中，对 Swift 的 Int 类型添加了一个整数类型的下标。下标 [n] 从数字右侧开始，返回小数点后的第 n 位：

extension Int {
    subscript(digitIndex: Int) -> Int {
        var decimalBase = 1
        for _ in 0..<digitIndex {
            decimalBase *= 10
        }
        return (self / decimalBase) % 10
    }
}

print(123[0])
// 3
print(123[1])
// 2
print(123[2])
// 1

嵌套类型

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

extension Int {
    
   enum calculate
   {
      case add
      case sub
      case mult
   }

   var print: calculate {
      switch self
      {
         case 0:
            return .add
         case 1:
            return .sub
         default:
            return .mult
       }
   }
}

func result(numb: [Int]) {
   for i in numb {
      switch i.print {
         case .add:
            print("10")
          case .sub:
            print("20")
         case .mult:
            print("30")

      }
   }
}

result(numb: [1, 2, 0])
/**
 20
 30
 10
 */