convenience:

用在init方法之前。所有的convenience初始化方法都必须调用同一个类中的 designated 初始化完成设置，另外convenience的初始化方法是不能被子类重写或者是从子类中以super的方式被调用的。

class ClassA {
            let numA: Int
            init(num: Int) {
                numA = num
            }
            convenience init(bigNum: Bool) {
                self.init(num: bigNum ? 10000 : 1)
            }
        }
        class ClassB: ClassA {
            let numB: Int
            
            override init(num: Int) {
                numB = num + 1
                super.init(num: num)
            }
        }

只要在子类中实现重写了父类 convenience方法所需要的 init方法的话，我们在子类中就也可以使用父类的 convenience初始化方法了

guard

判断属性是否存在，如果不存在，可以做一些操作

        func apply() -> Bool {
            
            guard let image = UIImage(named:"some")
                else { return false }
            
            ...
            
        }
        

这里的 guard关键字，判读了 UIImage 是否创建成功，如果没有创建成功，在 else 分支中会将函数直接返回。

where

where
关键字的用处非常广泛，在 switch语句，catch分支语句或者条件语句比如 if, while, guard, for-in或者来限制类型的时候。
for-in

    let arr = [1,2,3,4]
    let dict = [1: "one", 2: "two"]
    
    for num in arry where dict[num] != nil {
    //1, 2
    }

do-catch

    enum ResponseError: ErrorType {
        case HTTP(Int)
    }
    
    func errorProne() throws {
        throw ResponseError.HTTP(404)
    }
    
    do {
    try errorProne()
    }catch ResponseError.HTTP(let code) where code >= 400 && code % 2 == 0 {
    print("Bad Request") //match
    }catch ResponseError.HTTP(let code) where code >= 50 && code < 600 {
    print("Internal Server Error")
    }
}

while

    var mutableArray: [Int]? = []
    while let arr = mutableArray  where arr.count < 5 {
    mutableArray?.append(0) //[0,0,0,0,0]
    }

if

    let string: String? = "checkmate"
    if let str = string where str != "checkmate"{
        print("game over")
    }else {
        print("Lte's play")
    }

guard

    let string: String? = "checkmate"
    guard let str = string where str != "checkmate" else{
        fataError("game over")
    }
    print("Let's play")

switch-case

    var value = (1, 2)
    switch value {
    case let (x, y) where x == 1:
    //
    case let (x, y) where x / 5 = 1:
    //
    default:
    
    }

type constraint

    func genericFunction<S where S: StringLiteralConvertible>(string: S) {
        print(string)
    }
    genericFunction("lambada")