//扩展（Extensions）

import UIKit

/*扩展（Extensions）:扩展 就是为一个已有的类、结构体、枚举类型或者协议类型添加新功能。这包括在没有权限获取原始源代码的情况下扩展类型的能力（即 逆向建模 ）

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

    1.添加计算型属性和计算型类型属性,扩展可以添加新的计算型属性，但是不可以添加存储型属性，也不可以为已有属性添加属性观察器

    2.定义实例方法和类型方法

    3.提供新的构造器:

        1.扩展能为类添加新的便利构造器，但是它们不能为类添加新的指定构造器或析构器。指定构造器和析构器必须总是由原始的类实现来提供。

        2.如果你使用扩展为一个值类型添加构造器，且该值类型的原始实现中未定义任何定制的构造器时，你可以在扩展中的构造器里调用逐一成员构造器。如果该值类型为所有存储型属性提供了默认值，你还可以在扩展中的构造器里调用默认构造器。

    4.扩展可以为已有类型添加新下标

    5.定义和使用新的嵌套类型

    6.使一个已有类型符合某个协议

在 Swift 中，你甚至可以对协议进行扩展，提供协议要求的实现，或者添加额外的功能，从而可以让符合协议的类型拥有这些功能

扩展语法（Extension Syntax）:可以通过扩展来扩展一个已有类型，使其采纳一个或多个协议

extension SomeType: SomeProtocol, AnotherProctocol { // 为 SomeType 添加的新功能写到这里 }

如果你通过扩展为一个已有类型添加新功能，那么新功能对该类型的所有已有实例都是可用的，即使它们是在这个扩展定义之前创建的

*/

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 }

}

let oneInch = 25.4.mm

print("One inch is \(oneInch) meters")

// 打印 “One inch is 0.0254 meters”

let threeFeet = 3.ft

print("Three feet is \(threeFeet) meters")

// 打印 “Three feet is 0.914399970739201 meters”

let aMarathon = 42.km + 195.m

print("A marathon is \(aMarathon) meters long")

// 打印 “A marathon is 42195.0 meters long”

//==============================

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

}

//因为结构体 Rect 未提供定制的构造器，因此它会获得一个逐一成员构造器。又因为它为所有存储型属性提供了默认值，它又会获得一个默认构造器

let defaultRect = Rect()

let memberwiseRect = Rect(origin: Point(x: 2.0, y: 2.0),

    size: Size(width: 5.0, height: 5.0))

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: 4.0, y: 4.0),

    size: Size(width: 3.0, height: 3.0))

// centerRect 的原点是 (2.5, 2.5)，大小是 (3.0, 3.0)

//================================

extension Int {

    func repetitions(task: () -> Void) {

        for _ in 0..<self {

            task()

        }

    }

}

3.repetitions({

    print("Hello!")

})

// Hello!

// Hello!

// Hello!

//通过扩展添加的实例方法也可以修改该实例本身。结构体和枚举类型中修改 self 或其属性的方法必须将该实例方法标注为 mutating，正如来自原始实现的可变方法一样

extension Int {

    mutating func square() {

        self = self * self

    }

}

var someInt = 3

someInt.square()

print(someInt)

// someInt 的值现在是 9

//===================================

extension Int {

    subscript(var digitIndex: Int) -> Int {

        var decimalBase = 1

        while digitIndex > 0 {

            decimalBase *= 10

            --digitIndex

        }

        return (self / decimalBase) % 10

    }

}

746381295[0]

// 返回 5

746381295[1]

// 返回 9

746381295[2]

// 返回 2

746381295[8]

// 返回 7

746381295[9]

// 返回 0，即等同于：

0746381295[9]

//===============================

extension Int {

    enum Kind {

        case Negative, Zero, Positive

    }

    var kind: Kind {

        switch self {

        case 0:

            return .Zero

        case let x where x > 0:

            return .Positive

        default:

            return .Negative

        }

    }

}

func printIntegerKinds(numbers: [Int]) {

    for number in numbers {

        switch number.kind {

        case .Negative:

            print("- ", terminator: "")

        case .Zero:

            print("0 ", terminator: "")

        case .Positive:

            print("+ ", terminator: "")

        }

    }

    print("")

}

printIntegerKinds([3, 19, -27, 0, -6, 0, 7])

// 打印 “+ + - 0 - 0 +”