Swift 中的扩展
扩展就是向一个已有的类、结构体或枚举类型添加新功能，这包括在没有权限获取原始源代码的情况下扩展类型的能力。
扩展和 Objective-C中的分类（category）类似，但是它要比分类强大的多，它不仅可以扩展类，还可以扩展协议、枚举、结构体，另外扩展也不局限于扩展方法，还可以扩展便利构造方法、计算属性、下标脚本等
Swift中的扩展可以：

添加计算属性和计算静态属性
添加实例方法和类型方法
提供新的构造器
添加下标脚本
定义和使用新的嵌套类型

// 使用扩展需要使用到extension关键字,这里的SomeType可以是类、结构体、枚举、协议等类型
extension SomeType {
    // 添加到SomeType的新功能写在这里
}

// 一个扩展可以扩展一个已有类型,使其能够适配一个或多个协议
extension SomeType :SomeProtocol, AnotherProctocol {
    // 协议实现写到这里
}

扩展属性（只能是计算属性）

// 扩展系统结构体Double,添加计算属性
extension Double {
    var km:Double { return self * 1_000.0 }  // 计算只读属性的简化写法
    var m :Double { return self }
    var cm:Double { return self / 100.0 }
    var mm:Double { return self / 1_000.0 }
    var ft:Double { return self / 3.28084 }
}

var inch:Double = 25.4
let oneInch = inch.mm
print("One inch is \(oneInch) meters")
// 打印输出:One inch is 0.0254 meters

var feet:Double = 3.0
let threeFeet = feet.ft
print("Three feet is \(threeFeet) meters")
// 打印输出:Three feet is 0.914399970739201 meters

扩展实例方法和类型方法

//: Playground - noun: a place where people can play

import Foundation

// 向Int类型添加一个名为repetitions的新实例方法;
// 接受一个空参数无返回值的函数类型参数
extension Int {
    func repetitions(task: () ->()) {
        // 重复执行本身值次数的函数
        for _ in 0..<self {
            task()
        }
    }
    // 扩展类型方法
    static func number() ->[Int] {
        return [1,2,3]
    }
}

var value:Int = 3
value.repetitions({
    print("Hello World")
})

// 尾闭包简化
value.repetitions{
    print("extension")
}

print(Int.number())

// 运行结果
// Hello World
// Hello World
// Hello World
// extension
// extension
// extension
// [1, 2, 3]

扩展构造器

class Person {
    var firstName :String
    var lastName :String
    var age :Int = 0
    var fullName:String {
        get  {
            return firstName + " " + lastName
        }
    }
    
    init(firstName:String,lastName:String) {
        self.firstName = firstName
        self.lastName = lastName
    }
}

// 扩展该类,扩展便利构造器方法
extension Person {
    // 类类型只能扩展便利构造方法,不能扩展指定构造方法
    convenience init() {
        self.init(firstName:"",lastName:"")
    }
}

var p = Person()
p.firstName = "Chen"
p.lastName = "QP"
p.age = 18
print(p.fullName)  // //打印:Chen QP

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()
}

// 默认构造器方法
let defaultRect = Rect()
// 成员逐一构造器方法
let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0), size: Size(width: 5.0, height: 5.0))

extension Rect {
    // 这个新的构造器会根据提供的center和size值计算一个合适的原点
    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: 4.0, y: 4.0), size: Size(width: 3.0, height: 3.0))
// centerRect的原点是 (2.5, 2.5),大小是 (3.0, 3.0)

类类型只能扩展便利构造方法，不能扩展指定构造方法
值类型扩展指定构造方法访问默认构造方法和成员逐一构造器的条件是：
保证存储属性都有值（一般需要调用默认构造方法或成员逐一构造方法）
在源类型中没有定义该指定构造器方法

扩展下标脚本

// 为系统类型Int添加扩展
extension Int {
    // 为系统类型Int添加扩展
    subscript(digitIndex:Int) ->Int {
        var decimalBase = 1
        for _ in 0..<digitIndex {
            decimalBase *= 10
        }
        return  (self/decimalBase) % 10
    }
}

var value:Int = 1234567
print(value[0]) // 结果:7
print(value[1]) // 结果:6
print(value[2]) // 结果:5
print(value[3]) // 结果:4
print(value[4]) // 结果:3
print(value[5]) // 结果:2
print(value[6]) // 结果:1

扩展嵌套类型

//: Playground - noun: a place where people can play

import Foundation

// 为系统类型Character添加扩展
extension Character {
    // 扩展嵌套类型，表示元音、辅音、其他
    enum Kind {
        case Vowel,Consonant,Other
    }
    
    // 扩展计算属性
    var kind :Kind {
        // 转为小写后进行元辅音匹配
        switch String(self).lowercaseString {
            case "a", "e", "i", "o", "u":
            return .Vowel
        case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",
        "n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":
            return .Consonant
        default:
            return .Other
        }
    }
}

var word = "Hello"
// 遍历字符串的所有字符
for character in word.characters {
    switch character.kind {
    case .Vowel:  // 因为kind属性指定了类型,是Character.Kind.Vowel的简化
        print("\(character)是元音")
    case .Consonant:
        print("\(character)是辅音")
    case .Other:
        print("\(character)是其他")
    }
}

// 运行结果：
// H是辅音
// e是元音
// l是辅音
// l是辅音
// o是元音

灵活使用Swift的扩展，可以提高我们的编码效率，就像我们在OC中积累项目经验，有一些东西会已分类的形式进行积累，可以方便我们移植到其他项目中，提高我们的效率，Swift扩展就是比这个更加强大的存在，没理由不用.