Swift闭包

func closesure{
///1.
    let b = {print("最简单闭包")}
    b()
 
    ///2.
    let countNum = {(num1:Int,num2:Int) -> Int in
        
        return num1+num2
    }

    let count = countNum(2,6)
    print(print("有返回值且带参数count=\(count)"))

    //等价上边
    var countNum2: (Int , Int ) -> Int = {
        (a: Int , b: Int) -> Int in
        return a * b
    }

   //第一次简化 类型自动推导 可以根据参数推断
    countNum2 = {
        (a,b) in
        return a * b
    }
    
    //第二次简化 如果函数体只包含一句 return 代码，可省略 return
    countNum2 = {
        (a, b) in
        a * b
    }
    /*
     第三次简化
     被捕获的参数列表中，含有a、b，下标从0开始，可通过"$"获取。
     
     编译器亦可通过，捕获列表自行推断出参数。
     故可省略参数列表 （a, b）和 关键字 in
     */
    countNum2 = {
        $0 * $1
    }
    let count2 = countNum2(2,6)
    print("有返回值且带参数count2=\(count2)")
    

}

 

2.闭包作为参数（分内联和尾随）

//闭包作为函数参数
func myOpreation(a:Int,b:Int,operation:(Int , Int) -> Int) -> Int{
   return operation(a,b)
}

调用上边的函数

 //内联闭包（其实就是把闭包写在“)”里边）
    let kk = myOpreation(a: 3, b: 5 ,operation: { (a, b) -> Int in
          return a*b
    })
    
    //尾随闭包（其实就是把闭包写在“)”外边）
    let hj = myOpreation(a: 4, b: 2) { (m, n) -> Int in
        return m-n
    }
   //简化尾随闭包
    let mm = myOpreation(a: 3, b: 4) {
         $0+$1
    }
    
    //这个不知道算是内联的还是尾随的
    let nn = myOpreation(a: 4, b: 5, operation: *)
    print(nn)

3.逃逸闭包和非逃逸闭包

//非逃逸闭包（就是在函数内调用）
func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}
//逃逸闭包（需要加@escaping）
var functionArray:[()->Void] = []
func doSomething(paramClosure:@escaping ()->Void){
    functionArray.append(paramClosure)
}

调用俩闭包，会发现，非逃逸闭包在函数内已经调用，而逃逸闭包分两步，先调用函数，实现函数内闭包的声明，再调用数组存储的函数内的闭包

 //1.调用函数（加self才能访问到属性）
    doSomething(paramClosure: {
        self.apple = 9
        print(self.apple)})
    
    //2.逃逸调用闭包
    for closurePrama in functionArray {
        closurePrama()

    }
    
    //调用非逃逸闭包(不用加self)
    someFunctionWithNonescapingClosure {
        apple = 10
        print(apple)
    }