Swift 5 闭包Closure简明教程

系统: Mac OS 10.15.2， XCode 11.3，swift 5.0
写作时间：2020-01-09

说明

Swift中的闭包(Closure) ，闭包的地位等同于OC中的Block！

Objc 闭包的写法

 void (^printBlock)(NSString *x);  
      printBlock = ^(NSString* str)  { 
           NSLog(@"print:%@", str);  
      };  
      printBlock(@"hello world!"); 

Swift 闭包 的写法

// 定义语法
//{  
//   (参数列表) ->返回值类型 in 
//     语句组
//}

  // 声明一个闭包(有两个整形参数，且返回值为整形的闭包)
    var sumClosure:((a: Int, b: Int) -> Int)
    
    // 实现闭包
    sumClosure = {  (a: Int, b: Int) -> Int in 
         return a + b
    }

    // 调用
    let sum = sumClosure(a: 10,b: 20)print(sum)

Swift 闭包重定义

// 有参数无返回值的
 typealias Myclosure1 = (str:String) ->Void

// 有参数无返回值的
typealias Myclosure2=(str:String) ->String

// 两个参数,一个返回值
typealias Myclosure3=(str:String,str:String)->String

// 无参数，无返回值
typealias Myclosure4=()->Void

// 使用如下
 var closure1: Myclosure1?
   closure1 = { (str: String) ->Void in 
        print(str)
    } 
   closure1!(str: "HelloWorld")

Swift 比较作为方法的参数

// MARK: - 闭包作为方法参数
 var closure4:Myclosure4?
 closure4 = { 
    print("Swift")
 }

 func Fun(myclosure: Myclosure4) { 
    myclosure()
 }

 Fun(closure4!)

Swift闭包 简化写法

// 形式1: 带有参数参数类型，参数名，返回值类型
 sumClosure = { (a: Int, b: Int) -> Int in return a + b}

// 形式2: 省略参数类型
sumClosure = { (a,b) -> Int in return a + b}

// 形式3: 省略返回值类型
sumClosure = { (a,b) in return a + b}

// 形式4：省略参数小括号
sumClosure = { a,b in return a + b}

// 形式5: 省略参数
sumClosure = { return $0 + $1}

// 形式6: 省略关键字
returnsumClosure = { $0 + $1}

Swift 闭包常用方式

1. 作为非空变量:

var closureName: (ParameterTypes) -> ReturnType

2. 作为可为空变量:

var closureName: ((ParameterTypes) -> ReturnType)?

3. 作为别名:

typealias ClosureType = (ParameterTypes) -> ReturnType

4. 作为静态变量:

let closureName: ClosureType = { ... }

5. 作为参数(用别名定义)，在函数中:

funcName(parameter: (ParameterTypes) -> ReturnType)

注释: 如果在闭包中的参数会函数体外变化，需要添加修饰词@escaping.

6. 作为函数回调的参数:

funcName({ (ParameterTypes) -> ReturnType in statements })

7. 作为函数的参数(不用别名定义):

array.sorted(by: { (item1: Int, item2: Int) -> Bool in return item1 < item2 })

8. 作为函数的参数(不用别名定义)，并隐藏参数类型(比如这里的item1: Int):

array.sorted(by: { (item1, item2) -> Bool in return item1 < item2 })

9. 作为函数的参数(不用别名定义)，并隐藏返回值类型(比如返回值类型为Bool):

array.sorted(by: { (item1, item2) in return item1 < item2 })

10. 作为函数的最后一个参数:

array.sorted { (item1, item2) in return item1 < item2 }

11. 作为函数的最后一个参数， 省略掉参数声明:

array.sorted { return $0 < $1 }

12. 作为函数的最后一个参数， 省略掉返回return关键字:

array.sorted { $0 < $1 }

13. 作为函数的最后一个参数， 省略掉返回具体实现，只用符号表示比较:

array.sorted(by: <)

14. 作为函数的参数，并清楚写清所有参数，返回值，类型，以及实现:

array.sorted(by: { [unowned self] (item1: Int, item2: Int) -> Bool in return item1 < item2 })

15. 作为函数的参数，并清楚写清所有参数，返回值，以及实现。其中省略掉参数类型，返回值类型，由上下文推论得出:

array.sorted(by: { [unowned self] in return $0 < $1 })

参考

https://docs.swift.org/swift-book/LanguageGuide/Closures.html

https://www.jianshu.com/p/79ab32f60485

https://fuckingclosuresyntax.com/