Swift Extension

/*  

    Extension

 

*/

class C{}

protocol someProtocol{}

protocol anotherProtocol{}

// extend protocol conformance

extension C:someProtocol,anotherProtocol{

    //do something to conform the protocol

}

// extend computed property

extension C{

    var number:Int{

        return self.number*2

    }

}

extension Double{

    var km :Double { return self * 1_000.00 }

}

var qianmi = 25.3.km

print(qianmi)

/*  extend initializer,

    only convenience initializer for class not for struct

*/

/*

struct Point{

    var x=0,y=0

}

struct Size{

    var long=5,width=5

}

struct Rect{ // if I put class here it will fail

    var point:Point=Point()

    var size:Size=Size()

}

extension Rect{

    init(center:Point,size:Size){

        let orix=center.x - (size.long/2)

        let oriy=center.y - (size.width/2)

        self.init(point:Point(x:orix,y:oriy),size:size)

    }

}

 

 

*/

struct Size {

    var width = 0.0, height = 0.0

}

struct Point {

    var x = 0.0, y = 0.0

}

class Rect {

    var origin = Point()

    var size = Size()

}

extension Rect {

    convenience init(center: Point, size: Size) {

        let originX = center.x - (size.width / 2)

        let originY = center.y - (size.height / 2)

        self.init(center: Point(x: originX, y: originY), size: size)

    }

}

/*

    Extension on method

 

*/

extension Int{

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

        for _ in 0..<self{

            foo()

        }

    }

}

extension String{

    func foo(){

        print(self + self)

    }

}

var a="god damn it"

a.foo()

a.self

3.self

3.repetitions {

    print("hey")

    //print(self)

    // because this code block don't belong to 3 itself

    // hence you can't put self here, because it's undeclared

}

// Extension on method to mutate instance itself

extension Int{

     mutating func double(){

        self=self*2 // because by default, self is immutable

    }

}

/*

    extension for subscript

 */

extension Int{

    subscript(index:Int) -> Int {

        var decimalBase = 1

        for _ in 0 ..< index{

            decimalBase *= 10

        }

        return (self/decimalBase)%10

    }

}

12345[0]

12345[1]

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 printType(_ numbers: [Int]){

    for i in numbers{

        switch i.kind {

        case .negative:

            print("- ",terminator:"")

        case .positive:

            print("+ ",terminator:"")

        case .zero:

            print("0 ",terminator:"")

        }

    }

}

printType([-2,51,0,542,-4])