Swift笔记<二十>闭包

1.闭包的介绍

• 闭包和OC中的block非常相似

2.闭包的使用

• block的定义属性和方法中带block

//属性定义
@property(nonatomic,copy) int(^resultBlock)(int a,int b)
- (void)text: (void(^)())resultBlock;

• 闭包==特殊的函数

var add: (Int,Int) -> (Int) = {
    (a,b)->(Int) in
    return a+b
}
add(10,20)


var sub: (Int,Int) -> (Int) = {
    (a,b)->(Int) in
    return a-b
}

sub(10,1)

func exec(n1:Int,n2:Int,block:(Int,Int) -> (Int))->Int{
    
    return block(n1,n2)
}

exec(n1: 10,n2: 3,block: sub)
exec(n1: 10,n2: 3,block: {
    (a,b)-> Int in
    
    return a+b
    
})

//如果闭包,参数是没有的,可以省略,in和in前面的内容
var bb:() -> Int = {
    
    return 10
    
}

3.参数闭包|尾随闭包|逃逸闭包

//参数闭包
func text(a:Int,bb:(Int,Int)->(Int)){
    
    print(bb(a,a))
}
//尾随闭包
text(a: 1){(aa,bb)->(Int) in
    
    return 10
}

//如果以后,设计一个函数,函数里面需要接收闭包类型,一定注意,尽量把闭包参数放在最后

//逃逸闭包

func text2(bb:@escaping (Int,Int)->(Int)){
    
    bb(1,2)
    
    //@escaping:代表这个闭包,是逃逸闭包,以后有可能会被其他的闭包,延长生命周期(强引用)
    
    DispatchQueue(label:"xx").asyncAfter(deadline: DispatchTime.now()+DispatchTimeInterval.seconds(2)) {
        
        bb(1,4)
    }  
}

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

• 在OC中解决循环引用

__weak typeof(self)weakself = self;
//或者
//__unsafe__unretained typeof(self)weakself = self;

//两者区别
//1.__weak修饰时 ,weakself一旦被释放,weakself =nil,nil发送消息是可行的
//2.__unsafe__unretained修饰时,weakself依然保存的是之前的内存地址,会易引发野指针错误

*swift中解决循环引用

class Person{
    
    var resultBlock:(()->())?
//解决方案一
//    func text(){
//        weak var weakSelf = self
//        resultBlock = {
//            print("xxx",weakSelf)
//        }
//        resultBlock?()
//    }
//解决方案二
//        func text(){
//            resultBlock = {
//                [weak self]
//                in
//                print("xxx",self)
//            }
//            resultBlock?()
//        }
    
//解决方案三
//            func text(){
//                //unowned 相当于oc中的__unsafe_unretained
//                unowned var weakSelf = self
//                resultBlock = {
//                    print("xxx",weakSelf)
//                }
//                resultBlock?()
//            }
//解决方案四
                func text(){
                    //unowned 相当于oc中的__unsafe_unretained
                    
                    resultBlock = {
                        [unowned self]
                        in
                        print("xxx",self)
                    }
                    resultBlock?()
                }
    
    
    deinit {
        print("人被释放了")
    }
    
}
var p :Person? = Person()
p?.text()
p = nil