swift-闭包2

一、oc-Block与swift闭包相互调用

1.1 swift中调用oc的block

//OC

//oc  .h文件 定义一个方法，Block作为参数
+(void)testBlock:(void(^)(NSInteger index))block;

//oc  .m文件 实现方法，调用Block
+(void)testBlock:(void(^)(NSInteger index))block {
    if (block) {
        block(10);
    }
}

//swift

//swift中调用test方法
Test.testBlock { index in
    print("oc-block传过来的值\(index)")
}

//oc-block传过来的值10

1.2 oc调用swift中的闭包(类要继承自NSbject并且需要加@objc关键字暴露给oc调用)

//在Swift中定义一个闭包
class LGTest: NSObject {
    @objc static var closure: ((_ name: String) -> Void)?
}

//调用OC中的方法
Test.getName { name in
    print("oc-swift交互的值\(name)")
}
//调用闭包
LGTest.closure?("swift")


//在OC .h文件中定义一个方法（由于主要探讨的Swift内的闭包，所以这里需要把传过来的name再传回给Swift来输出）
+(void)getName:(void(^)(NSString *name))block;
//在OC .m文件中实现方法
+(void)getName:(void(^)(NSString *name))block{
    
    LGTest.closure = ^(NSString * _Nonnull name) {
        NSLog(@"Swift传过来的值 %@ ",name);
        block(name);
    };
}

//Swift传过来的值 swift oc-swift交互的值 swift

1.3 convention关键字

修饰swift的函数类型（调用c函数的时候）

//.h文件
int TestCFUnction(int (callBack)(int a, int b));
//.c文件

int TestCFUnction(int (callBack)(int a, int b)){
    return  callBack(10, 20);
}
//swif文件
let closure: @convention(c)(Int32, Int32) -> Int32 = {(a:Int32, b: Int32) -> Int32 in return a+b }

let result = TestCFunction(closure)

}

调用oc方法时，修饰swift函数类型

二、逃逸闭包

当闭包作为一个实际参数传递给一个函数时，且是在函数返回之后调用，我们说这个闭包就是逃逸闭包，当我们接受逃逸闭包作为函数参数时，就可以在闭包的前面加上@escaping来明确闭包时可逃逸的，我们将逃逸闭包的三点总结如下：

作为函数的参数传递
当前闭包在函数内部异步执行或者被存储
函数结束，闭包被调用，生命周期结束

class LGTeacher{
    var completionHandle: ((Int) -> Void)?

    func makeIncrementer(_ amout: Int, handler : @escaping (Int) -> Void) {
        var runningTool = 10
        runningTool += amout
        self.completionHandle = handler
//        DispatchQueue.global().asyncAfter(deadline: .now() + 0.1) {
//            handler(runningTool)
//        }
//    }

    func dosomething(){
        self.makeIncrementer(10) {
            print($0)
        }
    }

上面提示了我们handler是一个逃逸闭包，需要加@escaping关键字

三、自动闭包@autoclosure

自动闭包是一种自动创建的闭包，用于作为函数的表达式包装传递给函数，这种闭包不接受任何参数，当他被调用时，会返回被包装在其中的表达式的值。这种便利语法让我们可以省略闭包中的花括号，用一个普通的表达式来代替显式的闭包。

func debugOutPrint(_ condition: Bool , _ message: @autoclosure () -> String){
    if condition {
        print("lg_debug:\(message())")
    }
}
func dosomthing() -> String{
    //耗时的操作
    return "Application Error Occured"
}

debugOutPrint(true, dosomthing())

四、defer

defer{ }里的代码会在当前代码块返回的时候执行，无论当前代码块是从哪个分支return的，即使程序抛出错误，也会执行。

func testDefer() {
    defer {
        print("First defer")
    }
    defer {
        print("Second defer")
    }
    
    print("end of testDefer")
}
testDefer()

输出顺序
end of testDefer --> Second defer -> First defer

如果多个 defer 语句出现在同一作用域中，则它们出现的顺序与它们执行的顺序相反，也就是先出现的后执行。

let count = 2
let pointer = UnsafeMutablePointer<Int>.allocate(capacity: count)
pointer.initialize(repeating: 0, count: count)

defer {
    pointer.deinitialize(count: count)
    pointer.deallocate()
}

defer统一管理析构函数，在函数执行后统一执行

var a = 1
func add()->Int{
    defer{
        a = a + 1
    }
    return a
}
let temp = add()
print(temp)
print(a)
//1
//2

这里需要注意的是temp的值还是 1，因为defer是在返回之后执行。其实这里 defer这样使用并没有意义，我们要避免这样的写法，defer我们一般用来管理一些统一资源，优化冗余代码，使代码更加简洁直观。

五、非逃逸闭包

func testNoEscaping(_ f: () -> Void) {
    f()
}

func test() -> Int {
    var age = 18
    testNoEscaping {
        age += 20
    }

    return 30
}

test()

这个就是一个非逃逸闭包，当函数调用完之后这个闭包也就消失了。并且非逃逸闭包还有以下优点：

不会产生循环引用，函数作用域内释放
编译器更多性能优化（retain，release）
上下文的内存保存在栈上，不是堆上

原文地址：https://www.cnblogs.com/suanningmeng/p/15863049.html

相关推荐