1、写一个闭包

let sumNum = {
    (x: Int, y: Int) -> Int in
    return x + y
}
print(sumNum(1, 2))

2、尾随闭包

尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用

func calculate(str: String, funN:(Int, Int) -> Int){
    switch str {
    case "+":
        print(funN(10, 5))
    default:
        print(funN(10, 5))
    }
}

calculate(str: "+") { (a: Int, b: Int) -> Int in
    return a + b
}

calculate(str: "-") { (a: Int, b: Int) -> Int in
    return a - b
}

注：要使用尾随闭包，则必须是参数列表的最后一个参数，如果不是最后一个参数，是无法使用尾随闭包写法的

3、使用闭包表达式

/*
{
    (a: Int, b: Int) -> Int in
    return a + b
}
*/

这就是一个标准类型的闭包表达式

4、根据上下文推断

可以简写为{a,b in return a - b}，希望系统根据啊，b的类型推断返回值的类型，所以int可以省略

func calculate2(str: String) -> (Int,Int) -> Int{
    var result:(Int, Int) -> Int
    switch str {
    case "+":
        result = {a, b in return a + b}
    default:
        result = {a, b in return a - b}
    }
    return result
}

let fi = calculate2(str: "+")
let sum = fi(10,20)
print(sum,calculate2(str: "1")(10, 8))

5、单行闭包表达式可以省略return关键字

如果在闭包中只有一条语句，可以吧return省略掉，所以{a, b in return a + b},可以去掉return

func calculate3(str: String) -> (Int,Int) -> Int{
    var result:(Int, Int) -> Int
    switch str {
    case "+":
        result = {a, b in  a + b}
    default:
        result = {a, b in  a - b}
    }
    return result
}

let fi3 = calculate3(str: "+")
let sum3 = fi3(10,20)
print(sum3,calculate3(str: "1")(10, 8))

6、参数名称缩写

swift 提供了参数名的缩写功能，用¥1¥2来表示调用闭包中的参数，同时关键字也可以省略

func calculate4(str: String) -> (Int, Int) -> Int{
    var result:(Int, Int) -> Int
    switch str {
    case "+":
        result = {$0 + $1}
    default:
        result = {$0 - $1}
    }
    return result
}

print(calculate4(str: "-")(2, 1))

7、捕获

捕获函数或者闭包可以在其定义的上下文中捕获常量和变量，即使定义的这些变量或者常量的原作用域不在，仍然可以在闭包函数题内引用和修改这些变量和常量

func makeArray() -> (String) -> [String] {
    var array:[String] = [String]()
    func addElement(element: String) -> [String]{
        array.append(element)
        return array
    }
    return addElement
}

let fn = makeArray()
print(fn("red"))
print(fn("greed"))
print(fn("clock"))

var city = ["郑州","厦门","合肥","南昌"]

var cityRank1 = city.sorted()
var cityRank2 = city.sorted(by: daoxu)

func daoxu(a: String,b: String) ->Bool{
    return a > b
}

var cityRank3 = city.sorted{(a,b) -> Bool in
    return a > b
}

var cityRnk5 = city.sorted {$0 > $1}
cityRnk5