详解Swift中的函数及函数闭包使用

一、引言

函数是有特定功能的代码段，函数会有一个特定的名称调用时来使用。Swift提供了十分灵活的方式来创建与调用函数。事实上在Swift，每个函数都是一种类型，这种类型由参数和返回值来决定。Swift和Objective-C的一大区别就在于Swift中的函数可以进行嵌套。

而Swift中的闭包是有一定功能的代码块，这十分类似于Objective-C中的block语法。Swift中的闭包语法风格十分简洁，其作用和函数的作用相似。

二、函数的创建与调用

函数通过函数名，参数和返回值来定义，参数和返回值决定一个函数的类型，在调用函数时，使用函数名来进行调用，示例如下：

//传入一个名字 打印并将其返回
func printName(name:String) -> String {
  print(name)
  return name
}
//进行函数的调用
printName("HS")

也可以创建没有参数的函数：

func onePuseTwo()->Int {
  return 1+2
}
onePuseTwo()
同样也可以创建没有返回值的函数：

func sayHello(){
  print("Hello")
}
sayHello()

上面介绍的函数类型都比较常见，对于多返回值的函数，在Objective-C中十分难处理，开发者通常会采用字典、数组等集合方式或者干脆使用block回调，在Swift中，可以使用元组作为函数的返回值，示例如下：

func tuples()->(Int,String){
  return (1,"1")
}
tuples()

也可以是函数返回一个Optional类型的值，支持返回nil，示例如下：

func func1(param:Int)->Int? {
  guard(param>0)else{
    return nil
  }
  return param
}
func1(0)
func1(1)

在函数的参数名前，开发者还可以再为其添加一个参数名称作为外部参数名，示例如下：

func func1(count param:Int ,count2 param2:Int)->Int? {
  //内部依然使用param
  guard(param>0)else{
    return nil
  }
  return param
}
//外部调用使用count
func1(count: 0,count2: 0)
func1(count: 1,count2: 1)

其实Swift函数中的参数列表有这样一个特点，除了第一个参数外，之后的参数都默认添加一个一个和内部名称相同的外部名称，如果开发者不想使用这个外部名称，使用_符号设置，示例如下：

func func2(param:Int,param2:Int,param3:Int) {

}
//有外部名称
func2(0, param2: 0, param3: 0)
func func3(param:Int,_ param2:Int,_ param3:Int) {

}
//没有外部名称
func3(0, 0, 0)

Swift也支持开发者为函数的参数创建一个默认值，如果函数的某个参数有设置默认值，则开发者在调用时可以省略此参数，示例如下：

func func4(param:Int=1,param2:Int=2,param3:Int) {
  print(param,param2,param3)
}
func4(3,param3:3)

还有一种情形在Objective-C中也很处理，对于参数数量不定的函数，在前面章节介绍过，Objective-C一般会使用list指针来完成，在Swift中编写这样的函数十分简单，示例如下：

func func5(param:Int...) {
  for index in param {
    print(index)
  }
}
func5(1,2,3,4)

Swift中参数默认是常量，在函数中是不能修改外部传入参数的值得，如果有需求，需要将参数声明成inout类型，示例如下：

func func6(inout param:Int) {
  param = 10
}
var count = 1
//实际上传入的是参数地址
func6(&count)
print(count)

三、函数类型

函数是一种特殊的数据类型，每一个函数属于一种数据类型，示例如下：

func func7(a:Int,_ b:Int)->Int{
  return a+b
}
var addFunc:(Int,Int)->Int = func7
addFunc(1,2)

函数也可以作为参数传入另一个函数，这十分类似于Objective-C中的block语法，示例如下：

func func7(a:Int,_ b:Int)->Int{
  return a+b
}
var addFunc:(Int,Int)->Int = func7
addFunc(1,2)
func func8(param:Int,param2:Int,param3:(Int,Int)->Int) -> Int {
  return param3(param,param2)
}
//传入函数
func8(1, param2: 2, param3: addFunc)
//闭包的方式
func8(2, param2: 2, param3:{ (a:Int,b:Int) -> Int in
  return a*b
  })

一个人函数也可以作为另一个函数的返回值，示例如下：

func func9()->(Int)->Int{
  //Swift支持嵌套函数
  func tmp(a:Int)->Int{
    return a*a
  }
  return tmp
}
var myFunc = func9()
myFunc(3)

四、从一个系统函数看闭包

Swift标准函数库中提供了一个sort排序函数，对于已经元素类型的数组，调用sort函数会进行重新排序并返回新的排序后的数组。这个sort函数可以接收一个返回值为Bool类型的闭包，来确定第一个元素是否排在第二个元素前面。代码示例如下：

var array = [3,21,5,2,64]
func func1(param1:Int,param2:Int) -> Bool {
  return param1>param2
}
//通过传入函数的方式
//array = [64,21,5,3,2]
array = array.sort(func1)
//通过闭包的方式
//array = [2,3,5,21,64]
array = array.sort({(param:Int,param2:Int)->Bool in
            return param<param2
          })

