17-Swift中闭包的使用

一、闭包的介绍

• 闭包和OC中的block非常相似:
  1. OC中的block是匿名的函数；
  2. Swift中的闭包是一个特殊的函数；
  3. block和闭包都是经常用于回调。
• 注意：闭包和block一样，第一次使用时可能不习惯它的语法

二、闭包的使用

• block的使用回顾：

//block的定义
@property(nonatomic,weak) void (^myBlock)();

//block当作参数
-(void)test:(void(^)())block{
    block();
}

• 使用闭包代替block，闭包的写法：

var block:(形参列表)->(返回值) = {
    (形参) -> (返回值类型) in
}

//闭包是特殊的函数
var block:(Int)->() = {
    (a:Int) -> () in
    print(a + 13)
}
block(3)    //16

三、闭包的简写

var block2:()->() = {
    () -> () in
    print("test")
}
block2()    //test

//没有参数和返回值时，就可以省略
var block2 = {
    print("test")
}
block2()    //test

四、闭包作为参数

var addBlock:(Int,Int)->(Int) = {
    (a:Int,b:Int) -> (Int) in
    return a + b
}
var multipleBlock:(Int,Int)->(Int) = {
    (a:Int,b:Int) -> (Int) in
    return a * b
}

func testBlock1(a:Int,b:Int,block:(Int,Int)->(Int)){
    let result = block(a, b)
    print(result)
}
testBlock1(a: 5, b: 6, block: addBlock) //11
testBlock1(a: 5, b: 6, block: multipleBlock)    //30

五、尾随闭包

//尾随闭包
func weisuiBlock(block:()->()){
    block()
}
weisuiBlock {
    print("尾随闭包")
}

六、闭包的循环引用

1. weak：如果这个对象被释放了，那么对应的weakSelf指针指向nil；

//OC中
__weak typeof(self) weakSelf = self

2. __unsafe_unretained:如果这个对象被释放了，那么对应的weakSelf指针指向的还是原来的地址，容易导致野指针错误

//OC中
__unsafe_unretained typeof(self) weakSelf = self

3. 闭包的循环引用及解决方案一：

//闭包的循环引用及解决方案
class Person{
    var block:(()->())?

    func test() {
        weak var weakSelf = self
        block = {
            weakSelf
        }
    }

    deinit {
        print("释放了")
    }
}
var p:Person? = Person()
p?.test()
p = nil //释放了

4. 闭包的循环引用及解决方案二

//闭包的循环引用及解决方案二
class Person{
    var block:(()->())?

    func test() {
        block = {
            //告诉编译器，里面所有的self都是弱引用
            [weak self]
            ()->() in
            self
            self
        }
    }

    deinit {
        print("释放了")
    }
}
var p:Person? = Person()
p?.test()
p = nil //释放了

5. 闭包的循环引用及解决方案三

//闭包的循环应用及解决方案三
class Person{
    var block:(()->())?

    var a:Int = 10

    func test() {
        //weak：安全，如果对象被释放，值会置为nil（var可选）
        //unowned：不安全，如果对象被释放，不会改变里面的值：（let非可选）
        unowned let weakSelf = self
        block = {
            weakSelf.a += 10
            weakSelf
            weakSelf
        }
    }

    deinit {
        print("释放了")
    }
}
var p:Person? = Person()
p?.test()
p = nil //释放了

6. 闭包的循环使用及解决方案四

//闭包的循环使用及解决方案四
class Person{
    var block:(()->())?

    var a:Int = 10

    func test() {
        //weak：安全，如果对象被释放，值会置为nil（var可选）
        //unowned：不安全，如果对象被释放，不会改变里面的值：（let非可选）
        block = {
            [unowned self]
            ()->() in
            self
            self
            self
        }
    }

    deinit {
        print("释放了")
    }
}
var p:Person? = Person()
p?.test()
p = nil //释放了

• 一般情况下，解决方案二和方案四使用的较多。

七、闭包在懒加载中的使用

• OC中，懒加载就是重写get方法，并在其中进行一系列初始化操作；
• Swift中，懒加载通过关键字lazy和闭包实现
• 懒加载的两个特性：1.用到时再加载；2.多次使用只加载一次

//懒加载的使用
class Dog{
    var age:Int = 8
}
class Owner{
   lazy var dog:Dog = Dog()
    lazy var dog2:Dog = {
        //可以进行一系列的初始化工作
        let d = Dog()
        d.age = 12
        return d
    }()
}
let owner = Owner()
owner.dog
owner.dog2

注意：self不可以省略的地方

• 在闭包中使用self时，self不能省略；
• 如果子类有自定义的构造函数或者重写父类的构造函数，此时必须实现父类中使用required修饰的构造函数，在构造函数的super.init()之前，需要保证所有的属性被初始化完毕，此时初始化时候的self不能省略：

class YJWView:UIView{
    
    //定义属性
    var titles:[String]
    
    init(frame:CGRect,titles:[String]) {
        self.titles = titles
        super.init(frame:frame)
    }
    
    required init?(coder aDecoder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
}

• 懒加载时，self不可以省。