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

1. 闭包

• 一个函数和它所捕获的变量/常量环境组合起来，称为闭包
  
  
  
  • 一般指定义在函数内部的函数
    
  • 一般它所捕获的是外层函数的局部变量/常量
    
  1. typealias fn = (Int) -> Int
  2. func getFn() -> fn{
  3.         var count = 0
  4.                 func sum(_ i: Int) -> Int{
  5.                     count += i
  6.                     return count
  7.                 }
  8.         return sum
  9. }
  11. var f1 = getFn()
  13. f1(1)
  14. f1(1)
  15. f1(1)
  16. f1(1)

  复制代码
  结果：
  
  
  
  解释：
  闭包能够使用其外层函数的局部变量，所以函数值能够增加
  本质：
  编译器给sum函数外层getFn函数的count属性分配了堆空间，所以count变量不会在getFn函数执行完后销毁，因此sum函数能够对其进行访问
  分配内存结构： 类似于给class分配的堆空间结构
  
  
  
  
  
  
  • 可以把闭包想象成一个对象的实例
    
    
    
    • 内存在堆空间
      
    • 捕获的局部变量/常量就是对象的成员
      
    • 组成闭包的函数就是类内部定义的方法
      类似与class的形式：
      
    1. class Closure{
    2. var count = 0
    3.         func sum(_ i:Int) -> Int{
    4.                 count += i
    5.                 return count
    6.         }
    7. }
    9. var c1 = Closure()
    10. c1.sum(1)
    11. c1.sum(1)
    12. c1.sum(1)

    复制代码
  
  

2. 闭包表达式

• 语法：
  1. {
  2.         (参数列表) -> 返回值类型 in
  3.         函数体代码
  4. }

  复制代码
• 简写：
  1. func exec(v1:Int, v2:Int, fn:(Int, Int) -> Int){
  2.         print(fn(v1, v2))
  3. }
  4. // 完整写法：
  5. exec(v1:10, v2:20, fn:{
  6.         (a1:Int, a2:Int) -> Int in
  7.         return a1 + a2
  8. })
  9. // 简写1
  10. exec(v1:10, v2:20, fn:{
  11.         a1, a2 in return a1 + a2
  12. })
  13. // 简写2
  14. exec(v1:10, v2:20,fn:{
  15.         a1,a2 in a1 + a2
  16. })
  17. // 简写3
  18. exec(v1:10, v2:20, fn:{ $0 + $1 })
  19. // 简写4
  20. exec(v1:10, v2:20, fn: + )
  21. // 尾随闭包: 是一个被书写在函数调用括号外面(后面)的闭包表达式
  22. // 如果一个很长的闭包表达式作为一个函数的 最后一个 实参，使用尾随闭包可以增强程序的可读性
  23. exec(v1:10, v2:20){ $0 + $1 }
  24. // 如果函数只有一个参数，且类型是函数类型，可以省略括号
  25. func add(fn: (Int,Int) -> Int){
  26.         print(fn(1, 2))
  27. }
  28. add{ $0 + $1 }
  29. // 省略参数
  30. add{ _,_ in 10 }  //省略掉参数，固定返回10

  复制代码

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！