Swift：闭包(Closures)_app

var numbers = [1,2,3]let strings = numbers.map({ (var number) -> String in var output = "" while number > 0 { output = String(number % 10) + output number /= 10 } return output})

var numbers = [1,3]let strings = numbers.map(){ (var number) -> String in var output = "" while number > 0 { output = String(number % 10) + output number /= 10 } return output}

var numbers = [1,3]let strings = numbers.map{ (var number) -> String in var output = "" while number > 0 { output = String(number % 10) + output number /= 10 } return output}

func increment(#amount: Int) -> (() -> Int) { var total = 0 func incrementAmount() -> Int { total += amount // total是外部函数体内的变量，这里是可以捕获到的 return total } return incrementAmount // 返回的是一个嵌套函数（闭包） }

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

class HTMLElement { var name: String var text: String? init(name: String,text: String?) { self.name = name self.text = text } lazy var asHTML: () -> String = { [uNowned self] in if let text = self.text { return "<\(self.name)>\(self.text)</\(self.name)>" } else { return "<\(self.name)>" } }}var HTML = HTMLElement(name: "Node",text: "Jack")HTML.asHTML()

class TestVIEw: UIVIEw { private weak var textFIEld1: UITextFIEld! var testClosure: ((str1: String) -> VoID)? overrIDe init(frame: CGRect) { super.init(frame: frame) var size = UIScreen.mainScreen().bounds.size self.frame = CGRectMake(0,size.wIDth,kVIEwHeight) self.backgroundcolor = UIcolor.graycolor() var textFIEld1 = UITextFIEld(frame: CGRectMake(10,30,150,30)) textFIEld1.backgroundcolor = UIcolor.whitecolor() self.addSubvIEw(textFIEld1) self.textFIEld1 = textFIEld1 var btn = UIbutton(frame: CGRectMake(300,50,30)) btn.setTitle("GO",forState: UIControlState.normal) btn.addTarget(self,action: "showResult",forControlEvents: UIControlEvents.touchDown) self.addSubvIEw(btn) } func showResult() { self.testClosure?(str1: self.textFIEld1.text) } required init(coder aDecoder: NSCoder) { fatalError("init(coder:) has not been implemented") }}

class VIEwController: UIVIEwController { @IBOutlet weak var testLabel: UILabel! overrIDe func vIEwDIDLoad() { super.vIEwDIDLoad() var tab = TestVIEw() tab.testClosure = { [uNowned self] // 去除循环引用 (str1: String) -> VoID in self.testLabel.text = "First Record:\(str1)" } self.vIEw.addSubvIEw(tab) } overrIDe func dIDReceiveMemoryWarning() { super.dIDReceiveMemoryWarning() // dispose of any resources that can be recreated. }}

概述一、基本概念闭包（Closures）是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。在Swift中的闭包与C、OC中的blocks和其它编程语言（如C#）中的lambda, javascript中的函数嵌套等类似。闭包可以捕获和存储上下文中定义的的任何常量和变量的引用。这就是所谓的变量和变量的自封闭，因此闭包还会处理所有捕获的引用的内存管理。全局函数和嵌套函数其实就是特殊

一、基本概念

闭包（Closures）是自包含的功能代码块，可以在代码中使用或者用来作为参数传值。在Swift中的闭包与C、OC中的blocks和其它编程语言（如C#）中的lambda,JavaScript中的函数嵌套等类似。闭包可以捕获和存储上下文中定义的的任何常量和变量的引用。这就是所谓的变量和变量的自封闭，因此闭包还会处理所有捕获的引用的内存管理。全局函数和嵌套函数其实就是特殊的闭包。闭包的形式有：

（1）全局函数都是闭包，有名字但不能捕获任何值。
（2）嵌套函数都是闭包，且有名字，也能捕获封闭函数内的值。
（3）闭包表达式都是无名闭包，使用轻量级语法，可以根据上下文环境捕获值。

Swift中的闭包有很多优化的地方:
(1)根据上下文推断参数和返回值类型
(2)从单行表达式闭包中隐式返回（也就是闭包体只有一行代码，可以省略return）
(3)可以使用简化参数名，如$0,$1(从0开始，表示第i个参数...)

(4)提供了尾随闭包语法(Trailing closure Syntax)

二、使用举例（这里所列举的例子，均从《The Swift Programming Language》这本书总结所得）
下面用Swift标准库中的sort方法来一步步简化闭包写法
sort函数需要两个参数
参数一：数组
参数二：一个闭包：带有两个参数，这两个参数类型与数组中的元素类型相同，返回值是Bool
数组：

var names = ["Swift","Arial","Soga","Donary"]

第一种方式：使用函数

func backwards(firstString: String,secondString: String) -> Bool {     return firstString > secondString // 降序排序   }

调用：

sort(&names,backwards)

这种方式的使用相当于回调backward方法。

第二种方式：使用闭包方式
完整闭包写法是在花括号内有参数列表和返回值，用关键字in表明闭包体的开始
（1） (firstString: String,secondString: String) 闭包参数列表
（2） -> Bool 指明闭包返回值类型是Bool
（3） in关键字表明闭包体的开始

sort(&names,{ (firstString: String,secondString: String) -> Bool in      return firstString > secondString      })

这里可以进一步简化写法，因为闭包代码比较短，可以写到一行上

sort(&names,secondString: String) -> Bool in return firstString > secondString})

下面再进一步简化写法：根据环境上下文自动推断出类型,参数列表都没有指明类型，也没有指明返回值类型，这是因为swift可以根据上下文推测出,firstString和secondString的类型会是names数组元素的类型，而返回值类型会根据return语句结果得到

sort(&names,{ firstString,secondString in return firstString > secondString})

再进一步简化：隐式返回（单行语句闭包）,因为闭包体只有一行代码，可以省略return

sort(&names,secondString in firstString > secondString})

再进一步简化：使用简化参数名（$i,i=0,1,2...从0开始的）,Swift会推断出闭包需要两个参数，类型与names数组元素相同

sort(&names,{ 最简单的一种写法：使用 *** 作符 >  })

sort(&names,>)

sort(&names,secondString: String) -> Bool in      return firstString > secondString      })

