Swift:闭包(Closures)

发布时间:2020-05-20 发布网站:脚本之家
脚本之家收集整理的这篇文章主要介绍了Swift:闭包(Closures)脚本之家小编觉得挺不错的,现在分享给大家,也给大家做个参考。

一、 基本概念

闭包(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,{ $0 > $1 })  

最简单的一种写法:使用操作符
sort(&names,>)

三、 尾随闭包(Trailing Closures)
如果函数需要一个闭包参数作为参数,且这个参数是最后一个参数,而这个闭包表达式又很长时, 使用尾随闭包是很有用的。尾随闭包可以放在函数参数列表外,也就是括号外。就是将原本在参数列表内的闭包提取到函数的后边书写,这样就利于阅读及使用。
1. 还是用sort的方法为例,正常的闭包写法如下:

sort(&names,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,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
}

四、 捕获值
闭包可以根据环境上下文捕获到定义的常量和变量。闭包可以引用和修改这些捕获到的常量和变量。在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;

在Swift中的闭包中也存在同样的问题,其实大致思路是一致的,我们可以使用unowned 关键字。
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 “弱化”。从而解除了循环引用。


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


功能很简单
1. 上面灰色的View就是自定义的View(TestView.swift),它包含一个文本输入框和一个“GO”按钮。
2. 后面这一块就是控制器的View(ViewController.swift),它里面包含一个testLabel。
3. 点击"GO"按钮后将文本框中的内容回调到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,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")
    }
}

代码中,我定义了一个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)所遇到的程序开发问题。

如果觉得脚本之家网站内容还不错,欢迎将脚本之家网站推荐给程序员好友。

本图文内容来源于网友网络收集整理提供,作为学习参考使用,版权属于原作者。
如您喜欢交流学习经验,点击链接加入脚本之家官方QQ群:1065694478
脚本之家官方公众号

微信公众号搜索 “ 程序精选 ” ,选择关注!

微信公众号搜索 “ 程序精选 ”
精选程序员所需精品干货内容!