swift中的闭包

其实到现在为止还是不太明白“闭包”的真正含义和使用方法，只能借javascript中的定义：

当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。

来解释闭包的含义。为以下的使用做为指导吧！

闭包是功能性自包含模块，可以在代码中被传递和使用。Swift中的闭包与C和Objective-C中的blocks以及其他一些编程语言中的lambdas比较相似。

闭包可以捕获和存储其所在上下文中任意常量和变量的引用。这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift会为您管理在捕获过程中涉及到的内存操作。

注意：如果您不熟悉捕获(capturing) 这个概念也不用担心，后面会详细对其进行介绍。

在 Swift函数章节中介绍的全局和嵌套函数实际上也是特殊的闭包，闭包采取如下三种形式之一：

全局函数是一个有名字但不会捕获任何值的闭包
嵌套函数是一个有名字并可以捕获其封闭函数域内值的闭包
闭包表达式是一个利用轻量级语法所写的可以捕获其上下文中变量或常量值的没有名字的闭包

Swift的闭包表达式拥有简洁的风格，并鼓励在常见场景中以实现语法优化，主要优化如下：

利用上下文推断参数和返回值类型
单表达式（single-expression）闭包可以省略return关键字
参数名称简写
Trailing 闭包语法

闭包表达式

嵌套函数是一种在较复杂函数中方便进行命名和定义自包含代码模块的方式。当然，有时候撰写小巧的没有完整定义和命名的类函数结构也是很有用处的，尤其是在处理一些函数并需要将另外一些函数作为该函数的参数时。

闭包表达式是一种利用简洁语法构建内联闭包的方式。闭包表达式提供了一些语法优化，使得撰写闭包变得简单明了。下面闭包表达式的例子通过使用几次迭代展示了sort函数定义和语法优化的方式。每一次迭代都用更简洁的方式描述了相同的功能。

sort函数

Swift 标准库提供了sort函数，会根据您提供的排序闭包将已知类型数组中的值进行排序。一旦排序完成，函数会返回一个与原数组大小相同的新数组，该数组中包含已经正确排序的同类型元素。

下面的闭包表达式示例使用sort函数对一个String类型的数组进行字母逆序排序，以下是初始数组值：

     
     
      
      let names = ["Chris","Alex","Ewa","Barry","Daniella"]

排序函数有两个参数：

已知类型值的数组。
一个闭包，采用相同类型的数组的内容的两个参数，并返回一个布尔值来表示是否将第一个值在排序时放到第二个值的前面或是后面。如果第一个值应该出现第二个值之前，闭包需要返回true，否则返回false。

该例子对一个String类型的数组进行排序，因此排序闭包需为(String,String) -> Bool类型的函数。

提供排序闭包的一种方式是撰写一个符合其类型要求的普通函数，并将其作为sort函数的第二个参数传入：

     
     
      
      func backwards(s1: String,s2: String) -> Bool {
      
       return s1 > s2
      
      }
      
      var reversed = sort(names,backwards)
      
      // reversed is equal to ["Ewa","Daniella","Chris","Alex"]

如果第一个字符串 (s1) 大于第二个字符串 (s2)，backwards函数则返回true，表示在新的数组中s1应该出现在s2前。字符中的 "大于" 表示 "按照字母顺序后出现"。这意味着字母 "B" 大于字母 "A",字符串 "Tom" 大于字符串 "Tim"。其将进行字母逆序排序，"Barry" 将会排在 "Alex" 之后,一次类推。

然而，这是一个相当冗长的方式，本质上只是写了一个单表达式函数 (a > b)。在下面的例子中，利用闭合表达式语法可以更好的构造一个内联排序闭包。

闭包表达式语法

闭包表达式语法有如下一般形式：

     
     
      
      { (parameters) -> returnType in
      
       statements
      
      }

闭包表达式语法可以使用常量、变量和inout类型作为参数，但不提供默认值。也可以在参数列表的最后使用可变参数。元组也可以作为参数和返回值。