三、尾随闭包（Trailing Closures）
如果函数需要一个闭包参数作为参数，且这个参数是最后一个参数，而这个闭包表达式又很长时，使用尾随闭包是很有用的。尾随闭包可以放在函数参数列表外，也就是括号外。就是将原本在参数列表内的闭包提取到函数的后边书写，这样就利于阅读及使用。
1. 还是用sort的方法为例，正常的闭包写法如下：
但可以发现，sort函数中，第二个参数非常的长并且不利于阅读，这时，我们可以使用尾随闭包进行改造，代码如下：

sort(&names){    (firstString,secondString) -> Bool in    return firstString > secondString}

2. map方法使用举例，输出一个数组对应的字符串

var numbers = [1,2,3]let strings = numbers.map({    (var number) -> String in    var output = ""    while number > 0 {        output = String(number % 10) + output        number /= 10    }    return output})

注意到，map是一个方法，而其参数就只有一个闭包，所以我们同样可以使用尾随闭包的形式，写成如下形式

var numbers = [1,3]let strings = numbers.map(){    (var number) -> String in    var output = ""    while number > 0 {        output = String(number % 10) + output        number /= 10    }    return output}

而map函数没有任何其他的参数，只有一个闭包参数，所以map后面的"()"也可以省略，最终的尾随闭包可以写成如下形式

var numbers = [1,3]let strings = numbers.map{    (var number) -> String in    var output = ""    while number > 0 {        output = String(number % 10) + output        number /= 10    }    return output}

