14.闭包

2018-10-11 16:06:11 浏览数 (1)
闭包引入

计算1个数的平方

  • 函数写法
代码语言：javascript复制
func square(param:Int)  -> Int{  
    return param * param
}
square(param:3)
  • 闭包写法
代码语言：javascript复制
let squareCloure = { (param:Int) -> Int in
    return param * param
}
squareCloure(3)
闭包含义
  • 闭包是可以被传递和引用的一个独立模块
  • 闭包能够捕获和存储定义在其上下文中的任何常量和变量，即闭合并包裹那些常量和变量，因此被称为“闭包”
  • 闭包符合如下三种形式中的一种：
    • 全局函数是一个有名字但不会捕获任何值的闭包
    • 内嵌函数是一个有名字且能从其上层函数捕获值的闭包（函数中的嵌套函数知识点）
    • 闭包表达式是一个轻量级语法，可以捕获其上下文中常量或变量值的没有名字的闭包
  • 闭包和函数一样也是引用类型
简单案例
  • 案例一
代码语言：javascript复制
let demo= { print("Swift 闭包实例。") }
demo()
  • 案例二
代码语言：javascript复制
let divide = {(val1: Int, val2: Int) -> Int in 
   return val1 / val2 
}
let result = divide(200, 20)
print (result)
闭包表达式

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

代码语言：javascript复制
  { (parameters) -> (return type) in
    statements
  }
  • 闭包表达式由一对{}开始与结束
  • 由in关键字将闭包分割成两部分：参数与返回值、闭包体
  • in 关键字表示闭包的参数类型和返回类型定义已经完成，并且闭包的闭包体即将开始
  • 闭包参数与函数参数的区别
    • 形式参数不能提供默认值
闭包主要知识点
参数名称缩写
  • Swift 提供了参数名称的缩写功能，直接通过 $0,$1,$2来顺序调用闭包的参数
  • 在闭包表达式中使用参数名称缩写，可以在闭包参数列表中省略对其定义
    • 参数类型可以通过函数类型进行推断
    • return 关键字可以省略
    • in 关键字也可以被省略
代码语言：javascript复制
//从数组中筛选指出合适的数据组成新的数组
func getList(score:[Int], con:(Int)->Bool) -> [Int]{
    
    var newScore:[Int] = [Int]()
    for item in score {
        if con(item) {
            newScore.append(item)
        }
    }
    return newScore
}

let newAarray = getList(score: [75,60,95,45,85],  con:{(s:Int)->Bool in return s>80})
print(newAarray)

第一种简写: 省略 ->与返回类型(根据后面表达式可以推断返回值是一个Bool)

代码语言：javascript复制
let newAarray = getList(score: [75,60,95,45,85],  con:{(s:Int) in return s>80})

第二种简写:省略参数类型和括号(根据函数的参数可推断传进来的必然是Int)

代码语言：javascript复制
let newAarray = getList(score: [75,60,95,45,85],  con:{s in return s>80})

第三种简写:省略return关键字

代码语言：javascript复制
let newAarray = getList(score: [75,60,95,45,85],  con:{s in s>80})

第四种简写:参数名称缩写，省略参数声明和in，改为$0

代码语言：javascript复制
let newAarray = getList(score: [75,60,95,45,85],  con:{$0>80})
捕获
  • 闭包可以从上下文环境中捕获常量、变量，并在自己的作用域内使用
  • Swift最简单的闭包形式是嵌套函数，也就是定义在其他函数的函数体内的函数，嵌套函数可以捕获其外部函数所有的参数以及定义的常量和变量。
代码语言：javascript复制
func makeIncrementor(forIncrement amount: Int) -> () -> Int {
    var runningTotal = 0
    func incrementor() -> Int {
        runningTotal  = amount
        return runningTotal
    }
    return incrementor
}

let incrementByTen = makeIncrementor(forIncrement: 10)
// 返回的值为10
print(incrementByTen())
// 返回的值为20
print(incrementByTen())
// 返回的值为30
print(incrementByTen())
尾随闭包
  • 尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用
    • 闭包是函数的最后一个参数
    • 函数的 ) 可以前置到倒数第二个参数末尾
    • 后面的参数直接使用 { // 执行代码 }
    • 如果您需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性
代码语言：javascript复制
func someFunctionThatTakesAClosure(closure: () -> Void ) {   
 //函数体部分
}  

//以下是不使用尾随闭包进行函数调用
someFunctionThatTakesAClosure ({ 
//闭包主体部分 
}) 

//以下是使用尾随闭包进行函数调用someFunctionThatTakesAClosure () {        
//闭包主体部分   
}
逃逸闭包
  • 闭包作为一个参数传递给一个函数
  • 传入函数的闭包如果在函数执行结束之后才会被调用，那么这个闭包就叫做逃逸闭包。
  • 声明一个接受闭包作为形式参数的函数时，可以在形式参数前写 @escaping 来明确闭包是允许逃逸的。
  • 逃逸闭包会在函数结束后才执行
  • 举例
