闭包的概念和定义

一段程序代码通常由常量、变量和表达式组成，之后使用一对花括号“{}”来表示闭合并包裹着这些代码，由这对花括号包裹着的代码块就是一个闭包。

{
      (参数名1：参数类型，参数名2：参数类型...)->返回值类型  in
      闭包函数体
      return 返回值
}

不能在闭包参数中设置默认值。

let sumFunc = {
        (x:Int,y:Int)->Int
        in
        return x+y
}

print(sumFunc(10,20))

如果一个闭包没有参数和返回值，那么基本格式中的参数列表、返回值、in都可以省略掉，这就是最简单的闭包

let simpleFunc = {
    print("这是最简单的闭包")
}

使用尾随闭包

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

fun calculate(opr:String,funN:(Int,Int)->Int){
    switch(opr){
            case "+":
                print("10+5=\(funN(10,5))")
             default:
                print("10-5=\(funN(10,5))")
     }
}

调用calculate

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

第一行代码传入funN参数比较长，为此，可以通过第2行代码的调用方式，将小括号提前到闭包表达式前面，闭包表达式位于括号的外面，这种形式就是尾随闭包。
注意：
要使用尾随闭包，则闭包必须是参数列表的最后一个参数，如果不是最后一个的话，是无法使用尾随闭包写法的。

使用闭包表达式

1.根据上下文推断类型

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

Swift能够推断出参数a和b都是Int类型的，返回值也是Int类型的。

{a,b in return a+b}

eg:

fun calculate(opr:String)->(Int,Int)->Int{
     var result:(Int,Int)->Int
    switch(opr){
            case "+":
                result = {a,b in return a+b}
             default:
                result = {a,b in return a-b}
     }
     return result
}

let f1:(Int,Int)->Int = calculate(opr:"+")
print("10+5 = \(f1(10,5))")
let f2:(Int,Int)->Int = calculate(opr:"-")
print("10-5 = \(f2(10,5))")

2.单行闭包表达式可以省略return关键字
代码形式如下：

{a,b in a+b}

eg:

fun calculate(our:String)->(Int,Int)->Int{
     var result:(Int,Int)->Int
    switch(opr){
            case "+":
                result = {a,b in a+b}
             default:
                result = {a,b in a-b}
     }
}

let f1:(Int,Int)->Int = calculate(opr:"+")
print("10+5 = \(f1(10,5))")
let f2:(Int,Int)->Int = calculate(opr:"-")
print("10-5 = \(f2(10,5))")

3.参数名称缩写
Swift提供了参数名称 缩写功能。用1、0指代第1个参数，n指代第n+1个参数。

fun calculate(our:String)->(Int,Int)->Int{
     var result:(Int,Int)->Int
    switch(opr){
            case "+":
                result = {$0+$1}
             default:
                result = {$0-$1}
     }
}

let f1:(Int,Int)->Int = calculate(opr:"+")
print("10+5 = \(f1(10,5))")
let f2:(Int,Int)->Int = calculate(opr:"-")
print("10-5 = \(f2(10,5))")

4.使用闭包返回值
可以直接在表达式中使用闭包的返回值

let c1:Int = {(a:Int,b:Int)->Int in
                        return a+b}(10,5)
print("10+5=\(c1)")

捕获

嵌套函数或者闭包可以在其定义的上下文中捕获常量或者变量，即使定义的这些常量或变量的原作用域已经不存在，仍然可以在闭包函数体内引用和修改这些常量或变量，这种机制被称为捕获。

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

let f1 = makeArray()
print("---f1---")
print(f1("张三"))
print(f1("李四"))
print(f1("王五"))