swift-闭包（2）

2022-02-04 17:00:21 阅读：157 来源： 互联网

一、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）
上下文的内存保存在栈上，不是堆上

标签：闭包,defer,调用,oc,swift,block
来源： https://www.cnblogs.com/suanningmeng/p/15863049.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

swift-闭包（2）