代码语言：javascript复制
//1.定义一个函数
//全局数组变量completionHandlers
//存放没有参数、没有返回值的闭包
var completionHandlers: [() -> Void] = []
//不标记函数的形式参数为 @escaping ，会遇到编译时错误。
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
   //注意：此时传入的闭包并没有执行，仅仅是添加到全局数组中
   completionHandlers.append(completionHandler)
}
代码语言：javascript复制
//2.定义另一个接收闭包的函数
func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}
代码语言：javascript复制
/*
3.定义一个类:
初始化x值为10
通过调用上面定义的两个函数,使用尾随闭包的方式将实现"对x赋值"这么一个功能的闭包传入
*/
class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}
代码语言：javascript复制
//创建类的对象
let instance = SomeClass()
/*
执行doSomething函数
PS:内部执行someFunctionWithEscapingClosure，someFunctionWithNonescapingClosure，即期望内部会利用两个尾随闭包对x进行赋值
*/
instance.doSomething()
print(instance.x)
// 打印出 "200"
completionHandlers.first?()
print(instance.x)
// 打印出 "100" 因为闭包最后才被执行
自动闭包
代码语言：javascript复制
var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// 打印5
 
let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// 依然打印5 因为闭包并没有被调用

//调用一次闭包 
customerProvider()
print(customersInLine.count)
// 打印4
  • 一种自动创建的闭包，用于包装函数参数的表达式
  • 不接受任何参数，被调用时会返回被包装在其中的表达式的值
  • 自动闭包能够延迟求值，因为代码段不会被执行直到你调用这个闭包，这样你就可以控制代码什么时候执行
  • 在参数名前面加上@autoclosure关键字
代码语言：javascript复制
func printIfTrue (@autoclosure predicate: ()-> Bool){  
    if predicate(){  
        print("the result is true")  
    }  
}  
//直接进行调用了，Swift 将会把 2 > 1 这个表达式自动转换为 () -> Bool。这样我们就得到了一个写法简单，表意清楚的式子。  
printIfTrue(2 > 1)
闭包的循环引用
代码语言：javascript复制
class NetworkTools: NSObject {
/// 完成回调属性
var finishedCallBack: (()->())?
/// 加载数据
/// - parameter finished: 完成回调
func loadData(finished: () -> ()) {

    self.finishedCallBack = finished
    working()
}

func working() {
    finishedCallBack?()
}

deinit {
    print("网络工具 88")
}
代码语言：javascript复制
class ViewController: UIViewController {

    var tools: NetworkTools?
    override func viewDidLoad() {
        super.viewDidLoad()

        tools = NetworkTools()
        tools?.loadData() {
           print("加载数据完成,更新界面:", NSThread.currentThread())
           weakSelf!.view.backgroundColor = UIColor.redColor()
        }
    }
    /// 与 OC 中的 dealloc 类似，注意此函数没有()
    deinit {
        print("控制器 88")
    }
}
Swift中解决循环引用的方式
  • 方案一:
    • 使用weak,对当前控制器使用弱引用
    • 但是因为self可能有值也可能没有值,因此weakSelf是一个可选类型,在真正使用时可以对其强制解包(该处强制解包没有问题,因为控制器一定存在,否则无法调用所在函数)
代码语言：javascript复制
// 解决方案一:
weak var weakSelf = self
tools.loadData {
    print("加载数据完成,更新界面:", NSThread.currentThread())
    weakSelf!.view.backgroundColor = UIColor.redColor()
}
  • 方案二:
  • 和方案一类型,只是书写方式更加简单
  • 可以写在闭包中,并且在闭包中用到的self都是弱引用
代码语言：javascript复制
tools.loadData {[weak self] () -> () in
    print("加载数据完成,更新界面:", NSThread.currentThread())
    self!.view.backgroundColor = UIColor.redColor()
}
  • 方案三:
    • 使用关键字unowned
    • 从行为上来说 unowned 更像OC中的 unsafe_unretained
    • unowned 表示:即使它原来引用的对象被释放了，仍然会保持对被已经释放了的对象的一个 "无效的" 引用，它不能是 Optional 值，也不会被指向 nil
代码语言：javascript复制
tools.loadData {[unowned self] () -> () in
    print("加载数据完成,更新界面:", NSThread.currentThread())
    self.view.backgroundColor = UIColor.redColor()
}
存储 swift ide api

0 人点赞