下面的例子展示了之前backwards函数对应的闭包表达式版本的代码：

     
     
      
      reversed = sort(names,{ (s1: String,s2: String) -> Bool in
      
       return s1 > s2
      
      })

需要注意的是内联闭包参数和返回值类型声明与backwards函数类型声明相同。在这两种方式中，都写成了 (s1: String,s2: String) -> Bool类型。然而在内联闭包表达式中，函数和返回值类型都写在大括号内，而不是大括号外。

闭包的函数体部分由关键字in引入。该关键字表示闭包的参数和返回值类型定义已经完成，闭包函数体即将开始。

因为这个闭包的函数体部分如此短以至于可以将其改写成一行代码：

函数的整体调用保持不变，一对圆括号仍然包裹住了函数中整个参数集合。而其中一个参数现在变成了内联闭包 (相比于backwards版本的代码)。

根据上下文推断类型

因为排序闭包是作为函数的参数进行传入的，Swift可以推断其参数和返回值的类型。sort期望第二个参数是类型为(String,String) -> Bool的函数，因此实际上String,String和Bool类型并不需要作为闭包表达式定义中的一部分。因为所有的类型都可以被正确推断，返回箭头 (->) 和围绕在参数周围的括号也可以被省略：

函数时，都可以推断出闭包的参数和返回值类型，这意味着您几乎不需要利用完整格式构造任何内联闭包。

然而，你也可以使用明确的类型，如果你想它避免读者阅读可能存在的歧义，这样还是值得鼓励的。这个排序函数例子，闭包的目的是很明确的，即排序被替换，而且对读者来说可以安全的假设闭包可能会使用字符串值,因为它正协助一个字符串数组进行排序。

单行表达式闭包可以省略return

单行表达式闭包可以通过隐藏return关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：

在这个例子中，sort函数的第二个参数函数类型明确了闭包必须返回一个Bool类型值。因为闭包函数体只包含了一个单一表达式 (s1 > s2)，该表达式返回Bool类型值，因此这里没有歧义，return关键字可以省略。

参数名简写

Swift自动为内联函数提供了参数名称简写功能，您可以直接通过$0,$1,$2等名字来引用的闭包的参数的值。

如果您在闭包表达式中使用参数名称简写，您可以在闭包参数列表中省略对其的定义，并且对应参数名称简写的类型会通过函数类型进行推断。in关键字也同样可以被省略，因为此时闭包表达式完全由闭包函数体构成：

在这个例子中，$0和$1表示闭包中第一个和第二个String类型的参数。

运算符函数

实际上还有一种更简短的方式来撰写上面例子中的闭包表达式。Swift的String类型定义了关于大于号 (>) 的字符串实现，让其作为一个函数接受两个String类型的参数并返回Bool类型的值。而这正好与sort函数的第二个参数需要的函数类型相符合。因此，您可以简单地传递一个大于号，Swift可以自动推断出您想使用大于号的字符串函数实现：

内容请查看 Operator Functions。

Trailing 闭包

如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用 trailing 闭包来增强函数的可读性。

Trailing 闭包是一个书写在函数括号之外(之后)的闭包表达式，函数支持将其作为最后一个参数调用。

     
     
      
      func someFunctionThatTakesAClosure(closure: () -> ()) {
      
       // 函数体部分
      
      }
      
      // 以下是不使用 trailing 闭包进行函数调用
      
      someFunctionThatTakesAClosure({
      
       // 闭包主体部分
      
      })
      
      // 以下是使用 trailing 闭包进行函数调用
      
      someFunctionThatTakesAClosure() {
      
       // 闭包主体部分
      
      }

注意：如果函数只需要闭包表达式一个参数，当您使用 trailing 闭包时，您甚至可以把 () 省略掉。 NOTE

在上例中作为sort函数参数的字符串排序闭包可以改写为：

     
     
      
      reversed = sort(names) { $0 > $1 }

