swift闭包用法

闭包可以等同于java的函数式接口，lambda表达式。在写java的时候自己以前也没写过函数式接口，都是用java8写好的map、peek这类的函数式接口。在转到swift开发后遇到了大量的闭包表达式，还有嵌套函数，这里记录一下关于闭包的用法，并会根据实际应用场景展示一下闭包的应用。

闭包类型

有三种，了解即可：全局闭包、嵌套闭包、闭包表达式。这三种都用的挺多。

· 全局闭包：

具有名称的闭包，该类型不能捕捉上下文的值。举例：

let closureFunction = { (para1: Int, para2: Int) -> Int in
    return para1 + para2
}

print(closureFunction(1,2))
\\将会打印3

这里的closureFunction就是一个全局函数，有自己的名字closureFunction，本身是一个闭包，可以在需要的时候调用。

· 闭包表达式

闭包表达式没有名字，是一种轻量级写法，和lambda表达式很相似。举个例：

let testArray = [3,2,5,7,1]
var sortResult = testArray.sorted(by: {(para1: Int, para2: Int) -> Bool in
    para1 < para2
})
print(sortResult)
//结果为顺序排列1、2、3、5、7

这里sorted这个api接受一个表达式作为参数，这个参数的名字为by，在这种情况下我们直接传入一个表达式（by之后{ }部分），这种表达式是没有名字的，但是可以根据上下文捕捉到相应的值。这里可以$0和$1来表示第一个值和第二个值简写表达式，这里不举例了。

· 嵌套函数

嵌套函数是指在函数内部又加了一个函数并执行相关 *** 作的一种函数。嵌套函数拥有自己的名字，并且可以捕捉到上下文的变量值。看了菜鸟课程，这里举一个嵌套函数的例子：

func makeIncremental(increamenteAmount amount: Int) -> () -> Int{
    var flag = 10
    
    func makeAdditionSum() -> Int{
        flag = amount + flag
        return flag
    }
    
    return makeAdditionSum
}

let result = makeIncremental(increamenteAmount: 10)
print(result())
//值为20

makeIncremental这个函数接受一个Int类型的参数，并且返回一个（）-> Int的函数。
makeAdditionSum是嵌套在makeIncremental函数内部的一个闭包。值得注意的是，闭包都是引用类型。

· 闭包作为参数

在swift的开发中，经常也会有需要闭包作为函数参数的情况。比如：

func printSomething(completion: ()->Void) {
    print("Hello")
    completion()
}

printSomething {
    print("World!")
}

//上面是下面这种写法的简略写法
printSomething (completion: {
	print("World!")
})
//打印"Hello \n World

在printSomething这个函数中有一个参数叫做completion，他接受的变量值类型为completion的闭包。同时，这个例子同时也是一个尾随闭包，尾随闭包指的是最后一个参数为闭包类型，在调用函数的时候就可以省略掉参数的声明，直接把闭包表达式写进去。

在开发中，最常见的闭包调用形式应该是在遇到Result的时候了。

Result

swift有一个枚举类型Result，里面只有两种情况：成功or失败。

先来看看Result的结构：

@frozen enum Result<Success, Failure> where Failure : Error

现在假设有这样一个场景。我在执行某个任务的时候，发送了一个网络请求，但是我现在要对这个网络请求成功or失败进行不同的 *** 作。当成功的时候我写入body_success，当失败的时候我写入body_failure.

func main() {
   sendMyMessage{ [weak self] result in 
     result.success {
         //body_success
     } .failure{
         //body_failure
     }     
   }
}

func sendMyMessage(completion: @escaping (NetWork.Result<Void>) -> Void) {
     if case .success{
      //completion(.success)
     } .failure{
      //completion(.failure)
     } 
  }
}

实际开发中经常还会遇到多层请求的嵌套。记住，使用尾随闭包的时候{}内部要写的是当捕捉到请求的时候想要做的成功or失败的行为，并且Result内或者类型要和func里面的参数保持一致。此时写的内容都是对应的func的传参，是会被对应的func所使用的；

而对于func来说，使用闭包的行为则像使用正常的传参一样即可。

即在使用func的时候才把闭包（期望的行为）当作传输给传进去做相应的处理。