IOS swift3.0 下闭包语法整理

时间：2022-09-20 20:10:48

ios swift3.0 下闭包语法整理

一、闭包的概念

有oc基础的都知道，闭包其实是oc里面的block，语法格式不一样，但作用是一样的。主要是用于callback(异步回调)或者两个类之间的通信。它的本质一个函数，一个可执行的代码块，只是这个函数是没有名字的，也就是匿名函数。你也可以把他看作如 int、float一样，是一种数据类型，一种可以作为参数传递的数据类型。

二、基本语法

1、闭包的声明

?
1
2
3
4
5
6
7
8
9
10
//定义一个求和闭包
   //闭包类型：(int,int)->(int)
   let add:(int,int)->(int) = {
     (a,b) in
     return a + b;
   }
  //执行闭包，相当于调用函数
  let result = add(1100, 200);
   //打印闭包返回值
   print("result=\(result)");

闭包类型是由参数返回值决定，如上述add闭包类型为(int,int)->(int)，箭头前面括号是参数类型，多个参数逗号隔开，箭头后面括号返回值类型。

分析下上面代码，“=”左边的“ let add:(int,int)->(int) ”意思是声明一个add常量，add是一个闭包类型，并且这个闭包的类型是：(int,int)->(int)。

“=”右边是一个代码块，即闭包的具体实现，相当于给左边add常量赋值。代码块的语法格式：

?
1
2
3
4
{
    (参数1，参数2) in
    //code
 }

参数和需执行的代码（code）用 关键字“in”隔开，如果闭包没有参数， “ () in”可以直接省略：

?
1
2
3
{
  //code
 }

你也可以用关键字“typealias”先声明一个闭包的数据类型

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import uikit
 
//声明一个闭包类型 addblock
typealias addblock = (int,int)->(int);
 
class viewcontroller: uiviewcontroller {
 
  override func viewdidload() {
    super.viewdidload()
    let add:addblock = {
      (a,b) in
      return a + b;
    }
 
   let result = add(1100, 200);
    print("result=\(result)");
 }
}

3、闭包的用法

1、两个类之间的通信

ios中类之间的通信方式有多种，常用的有：协议代理、通知，以及本章要讲的闭包。因为协议代理用起来比较麻烦，又是声明协议方法、又要设置代理的，代码步骤太多，我一般不用；通知一般用于两个完全没有关联的类通信，可以一对多，但解耦和的太厉害，我一般是特定的场合用。所以针对有关联的两个类之间的通信，我一般是用闭包或block的，这样比较简洁迅速。

示例程序：监听控制器上一个自定义view按钮的点击

IOS swift3.0 下闭包语法整理
界面效果