当闭包非常长以至于不能在一行中进行书写时，Trailing 闭包就变得非常有用。举例来说，Swift的Array类型有一个map方法，其获取一个闭包表达式作为其唯一参数。数组中的每一个元素调用一次该闭包函数，并返回该元素所映射的值(也可以是不同类型的值)。具体的映射方式和返回值类型由闭包来指定。

当提供给数组闭包函数后，map方法将返回一个新的数组，数组中包含了与原数组一一对应的映射后的值。

下例介绍了如何在map方法中使用 trailing 闭包将Int类型数组[16,58,510]转换为包含对应String类型的数组["Onesix","FiveEight","FiveOneZero"]:

     
     
      
      let digitNames = [
      
       0: "Zero",1: "One",2: "Two",3: "Three",4: "Four",
      
       5: "Five",6: "Six",7: "Seven",8: "Eight",9: "Nine" 
      
      ]
      
      let numbers = [16,510]

上面的代码创建了整数数字到他们的英文名字之间映射字典。同时定义了一个准备转换为字符串的整型数组。

您现在可以通过传递一个 trailing 闭包给numbers的map方法来创建对应的字符串版本数组。需要注意的时调用numbers.map不需要在map后面包含任何括号，因为只需要传递闭包表达式这一个参数，并且该闭包表达式参数通过 trailing 方式进行撰写：

     
     
      
      let strings = numbers.map {
      
       (var number) -> String in
      
       var output = ""
      
       while number > 0 {
      
       output = digitNames[number % 10]! + output
      
       number /= 10
      
       }
      
       return output
      
      }
      
      // strings 常量被推断为字符串类型数组，即 String[]
      
      // 其值为 ["Onesix","FiveOneZero"]

map在数组中为每一个元素调用了闭包表达式。您不需要指定闭包的输入参数number的类型，因为可以通过要映射的数组类型进行推断。

闭包number参数被声明为一个变量参数 (变量的具体描述请参看 Constant and Variable Parameters)，因此可以在闭包函数体内对其进行修改。闭包表达式制定了返回值类型为String，以表明存储映射值的新数组类型为String。

闭包表达式在每次被调用的时候创建了一个字符串并返回。其使用求余运算符(number % 10)计算最后一位数字并利用digitNames字典获取所映射的字符串。

注意：字典digitNames下标后跟着一个叹号 (!)，因为字典下标返回一个可选值 (optional value)，表明即使该key不存在也不会查找失败。在上例中，它保证了number % 10可以总是作为一个digitNames字典的有效下标key。因此叹号可以用于强展开(force-unwrap)存储在可选下标项中的String类型值。

从digitNames字典中获取的字符串被添加到输出的前部，逆序建立了一个字符串版本的数字。 (在表达式number % 10中，如果number为16，则返回6，58返回8，510返回0)。

number变量之后除以10。因为其是整数，在计算过程中未除尽部分被忽略。因此 16变成了1，58变成了5，510变成了51。

整个过程重复进行，直到number /= 10为0，这时闭包会将字符串输出，而map函数则会将字符串添加到所映射的数组中。

上例中 trailing 闭包语法在函数后整洁封装了具体的闭包功能，而不再需要将整个闭包包裹在map函数的括号内。

捕获 (Caputure)

闭包可以在其定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。

Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数体内的函数。嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。

下例为一个叫做makeIncrementor的函数，其包含了一个叫做incrementor嵌套函数。嵌套函数incrementor从上下文中捕获了两个值，runningTotal和amount。之后makeIncrementor将incrementor作为闭包返回。每次调用incrementor时，其会以amount作为增量增加runningTotal的值。

     
     
      
      func makeIncrementor(forIncrement amount: Int) -> () -> Int {
      
       var runningTotal = 0
      
       func incrementor() -> Int {
      
       runningTotal += amount
      
       return runningTotal
      
       }
      
       return incrementor
      
      }

makeIncrementor返回类型为() -> Int。这意味着其返回的是一个函数，而不是一个简单类型值。该函数在每次调用时不接受参数只返回一个Int类型的值。关于函数返回其他函数的内容，请查看 Function Types as Return Types。

