Swift中的闭包（Closures）

 1. 闭包是自包含的功能代码块，可以用来作为参数传递。闭包可以捕获或者存储上下文中定义的任何变量。

闭包的格式为：

{

(参数：类型)－> 返回类型  in 

执行方法

return返回类型

}

例子：

func getList(arr:Int[] , pre:(Int)->Bool) ->Int[]{
    
   //定义一个空的可变整形集合
    var tempArr = Int[]()

    for temp in arr {

        if pre(temp){
            tempArr += temp;
        }
    }

    return tempArr;
}


/*
调用Getlist 说明
第一个参数 整形数组 [1,2,3,4]
第二个参数  闭包 来指向给 函数类型 。
{(s) in return s>2} 闭包类型说明，参数为整形,返回值为布尔类型
*/
let arr=getList([1,2,3,4],{(s:Int) in return s>2})
println(arr)

运行结果
[3, 4]

闭包的简写：

第一种：省略参数类型和括号

var arr = getList([1,2,3,4],{s in return s>2})

第二种：省略参数类型和括号，还有return 关键字

arr = getList([1,2,3,4], {s in s>2})

第三种：参数名称缩写（$0代表第一个参数，$1代表第二个参数）

 arr = getList([1,2,3,4],{$0>2})

2.尾随闭包

如果方法需要一个闭包参数作为参数，且这个参数为最后一个参数，而且这个闭包参数比较长，可以使用尾随闭包。尾随闭包可以放在方法的参数列表外。如果方法只有一个参数，那么可以把（）省略掉，后面直接跟着闭包

let strings = numbers.map { // map函数后面的()可以省略掉  
  (var number) -> String in  
  var output = ""  
  while number > 0 {  
    output = String(number % 10) + output   
    number /= 10  
  }  
  return output  
}  

3.捕获值

闭包可以根据代码上下文补货到定义的常量和变量，闭包可以引用和修改捕获到的常量和变量，就算在原来的范围内定义的常量或者变量已经不存在了

例子：

func increment(amount: Int) -> (() -> Int) {  
  var total = 0  
  func incrementAmount() -> Int {  
    total += amount // total是外部函数体内的变量，这里是可以捕获到的  
    return total  
  }  
  return incrementAmount // 返回的是一个嵌套函数（闭包）  
}     
      
// 闭包是引用类型，所以incrementByTen声明为常量也可以修改total  
let incrementByTen = increment(amount: 10)   
incrementByTen() // return 10,incrementByTen是一个闭包  
// 这里是没有改变对increment的引用，所以会保存之前的值  
incrementByTen() // return 20     
incrementByTen() // return 30     
  
let incrementByOne = increment(amount: 1)  
incrementByOne() // return 1  
incrementByOne() // return 2      
incrementByTen() // return 40   
incrementByOne() // return 3