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