makeIncrementor函数定义了一个整型变量runningTotal(初始为0) 用来存储当前增加总数。该值通过incrementor返回。

makeIncrementor有一个Int类型的参数，其外部命名为forIncrement，内部命名为amount，表示每次incrementor被调用时runningTotal将要增加的量。

incrementor函数用来执行实际的增加操作。该函数简单地使runningTotal增加amount，并将其返回。

如果我们单独看这个函数，会发现看上去不同寻常：

     
     
      
      func incrementor() -> Int {
      
       runningTotal += amount
      
       return runningTotal
      
      }

incrementor函数并没有获取任何参数，但是在函数体内访问了runningTotal和amount变量。这是因为其通过捕获在包含它的函数体内已经存在的runningTotal和amount变量而实现。

由于没有修改amount变量，incrementor实际上捕获并存储了该变量的一个副本，而该副本随着incrementor一同被存储。

然而，因为每次调用该函数的时候都会修改runningTotal的值，incrementor捕获了当前runningTotal变量的引用，而不是仅仅复制该变量的初始值。捕获一个引用保证了当makeIncrementor结束时候并不会消失，也保证了当下一次执行incrementor函数时，runningTotal可以继续增加。

注意：Swift会决定捕获引用还是拷贝值。您不需要标注amount或者runningTotal来声明在嵌入的incrementor函数中的使用方式。Swift同时也处理runingTotal变量的内存管理操作，如果不再被incrementor函数使用，则会被清除。

下面为一个使用makeIncrementor的例子：

     
     
      
      let incrementByTen = makeIncrementor(forIncrement: 10)

该例子定义了一个叫做incrementByTen的常量，该常量指向一个每次调用会加10的incrementor函数。调用这个函数多次可以得到以下结果：

     
     
      
      incrementByTen()
      
      // 返回的值为10
      
      incrementByTen()
      
      // 返回的值为20
      
      incrementByTen()
      
      // 返回的值为30

如果您创建了另一个incrementor，其会有一个属于自己的独立的runningTotal变量的引用。下面的例子中，incrementBySevne捕获了一个新的runningTotal变量，该变量和incrementByTen中捕获的变量没有任何联系：

     
     
      
      let incrementBySeven = makeIncrementor(forIncrement: 7)
      
      incrementBySeven()
      
      // 返回的值为7
      
      incrementByTen()
      
      // 返回的值为40

注意：如果您闭包分配给一个类实例的属性，并且该闭包通过指向该实例或其成员来捕获了该实例，您将创建一个在闭包和实例间的强引用环。Swift使用捕获列表来打破这种强引用环。更多信息，请参考 Strong Reference Cycles for Closures。

闭包是引用类型

上面的例子中，incrementBySeven和incrementByTen是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量值。这是因为函数和闭包都是引用类型。

无论您将函数/闭包赋值给一个常量还是变量，您实际上都是将常量/变量的值设置为对应函数/闭包的引用。上面的例子中，incrementByTen指向闭包的引用是一个常量，而并非闭包内容本身。

这也意味着如果您将闭包赋值给了两个不同的常量/变量，两个值都会指向同一个闭包：

     
     
      
      let alsoIncrementByTen = incrementByTen
      
      alsoIncrementByTen()
      
      // 返回的值为50

     
     
      
      let alsoIncrementByTen = incrementByTen
      
      alsoIncrementByTen()
      
      // 返回的值为50

