Swift：闭包(Closures)

Posted 2020-09-17 cynchanpin

一、 基本概念 

闭包（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方法。

另外一种方式：使用闭包方式 
完整闭包写法是在花括号内有參数列表和返回值。用keywordin表明闭包体的開始 
（1）  (firstString: String, secondString: String) 闭包參数列表  
（2）  -> Bool 指明闭包返回值类型是Bool  
（3）  inkeyword表明闭包体的開始  

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

这里能够进一步简化写法。由于闭包代码比較短，能够写到一行上

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

以下再进一步简化写法 ：依据环境上下文自己主动判断出类型 ,參数列表都没有指明类型，也没有指明返回值类型，这是由于swift能够依据上下文猜測出 ,firstString和secondString的类型会是names数组元素的类型，而返回值类型会依据return语句结果得到

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

再进一步简化：隐式返回（单行语句闭包）, 由于闭包体仅仅有一行代码，能够省略return 

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

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

sort(&names, { $0 > $1 })  

最简单的一种写法：使用操作符

sort(&names, >)

三、 跟随闭包（Trailing Closures）
假设函数须要一个闭包參数作为參数，且这个參数是最后一个參数，而这个闭包表达式又非常长时。 使用跟随闭包是非常实用的。

跟随闭包能够放在函数參数列表外，也就是括号外。就是将原本在參数列表内的闭包提取到函数的后边书写，这样就利于阅读及使用。

1. 还是用sort的方法为例，正常的闭包写法例如以下：

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

但能够发现，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,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函数没有不论什么其它的參数。仅仅有一个闭包參数。所以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
}

四、 捕获值 
闭包能够依据环境上下文捕获到定义的常量和变量。

闭包能够引用和改动这些捕获到的常量和变量。在Swift中闭包的最简单形式是嵌套函数。

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  

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

__weak typeof(self) wSelf = self;

方式一： 使用 unowned keyword

在Swift中的闭包中也存在相同的问题。事实上大致思路是一致的，我们能够使用unowned keyword。 
Example。 将一个对象的属性转化为XML形式显示：

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()

上面的代码中。self对asHtml这个闭包属性有强引用，而asHtml内部又有对self的强引用，所以我们能够使用[unowned self] 将self “弱化”。从而解除了循环引用。

注：  unowned keyword就相当于oc中的__unsafe_unretained,当不安全指针指向的对象销毁时。指针依旧指向曾经指向的内存地址(野指针)

方式二： 使用 weak keyword

lazy var asHtml: () -> String = {
        [weak self] in
        if let text = self.text {
            return "<\(self.name)>\(self.text)</\(self.name)>"
        } else {
            return "<\(self.name)>"
        }
    }

注： weakkeyword相当于oc中的__weak, 当弱指针指向的对象销毁时。指针自己主动指向nil

方式三： oc中相应的weakkeyword

weak var weakSelf = self
lazy var asHtml: () -> String = {
        if let text = weakSelf.text {
            return "<\(weakSelf.name)>\(weakSelf.text)</\(weakSelf.name)>"
        } else {
            return "<\(weakSelf.name)>"
        }
    }

注意：当中另外一种和第三种方法使用比較常见。

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

功能非常easy
1. 上面灰色的View就是自己定义的View（TestView.swift）。它包括一个文本输入框和一个“GO”button。
2. 后面这一块就是控制器的View（ViewController.swift），它里面包括一个testLabel。
3. 点击"GO"button后将文本框中的内容回调到ViewController.swift中的Label显示
TestView.swift 代码：

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, 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, 30, 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")
    }
}

代码中。我定义了一个testClosure闭包属性，当点击“GO”button则会调用其方法。注意到闭包的定义

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.
    }
}