闭包

闭包的介绍

  • 闭包和OC中的block非常相似
  • OC中的block是匿名的函数
  • Swift中的闭包是一个特殊的函数
  • block和闭包都经常用于回调
  • 注意:闭包和block一样,第一次使用时可能不习惯它的语法,可以先按照使用简单的闭包,随着学习的深入,慢慢掌握其灵活的运用方法.

闭包的使用

block的用法回顾

  • 定义网络请求的类
@interface HttpTool : NSObject
- (void)loadRequest:(void (^)())callBackBlock;
@end

@implementation HttpTool
- (void)loadRequest:(void (^)())callBackBlock
{
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"加载网络数据:%@", [NSThread currentThread]);

        dispatch_async(dispatch_get_main_queue(), ^{
            callBackBlock();
        });
    });
}
@end
  • 进行网络请求,请求到数据后利用block进行回调
- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event
{
    [self.httpTool loadRequest:^{
        NSLog(@"主线程中,将数据回调.%@", [NSThread currentThread]);
    }];
}
  • block写法总结:
block的写法:
    类型:
    返回值(^block的名称)(block的参数)

    值:
    ^(参数列表) {
        // 执行的代码
    };

Swift使用闭包代替block

  • 闭包写法:
闭包的写法:
类型:(形参列表)->(返回值)
技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值

值:
{
    (形参) -> 返回值类型 in
    // 执行代码
}
  • 定义网络请求的类
class HttpTool: NSObject {

    public func loadRequest(callBack : @escaping ()->()){

        DispatchQueue.global().async {
            print("加载数据\(Thread.current)")

            DispatchQueue.main.async{
                callBack()

                print(Thread.current)
            }
        }
    }
}
  • 进行网络请求,请求到数据后利用闭包进行回调
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    httpTool.loadRequest(callBack: {
        print("已经得到加载的数据")
    })

    //更简单写法
    httpTool.loadRequest {
        print("已经得到加载的数据")
    }
}
  • 尾随闭包写法:
  • 如果闭包是函数的最后一个参数,则可以将闭包写在()后面
  • 如果函数只有一个参数,并且这个参数是闭包,那么()可以不写
httpTool.loadRequest() {
    print("回到主线程", Thread.current);
}
// 开发中建议该写法
httpTool.loadRequest {
    print("回到主线程", Thread.current);
}

闭包的循环引用

  • 如果在HttpTool中有对闭包进行强引用,则会形成循环引用
  • 补充:在Swift中检测一个对象是否销毁,可以实现对象的deinit函数
// 析构函数(相当于OC中dealloc方法)
deinit {
    print("ViewController----deinit")
}
  • 循环引用的(实现)
  • 该实现是为了产生循环引用,而产生的循环引用
class HttpTool: NSObject {

    // 定义属性,来强引用传入的闭包
    var callBack : (()->())?

    func loadRequest(callBack : @escaping ()->()){
        DispatchQueue.global().async {
            print("加载数据", [Thread.current])

            DispatchQueue.main.async {
                callBack()
            }
        }

        self.callBack = callBack
    }
}

swift中解决循环引用的方式

  • 方案一:
  • 使用weak,对当前控制器使用弱引用
  • 但是因为self可能有值也可能没有值,因此weakSelf是一个可选类型,在真正使用时可以对其强制解包(该处强制解包没有问题,因为控制器一定存在,否则无法调用所在函数)
// 解决方案一:
weak var weakSelf = self
httpTool.loadRequest {
    print("加载数据完成,更新界面:", Thread.current)
    weakSelf!.view.backgroundColor = UIColor.red
}

  • 方案二:

  • 和方案一类型,只是书写方式更加简单

  • 可以写在闭包中,并且在闭包中用到的self都是弱引用
httpTool.loadRequest {[weak self] () -> () in
    print("加载数据完成,更新界面:", Thread.current)
    self!.view.backgroundColor = UIColor.red
}

  • 方案三:(常用)

  • 使用关键字unowned

  • 从行为上来说 unowned 更像OC中的 unsafe_unretained
  • unowned 表示:即使它原来引用的对象被释放了，仍然会保持对被已经释放了的对象的一个 "无效的" 引用，它不能是 Optional 值，也不会被指向 nil
httpTool.loadRequest {[unowned self] () -> () in
    print("加载数据完成,更新界面:", Thread.current)
    self.view.backgroundColor = UIColor.red
}

逃逸闭包&非逃逸闭包

Swift中的闭包有两种：逃逸闭包和非逃逸闭包，前者表示闭包将在函数返回之后执行；而后者则表示在函数返回前，即函数内部执行

  • 访问属性或调用方法时必须加self
  • 访问self时需要注意引用循环问题
  • 闭包在函数return之后执行，即异步执行

补充说明:现在swift3.0所有的函数都是默认@noescape，如果你需要逃脱的话需要使用@escaping修饰符。

注意：如果闭包中调用到了当前对象的属性或方法，需要加self

results matching ""

    No results matching ""