func increment(#amount: Int) -> (() -> Int) {    var total = 0    func incrementAmount() -> Int {      total += amount // total是外部函数体内的变量，这里是可以捕获到的      return total    }    return incrementAmount // 返回的是一个嵌套函数（闭包）  }

四、捕获值
闭包可以根据环境上下文捕获到定义的常量和变量。闭包可以引用和修改这些捕获到的常量和变量。在Swift中闭包的最简单形式是嵌套函数。
闭包是引用类型

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

，所以incrementByTen声明为常量也可以修改total

__weak typeof(self) wSelf = self;

五、闭包的循环引用问题
在objective-c时期，在使用block的时候不得不考虑block的循环引用问题。当时采取的措施就是将循环引用的一方弱化，比如：

class HTMLElement {    var name: String    var text: String?        init(name: String,text: String?) {        self.name = name        self.text = text    }        lazy var asHTML: () -> String = {        [uNowned self] in        if let text = self.text {            return "<\(self.name)>\(self.text)</\(self.name)>"        } else {            return "<\(self.name)>"        }    }}var HTML = HTMLElement(name: "Node",text: "Jack")HTML.asHTML()

在Swift中的闭包中也存在同样的问题，其实大致思路是一致的，我们可以使用uNowned 关键字。
Example，将一个对象的属性转化为XML形式显示：
上面的代码中，self对asHTML这个闭包属性有强引用，而asHTML内部又有对self的强引用，所以我们可以使用[uNowned self] 将self “弱化”。从而解除了循环引用。

class TestVIEw: UIVIEw {    private weak var textFIEld1: UITextFIEld!        var testClosure: ((str1: String) -> VoID)?        overrIDe init(frame: CGRect) {        super.init(frame: frame)                var size = UIScreen.mainScreen().bounds.size        self.frame = CGRectMake(0,size.wIDth,kVIEwHeight)        self.backgroundcolor = UIcolor.graycolor()                var textFIEld1 = UITextFIEld(frame: CGRectMake(10,30,150,30))        textFIEld1.backgroundcolor = UIcolor.whitecolor()        self.addSubvIEw(textFIEld1)        self.textFIEld1 = textFIEld1                var btn = UIbutton(frame: CGRectMake(300,50,30))        btn.setTitle("GO",forState: UIControlState.normal)        btn.addTarget(self,action: "showResult",forControlEvents: UIControlEvents.touchDown)        self.addSubvIEw(btn)    }        func showResult() {        self.testClosure?(str1: self.textFIEld1.text)    }        required init(coder aDecoder: NSCoder) {        fatalError("init(coder:) has not been implemented")    }}

六、闭包在UIKit实际环境中的使用举例
UI界面如下：

功能很简单
1. 上面灰色的VIEw就是自定义的VIEw（TestVIEw.swift），它包含一个文本输入框和一个“GO”按钮。
2. 后面这一块就是控制器的VIEw（VIEwController.swift），它里面包含一个testLabel。
3. 点击"GO"按钮后将文本框中的内容回调到VIEwController.swift中的Label显示
TestVIEw.swift 代码：
代码中，我定义了一个testClosure闭包属性，当点击“GO”按钮则会调用其方法。注意到闭包的定义

var testClosure: ((str1: String) -> VoID)?

它是可空的，因为在控制器VIEwController.swift中不一定完成了对testClosure闭包属性赋值的工作。所以在调用闭包的时候写成

self.testClosure?(str1: self.textFIEld1.text)

而在VIEwController.swift赋值的代码如下：

class VIEwController: UIVIEwController {        @IBOutlet weak var testLabel: UILabel!    overrIDe func vIEwDIDLoad() {        super.vIEwDIDLoad()                var tab = TestVIEw()        tab.testClosure = {            [uNowned self] // 去除循环引用            (str1: String) -> VoID in            self.testLabel.text = "First Record:\(str1)"        }        self.vIEw.addSubvIEw(tab)    }    overrIDe func dIDReceiveMemoryWarning() {        super.dIDReceiveMemoryWarning()        // dispose of any resources that can be recreated.    }}

总结

以上是内存溢出为你收集整理的Swift：闭包(Closures)全部内容，希望文章能够帮你解决Swift：闭包(Closures)所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。

欢迎分享，转载请注明来源：内存溢出

原文地址: http://outofmemory.cn/web/1085517.html