/*闭包（Closures）
*闭包是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。
*在Swift中的闭包与C、OC中的blocks和其它编程语言（如Python）中的lambdas类似。
*闭包可以捕获和存储上下文中定义的的任何常量和变量的引用。这就是所谓的变量和变量的自封闭，
*因此命名为”闭包“("Closures）").Swift还会处理所有捕获的引用的内存管理。
*
*全局函数和嵌套函数其实就是特殊的闭包。
*闭包的形式有：
*（1）全局函数都是闭包，有名字但不能捕获任何值。
*（2）嵌套函数都是闭包，且有名字，也能捕获封闭函数内的值。
*（3）闭包表达式都是无名闭包，使用轻量级语法，可以根据上下文环境捕获值。
*Swift中的闭包有很多优化的地方:
*(1)根据上下文推断参数和返回值类型
*(2)从单行表达式闭包中隐式返回（也就是闭包体只有一行代码，可以省略return）
*(3)可以使用简化参数名，如$0,$1(从0开始，表示第i个参数...)
*(4)提供了尾随闭包语法(TrailingclosureSyntax)
*/
//下面用Swift标准库中的sort方法来一步步简化闭包写法
//sort函数需要两个参数
//参数一：数组
//参数二：一个闭包：带有两个参数，这两个参数类型与数组中的元素类型相同，返回值是Bool
varnames=["Swift","Arial","Soga","Donary"]
//第一种方式：使用函数
funcbackwards(firstString:String,secondString:String)->Bool{
returnfirstString>secondString//升序排序
}
//这里第二个参数，传了一个函数
//reversedisequalto["Swift","Soga","Donary","Arial"]
varreversed=sort(nams,backwards)
//第二种方式：使用闭包方式
//完整闭包写法是在花括号内有参数列表和返回值，用关键字in表明闭包体的开始
//(firstString:String,secondString:String)闭包参数列表
//->Bool指明闭包返回值类型是Bool
//in关键字表明闭包体的开始
reversed=sort(names,{(firstString:String,0); background-color:inherit">secondString:String)->Boolin
returnfirstString>secondString
})
//这里可以进一步简化写法，因为闭包代码比较短，可以写到一行上
reversed=sort(names,0); background-color:inherit">secondString:String)->BoolinreturnfirstString>secondString})
//下面再进一步简化写法：根据环境上下文自动推断出类型
//参数列表都没有指明类型，也没有指明返回值类型，这是因为swift可以根据上下文推测出
//firstString和secondString的类型会是names数组元素的类型，而返回值类型会根据return语句结果得到
irstString,secondStringinreturnfirstString>secondString})
//再进一步简化：隐式返回（单行语句闭包）
//因为闭包体只有一行代码，可以省略return
irstString>secondString})
//再进一步简化：使用简化参数名（$i,i=0,1,2...从0开始的）
//Swift会推断出闭包需要两个参数，类型与names数组元素相同
0>$1})
//最简单的一种写法：使用操作符
/*
*尾随闭包（TrailingClosures）
*如果函数需要一个闭包参数作为参数，且这个参数是最后一个参数，而这个闭包表达式又很长时，
*使用尾随闭包是很有用的。尾随闭包可以放在函数参数列表外，也就是括号外。如果函数只有一个参数，
*那么可以把括号()省略掉，后面直接跟着闭包。
//Array的方法map()就需要一个闭包作为参数
letstrings=numbers.map{//map函数后面的()可以省略掉
(varnumber)->Stringin
varoutput=""
whilenumber>0{
output=String(number%10)+output
number/=10
}
returnoutput
/*捕获值
*闭包可以根据环境上下文捕获到定义的常量和变量。闭包可以引用和修改这些捕获到的常量和变量，
*就算在原来的范围内定义为常量或者变量已经不再存在（很牛逼）。
*在Swift中闭包的最简单形式是嵌套函数。
funcincrement(#amount:Int)->(()->Int){
vartotal=0
funcincrementAmount()->Int{
total+=amount//total是外部函数体内的变量，这里是可以捕获到的
returntotal
returnincrementAmount//返回的是一个嵌套函数（闭包）
//闭包是引用类型，所以incrementByTen声明为常量也可以修改total
letincrementByTen=increment(amount:10)
incrementByTen()//return10,incrementByTen是一个闭包
//这里是没有改变对increment的引用，所以会保存之前的值
//return20
incrementByTen()//return30
letincrementByOne=increment(amount:1)
incrementByOne()//return1
incrementByOne()//return2
//return40
//return3

上一篇：swift中的闭包下一篇：Swift 编程语言入门教程