customview类中代码

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class customview: uiview {
 
  //声明一个属性btnclickblock，type为闭包可选类型
  //闭包类型：()->() ，无参数，无返回值
  var btnclickblock:(()->())?;
 
  //重写 init(frame: cgrect)构造函数
  override init(frame: cgrect) {
    super.init(frame:frame);
    //创建按钮
    let btn = uibutton(frame: cgrect(x: 15, y: 15, width: 80, height: 32));
    btn.settitle("按钮", for: .normal);
    btn.backgroundcolor = uicolor.blue;
    //绑定事件
    btn.addtarget(self, action: #selector(customview.btnclick), for: .touchdown);
    //添加
    addsubview(btn);
 
  }
  //按钮点击事件函数
  func btnclick(){
 
    if self.btnclickblock != nil {
      //点击按钮执行闭包
      //注意：属性btnclickblock是可选类型，需要先解包
      self.btnclickblock!();
    }
  }
 
  required init?(coder adecoder: nscoder) {
    fatalerror("init(coder:) has not been implemented")
  }
 
}

controller类中代码：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class viewcontroller: uiviewcontroller {
 
  override func viewdidload() {
    super.viewdidload()
 
    //创建customview对象
    let cutomeview = customview(frame: cgrect(x: 50, y: 50, width: 200, height: 200));
    //给cutomeview的btnclickblock闭包属性赋值
    cutomeview.btnclickblock = {
      // () in 无参数可以省略
      //当按钮被点击时会执行此代码块
      print("按钮被点击");
    }
    cutomeview.backgroundcolor = uicolor.yellow;
    //添加到控制器view上
    self.view.addsubview(cutomeview);
 
  }
}

2、异步回调（callback）

以发送一个简单的网络请求为例:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/// 定义一个网络请求函数
  ///
  /// - parameter urlstring: 请求接口  string
  /// - parameter succeed:  成功的回调 可选闭包
  /// - parameter failure:  失败的回调 可选闭包
  func requestdata(urlstring:string,succeed: ((any?)->(void))?,failure:((any?)->(void))?){
 
    let request = urlrequest(url: url(string: urlstring)!);
 
    //发送网络请求
    nsurlconnection.sendasynchronousrequest(request, queue: operationqueue()) { (_, data, error) in
      if error == nil {
        //请求成功，执行成功的回调，并把数据传递出去
        succeed?(data);
      }else{
         //请求失败，执行失败的回调，并把错误传递出去
        failure?(error);
      }
    }
  }
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 调用函数requestdata函数
    requestdata(urlstring: "http://www.baidu.com", succeed: { (data) -> (void) in
 
      //成功的回调
      guard let result = data as? data else{
        return;
      }
 
      let srt = nsstring(data: result, encoding: string.encoding.utf8.rawvalue);
 
      print(srt!)
 
 
      }) { (error) -> (void) in
        //失败的的回调
        print(error);
    }

四、闭包的一些特殊语法

1、尾随闭包

当闭包作为函数的最后一个参数时，可以省略前面的括号。尾随闭包没什么特殊的作用，纯粹是一种语法上的简洁，增加易读性。

例：定义一个函数：

?
1
2
3
4
5
6
7
//第二个参数：闭包 (string)->(void)
func post(url:string,succesce:(string)->void) {
 
    print("发送请求");
 
    succesce("请求完成");
  }

执行函数，正常写法：

?
1
2
3
4
5
6
7
8
//正常写法，第二个参数，传递一个闭包
  post("http", succesce: {
     //闭包传递的参数
     (json) in
     //执行的代码
      print(json);
 
   });

执行函数，尾随闭包写法：

?
1
2
3
4
//尾随闭包，当闭包作为函数的最后一个参数时，可以省略前面的括号
 httptool.post("http") { (json) in
      print(json);
    };

2、逃逸闭包

看起来很“吊炸天”的一个名字，其实很简单。当闭包作为一个参数传递到函数时，我们知道它一般是用于函数内部的异步回调，闭包是等异步任务完成以后才调用，而函数是会很快执行完毕并返回的，所以闭包它需要逃逸，以便稍后的回调。

逃逸闭包一般用于异步函数的回调，比如网络请求成功的回调和失败的回调。语法：在函数的闭包行参前加关键字“@escaping”。

或许细心的人已经发现我上面的示例网络请求为什么没有出现关键字“@escaping”，你可以拉回去看下成功回调或失败的回调，类型是“((any?)->(void))?”，后面带了个“？”，这是闭包可选类型，并不是闭包类型，所以无需关键字“@escaping”。

假设成功和失败的回调要弄成闭包类型，而你又要异步使用的话，那就要在形参前面加关键字，如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
/// 定义一个网络请求函数
 ///
 /// - parameter urlstring: 请求接口  string
 /// - parameter succeed: 成功的回调 闭包 因需要异步使用，前面加关键字@escaping修饰，指明其为逃逸闭包
 /// - parameter failure: 失败的回调 闭包 因需要异步使用，前面加关键字@escaping修饰，指明其为逃逸闭包
 func requestdata(urlstring:string,succeed: @escaping (any?)->(void),failure:@escaping (any?)->(void)){
 
   let request = urlrequest(url: url(string: urlstring)!);
 
   //发送网络请求
   nsurlconnection.sendasynchronousrequest(request, queue: operationqueue()) { (_, data, error) in
     if error == nil {
       //请求成功，执行成功的回调，并把数据传递出去
       succeed(data);
     }else{
        //请求失败，执行失败的回调，并把错误传递出去
       failure(error);
     }
   }
 }

假设成功和失败的回调要弄成闭包类型，而你又要异步使用的话，但你又不想在形参前面加关键字，那对不起，我也没有办法，编译直接报错！

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

原文链接：http://www.jianshu.com/p/d1e5201ad616

标签：

相关文章