swift 闭包本质，闭包表达式，尾随闭包

1. 闭包

• 一个函数和它所捕获的变量/常量环境组合起来，称为闭包

  • 一般指定义在函数内部的函数
  • 一般它所捕获的是外层函数的局部变量/常量

  typealias fn = (Int) -> Int
  func getFn() -> fn{
  	var count = 0
  		func sum(_ i: Int) -> Int{
      		count += i
      		return count
  		}
  	return sum
  }
  
  var f1 = getFn()
  
  f1(1)
  f1(1)
  f1(1)
  f1(1)
  

  结果：
  
  解释：
  闭包能够使用其外层函数的局部变量，所以函数值能够增加
  本质：
  编译器给sum函数外层getFn函数的count属性分配了堆空间，所以count变量不会在getFn函数执行完后销毁，因此sum函数能够对其进行访问
  分配内存结构： 类似于给class分配的堆空间结构
  

  • 可以把闭包想象成一个对象的实例

    • 内存在堆空间
    • 捕获的局部变量/常量就是对象的成员
    • 组成闭包的函数就是类内部定义的方法
      类似与class的形式：

    class Closure{
    var count = 0
    	func sum(_ i:Int) -> Int{
    		count += i
    		return count
    	}
    }
    
    var c1 = Closure()
    c1.sum(1)
    c1.sum(1)
    c1.sum(1)
    

2. 闭包表达式

• 语法：

  {
  	(参数列表) -> 返回值类型 in
  	函数体代码
  }
  

• 简写：

  func exec(v1:Int, v2:Int, fn:(Int, Int) -> Int){
  	print(fn(v1, v2))
  }
  // 完整写法：
  exec(v1:10, v2:20, fn:{
  	(a1:Int, a2:Int) -> Int in
  	return a1 + a2
  })
  // 简写1
  exec(v1:10, v2:20, fn:{
  	a1, a2 in return a1 + a2
  })
  // 简写2
  exec(v1:10, v2:20,fn:{
  	a1,a2 in a1 + a2
  })
  // 简写3
  exec(v1:10, v2:20, fn:{ $0 + $1 })
  // 简写4
  exec(v1:10, v2:20, fn: + )
  // 尾随闭包: 是一个被书写在函数调用括号外面(后面)的闭包表达式
  // 如果一个很长的闭包表达式作为一个函数的 最后一个 实参，使用尾随闭包可以增强程序的可读性
  exec(v1:10, v2:20){ $0 + $1 }
  // 如果函数只有一个参数，且类型是函数类型，可以省略括号
  func add(fn: (Int,Int) -> Int){
  	print(fn(1, 2))
  }
  add{ $0 + $1 }
  // 省略参数
  add{ _,_ in 10 }  //省略掉参数，固定返回10