一.闭包的介绍
闭包是功能性自包含模块，可以在代码中被传递和使用。 Swift 中的闭包与 C 和 Objective-C中的 blocks 以及其他一些编程语言中的 lambdas 比较相似。
-
闭包可以 捕获 和存储其所在上下文中任意常量和变量的引用。 这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。Swift会为您管理在 捕获 过程中涉及到的内存操作。
- OC中的block是匿名的函数
- Swift中的闭包是一个特殊的函数
- block和闭包都经常用于回调
二.block的用法回顾
<1>. block写法总结:
block的写法:
类型:
返回值类型(^block的名称)(block的参数)
值:
^(参数列表) {
// 执行的代码
}
//例子
int (^sumOfNumbers)(int a, int b) = ^(int a, int b) {
return a + b;
};
<2>. block实现两个界面之间的传值
①在后面控制器的 .h文件 中声明block
// 一会要传的值为NSString类型
typedef void (^newBlock)(NSString *);
@interface NewViewController : UIViewController
// 声明block属性
@property (nonatomic, copy) newBlock block;
②在后面控制器的 .m文件 中设置block
- (void)viewWillDisappear:(BOOL)animated
{
[super viewWillDisappear:YES];
if (self.block != nil) {
self.block(@"呵呵");
}
}
③在前面控制器的 .m文件 中接收传来的值
NewViewController *newVC = [[NewViewController alloc] init];
// 接收block传来的值
__weak ViewController *weakSelf = self;
newVC.block = ^(NSString *str){
NSLog(@"%@,%@", weakSelf,str);
};
<3>. 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]);
}];
}
三.闭包的用法
<1>. 闭包写法总结:
类型:(形参列表)->(返回值)
技巧:初学者定义闭包类型,直接写()->().再填充参数和返回值
值:
{
(形参) -> 返回值类型 in
// 执行代码
}
let b = { (parm : Int) -> (Int) in
print(parm)
}
//调用
b(100)
<2>.闭包的简写
- 如果闭包没有参数,没有返回值，in和in之前的内容可以省略
httpTool.loadRequest({
print("回到主线程", NSThread.currentThread());
})
- 尾随闭包写法:
- 如果闭包是函数的最后一个参数,则可以将闭包写在()后面
- 如果函数只有一个参数,并且这个参数是闭包,那么()可以不写
httpTool.loadRequest() {
print("回到主线程", NSThread.currentThread());
}
// 开发中建议该写法
httpTool.loadRequest {
print("回到主线程", NSThread.currentThread());
}
<3>.使用闭包代替block,闭包作为参数进行延时回调
- 定义网络请求的类
class HttpTool: NSObject {
func loadRequest(callBack : ()->()){
dispatch_async(dispatch_get_global_queue(0, 0)) { () -> Void in
print("加载数据", [NSThread.currentThread()])
dispatch_async(dispatch_get_main_queue(), { () -> Void in
callBack()
})
}
}
}
- 进行网络请求,请求到数据后利用闭包进行回调
override func touchesBegan(touches: Set<UITouch>, withEvent event: UIEvent?) {
// 网络请求
httpTool.loadRequest ({ () -> () in
print("回到主线程", NSThread.currentThread());
})
}
<3>.实例二，闭包的回调传值
//[weak self]:解决循环引用导致的内存泄露
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
delayMethod {[weak self] (re) ->() in
print("$$$$$$$$$$$$$$$$$:\(re)%%%%%%%%%%%\(String(describing: self))")
}
delayMethod(comletion: {[weak self] (re)->() in
print("********:\(re)*************\(String(describing: self))")
})
}
//@escaping:逃逸闭包。它的定义非常简单而且易于理解。如果一个闭包被作为一个参数传递给一个函数，并且在函数return之后才被唤起执行，那么这个闭包是逃逸闭包。
func delayMethod(comletion: @escaping (_ results: String,_ resultss:String) -> ()) ->(){
//开启一个全局异步子线程
DispatchQueue.global().async {
Thread.sleep(forTimeInterval: 2.0)
//回调到主线程
DispatchQueue.main.async(execute: {
print("主线程更新 UI \(Thread.current)")
comletion("qwertyui","asdf")
})
}
}
<4>.闭包进行两个界面的传值
- 我们要实现点击第二个界面后，关掉第二个界面，并且传值给第一个界面
<1>.首先在第二个界面声明闭包进行操作
class NewViewController: UIViewController {
//声明闭包
typealias lewisCloser = (_ paramOne : String? ) -> ()
//定义个变量 类型就是上面声明的闭包
var customeCloser: lewisCloser?
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
if(customeCloser != nil) {
customeCloser!("要发给第一个界面的值")
}
self.dismiss(animated: true, completion: nil)
}
override func viewDidLoad() {
super.viewDidLoad()
// Do any additional setup after loading the view.
}
}
<2>.在第一个界面实现闭包，取得要穿的值
let vc = NewViewController()
//实现闭包
vc.customeCloser = {(cusValue) -> () in
//cusValue就是传过来的值
print("^^^^^^^^^^^^^^^^^^^^^:\(cusValue!)")
}
self.present(vc, animated: true, completion: nil)
以上就是swift中闭包和OC中block的用法比较，欢迎评论交流！