Swift语言有一个很显著的特点就是简洁，可以通过上下文推断出类型的情况一般开发都可以将类型的书写省略，这也是Swift语言设计的一个思路，由于闭包是作为函数的参数传入函数中的，因为函数参数的类型是确定，因此闭包的类型是可以被编译器推断出来的，开发者也可以将闭包的参数类型和返回值省略，上面的代码可以简写如下：

//将闭包的参数类型和返回值都省略
array = array.sort({(p1,p2) in return p1>p2})

实际上，如果闭包中的函数体只有一行代码，可以将return关键字也省略，这时会隐式的返回此行代码的值，如下：

array = array.sort({(p1,p2) in  p1>p2})

看到上面的表达式，是不是有点小震惊，闭包表达式竟然可以简写成这样！然而，你还是小看的Swift开发团队，后面的语法规则会让你明白什么是简洁的极致。可以看到上面的代码实现还是有3部分：参数和返回值，闭包关键字，函数体。参数和返回值即是参数列表，p1，p2，虽然省略了参数类型和返回值类型，但这部分的模块还在，闭包关键字即是in，它用来表示下面将是闭包的函数体，p1>p2即是函数体，只是这里省略了return关键字。闭包中既然参数类型和返回值类型编译器都可以自己推断出来，那么参数的数量编辑器也是可以自行推断的，因此，参数列表实际上也是多余的，闭包中会自动生成一些参数名称，和实际的参数数量向对应，例如上面sort函数中的闭包有两个参数，系统会自动生成$0和$1这两个参数名，开发者可以直接使用，因为参数列表都会省略了，那么也不再需要闭包关键字in来分隔参数列表与函数体，这时，闭包的写法实际上变成了如下的模样：

array = array.sort({$0<$1})

你没有看错，加上左右的大括号，一共7个字符，完成了一个排序算法。除了Swift，我不知道是否还有第二种语言可以做到。抛开闭包不说，Swift中还有一种语法，其可以定义类型的运算符方法，例如String类型可以通过=，<，>来进行比较，实际上是String类中实现了这些运算符方法，在某种意义上说，一个运算符即类似与一个函数，那么好了，sort函数中需要传入的方法对于某些类型来说实际上只是需要一个运算符，示例如下：

array = array.sort(>)

这次你可以真的震惊了，完成排序新算法只需要一个字符，不折不扣的一个字符。

五、Swift中闭包的更多特点

Swift中的闭包还有一个有趣的特点，首先闭包是作为参数传入另一个函数中的，因此常规的写法是将闭包的大括号写在函数的参数列表小括号中，如果闭包中的代码很多，这时在代码结构上来看会变得并不太清晰，为了解决这个问题，Swift中这样规定：如果这个闭包参数是函数的最后一个参数，开发者可以将其拉出小括号，在函数尾部实现闭包代码，示例如下：

//闭包结尾
func func2(param1:Int,param2:()->Void)->Void{
  param2()
  print("调用了func2函数")
}
func2(0){
    print("闭包中的内容")
}

如果一个函数中只有一个参数，且这个参数是一个闭包，那么开发者使用闭包结尾这种写法，完全可以将函数的参数列表小括号也省略掉，示例如下：

func func3(param:()->Void)->Void{
  param()
  print("调用了func3函数")
}
func3{
  print("闭包中的内容")
}

Swift中还有一个闭包逃逸的概念，这个很好理解，当闭包作为参数传递进函数时，如果这个闭包只在函数中被使用，则开发者可以将这个闭包声明成非逃逸的，即告诉系统当此函数结束后，这个闭包的声明周期也将结束，这样做的好处是可以提高代码性能，将闭包声明称非逃逸的类型使用@noescape关键字，示例如下：

func func3(@noescape param:()->Void)->Void{
  param()
  print("调用了func3函数")
}
func3{
  print("闭包中的内容")
}

逃逸的闭包常用于异步的操作，例如这个闭包是异步处理一个网络请求，只有当请求结束后，闭包的声明周期才结束。非逃逸的闭包还有一个有趣的特点，在其内部如果需要使用self这个关键字，self可以被省略。

闭包也可以被自动的生成，这种闭包被称为自动闭包，自动闭包可以自动将表达式封装成闭包，开发者不需要再写闭包的大括号格式，自动闭包不接收参数，返回值为其中表达式的值。示例如下：

//自动闭包演示
var list = [1,2,3,4,5,6]
//创建一个显式闭包
let closures = {
  list.removeFirst()
  list.append(7)
}
//将打印[1,2,3,4,5,6]
print(list)
//执行闭包
closures()
//将打印[2,3,4,5,6,7]
print(list)
func func4(closure:()->Void) -> Void {
  //执行显式的闭包
  closures()
}
func func5(@autoclosure auto:()->Void) -> Void {
  //执行自动闭包
  auto()
}
//显式闭包 需要大括号
func4(closures)
//将打印[3,4,5,6,7,7]
print(list)
//将表达式自动生成闭包
func5(list.append(8))
//将打印[3,4,5,6,7,7,8]
print(list)

自动闭包默认是非逃逸的，如果要使用逃逸的闭包，需要手动声明，如下：

func func5(@autoclosure(escaping) auto:()->Void) -> Void {
  //执行自动闭包
  auto()
}