Swift之闭包

func closures(y: (Int) -> Bool, x: Int) ->Bool {
    return y(x)
}

//比较第二个参数是否比100大
closures({ (a: Int) -> Bool in
    return a > 100
}, 101)

/*
闭包语法

{   (参数) -> 返回类型 in  
        函数体
}
*/


/*
根据上下文推断类型
因为closures2，第一个参数为(Int, Int) -> Bool的函数，所以在调用closures2的
时候可以省略Int, Int和Bool
*/
func closures2(y: (Int, Int) -> Bool, int1: Int, int2: Int) -> Bool {
    return y(int1, int2)
}

closures2({ int1, int2 in return int1 > int2
    }, 100, 1) // true

closures2( { int1, int2 in int1 > int2 }, 1, 100) // false

//参数名简写,$0和$1表示闭包的第一和第二个参数
closures2( { $0 > $1 } , 100, 99)  //true

//运算法函数大于号（ > ）正好与closures2函数传入的类型相符合
closures2(>, 100, 99) // true

func closures3(int1: Int, int2: Int, y: (Int, Int) -> Bool) -> Bool {
    return y(int1, int2)
}

/*
如果闭包函数体比较长，可以把闭包写在函数括号之外，不过闭包函数参数是该参数的最后一个，这样就能把在函数体外的闭包当作函数的最后一个参数传入
*/
closures3(100, 50) { $0 > $1 } //true

let digitNames = [
    0: "Zero", 1: "One", 2: "Two", 3: "Three", 4: "Four",
    5: "Five", 6: "Six", 7: "Seven", 8: "Eight", 9: "Nine"
]

let numbers = [16, 58, 510]

/*
Array类型的map方法接受一个参数，下面把参数写在外面，因此map()扣括号可以省略,写成map。该方法返回数组中每个元素的映射，返回改数字的String。
*/

let strings = numbers.map {
    (var number) -> String in
    var output = ""
    while number > 0 {
        output = digitNames[number % 10]! + output
        number /= 10
    }
    return output
}

strings // [OneSix", "FiveEight", "FiveOneZero"]

func makeIncrementor(amount: Int) -> () -> Int {
    var runnningToal = 0
    func incrementor() -> Int {
        runnningToal += amount
        return runnningToal
    }
    return incrementor
}
//捕获，函数体内改变runnningToal值，所以对runnningToal是引用捕获，对amount是值捕获，因为没有改变它的值。
let incrementByTen = makeIncrementor(10)
incrementByTen() // runnningToal = 10
incrementByTen() // runnningToal = 20
incrementByTen() // runnningToal = 30