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