使用func和closure加工数据(一)

[TOC]

函数的返回值以及灵活多变的参数

作为开始，我们就简单的快速学习一下Swift中函数的基本要素，这将是我们接下来所有内容的基础。

一个简单的函数

一个简单的函数看上去是这个样子的：

func printName() {
    print("My name is Mars")
}

其中：

• func是定义函数的关键字，后面是函数名；
• ()中是可选的参数列表，既然是最简单的函数，自然我们可以让它留空；
• ()后面，是函数的返回值，同样，简单起见，我们也没有定义返回值
• {}中是函数要封装的逻辑，其实，在这里，我们调用print，也是一个函数，只不过，它是一个定义在标准库中的函数，并且带有一个参数罢了

向函数传递参数

我们定义一个计算两个整数的乘机：

func mul(m: Int, n: Int) {
    print(m*n)
}

然后我们通过下面这样来使用mul:

mul(m: 2, n: 3) // 6

为参数设置默认值

我们在声明函数时，经常会遇到处理参数的默认值问题。它可以用来约束函数的默认行为，或者简化大多数时候都会传递的值。例如：

func mul(_ m: Int, of n: Int = 1) {
    print(m*n)
}

当我们使用的时候：

mul(2) //2

拥有默认值的函数参数必须从右向左依次排列，有默认值的参数不能出现在无默认值的参数的左边。

定义可变长参数

接下来，如果我们要计算不确定个数参数的乘积该怎么办呢？Swift还允许我们通过下面的方式，定义可变长度的参数列表：

func mul(_ numbers: Int ... ) {
    let arrayMul = number.reduct(1, *)
    print("mul: \(arrayMul)")
}

在上面的例子中，我们用numbers:Int ...的形式，表示函数可以接受的Int参数的个数是可变的。实际上，numbers的类型，是一个Array<Int>,因此，为了计算乘积，我们直接使用Array类型的reduce方法就好了。
定义好以后，我们可以这样调用它：

mul(2, 3, 4, 5, 6, 7) //5040

定义inout参数

Swift里，函数的参数有一个性质：默认情况下，参数是只读的，这也就意味着：

• 你不能再函数内部修改参数值；
• 你也不能通过函数参数对外返回值；

func mul(result: Int, _ number: Int ...) {
    result = numbers.reduce(1, *) //!!! Error Here !!!
    print("mul: \(arrayMul)")
}

在上面的实现里，函数的参数默认是个常量，因此编译器会提示你不能再函数内部对常量赋值。然后再来第二条：如果我们希望参数可以被修改，并且把修改过的结果返回给传递进来的参数，该怎么办呢？

其实，很简单，我们需要用inout关键字修饰一下参数的类型就ok了！明确告诉Swift编译器我们要修改这个参数的值：

func mul(result: inout Int, _ number: Int ...) {
    result = numbers.reduce(1, *)
    print(mul: \(result))
}

然后就可以这样使用mul了

var result = 0
mul(result: &result,2,3,4,5,6,7)
result //5040

对于inout类型的参数，我们在调用的时候，也需要在参数前明确使用&.这样，mul执行结束后，就可以看到result的值变成了5040

通过函数返回内容

当然，通过参数来获取返回值只能算函数的某种副作用，更"正统"的做法应该是把返回值放在函数的定义里，像这样：

func mul(_ number: Int ...) -> Int {
    return numbers.reduce(1, *)
}

我们通过->Type的方式，在参数列表后面定义返回值。然后，就可以用mul的返回值来定义变量了：

let result = mul(2,3,4,5,6,7) // 5040

函数和Closure真的是不同的类型么？

提起closure，如果你有过其他编程语言的经历，你可能会立即联想起一些类似的事物，例如：匿名函数、或者可以捕获变量的一对{}等等。但实际上，我们很容易搞混两个概念：Closure expression和Closure。他们究竟是什么呢？我们先从closure expression开始。

理解Closure Expression

简单来说，closure expression就是函数的一种简写形式。例如，对于下面这个计算参数平方的参数：

func square(n: Int) -> Int {
    return n*n
}

我们也可以这样来定义：

let squareExpression = { (n: Int) -> Int in
    return n*n
}

在调用的时候是完全相同的：

square(2) // 4
squareExpression(2) // 4

并且它们都可以当做函数的参数来使用：

let numbers = [1, 2, 3, 4, 5]
numbers.map(square) // [1, 4, 9 ,16, 25]
numbers.map(squareExpressions) // [1, 4, 9 ,16, 25]

我们在这个例子里，用于定于squareExpressions的{}就叫做closure expression,它只是把函数参数、返回值以及实现统统写在了一个{}里。
没错，此时的{}以及squareExpressions并不能叫做closure,它只是一个closure expression。那么，为什么要有两种不同的方式来定义函数呢？最直接的理由就是，为了写起来更简单。Closure expression可以再定义它的上下文里，被不断的简化，让代码尽可能的呈现出最自然的语义形态。

例如，当我们把一个完成的closure expression定义在map参数里，是这样的：

numbers.map ({ (n: Int) -> Int in 
    return n * n
})

首先Swift可以根据numbers的类型，自动推导出map中的函数参数以及返回值的类型，因此，我们可以在closure expression中去掉它：

numbers.map ({ n in return n * n })

其次，如果closure expression中只有一条语句，Swift可以自动把这个语句的值作为整个expression的值返回，因此，我们还可以去掉return关键字：

numbers.map ({ n in n * n })

第三，如果你觉得在closure expression中为参数起名字是个意义不大的事情，我们还可以使用Swift内置的$0/$1/$2/$3这样的形式作为closure expression的参数替代符，这样，我们连参数声明和in关键字也可以省略了：

numbers.map ({ $0 * $0 })

第四，如果函数类型的参数在参数列表的最后一个，我们还可以把closure expression写在()外面，让它和其它普通参数更明显的区分开：

numbers.map(){ $0 * $0 }

最后，如果函数只有一个函数类型的参数，我们甚至可以再调用的时候，去掉():

numbers.map { $0 * $0 }

看到这里，就应该知道当我们把closure expression用在它的上下文里，究竟有多方便了，相比一开始的定义，或者单独定义一个函数，然后传递给它，都好太多。但事情至此还没结束，相比这样：

numbers.sorted(by: {$0 > $1}) // [5,4,3,2,1]

closure expression 还有一种更简单的形式：

numbers.sorted(by: > ) // [5,4,3,2,1]

这是因为，numbers.sorted(by:)的函数参数是这样的：(Int ,Int) -> Bool,而Swift为Int类型定义的>操作符也正好和这个类型相同，这样，我们就可以直接把操作符传递给它，本质上，这和我们传递函数名是一样的。

另外，除了写起来更简单之外，closure expression还有一个副作用，就是默认情况下，我们无法忽略它的参数，编译器会对这种情况报错。看个例子，如果我们要得到一个包含了10个随机数的Array，最简单的方法，就是一个CountableRange调用map方法：

(0 ... 9).map { arc4random() } // Error in Swift

这样看似很好，但是由于map的函数参数默认是带有一个参数的，在我们的例子里，表示range中的每个值，因此，如果我们在整个closure expression里都没有使用这个参数，Swift编译器就会提示我们错误。

我们不能默认忽略closure expression中的参数，如果坚持如此，我们必须用_明确表明这个意图：

(0 ... 9).map { _ in arc4random() } 

这也算是Swift为了类型和代码安全，利用编译器，为我们提供的一层保障。以上，就是和closure expression有关的内容，如你看到的一样，它就是函数的另外一种在上下文中更简单的写法和用func定义的函数没有任何区别。

究竟什么是closure

如果我们翻翻Wikipedia，就能找到下面的定义：a closure is a record storing a function together with an environment。
说的通俗一点，一个函数加上它捕获的变量一起，才算一个closure。来看个例子：

func makeCounter() -> () -> Int {
    var value = 0
    return { 
        value += 1
        return value
    }
}

makeCounter()返回一个函数，用来返回它被调用的次数。然后，我们分别定义两个计数器，并各自调用几次：

let counter1 = makeCounter()
let counter2 = makeCounter()

(0...2).forEach { _ in print(counter1())} // 1 2 3
(0...5).forEach { _ in print(counter2())} // 1 2 3 4 5 6

这样，三次调用counter1()会在控制台打印"123",6次调用会打印“123456”。这说明什么呢？

首先，尽管从makeCounter返回后，value已经离开了它的作用域，但我们多次调用counter1或counter2时，value的值还是各自进行了累加。这就说明，makeCounter返回的函数，捕获了makeCounter的内部变量value。
其次，counter1和counter2分别有其各自捕获的value，也就是其各自的上下文环境，他们并不共享任何内容。

理解了closure的含义之后，我们就知道了，closure expression和closure并不是一回事儿。然后，捕获变量是{}的专利么？实际上也不是，函数也可以捕获变量。

函数同样可以是一个Closure

还是之前makeCounter的例子，我们把返回的closure expression改成一个local function：

func makeCounter() -> () -> Int {
    var value = 0
    return increase() -> Int {
        value += 1
        return value
    }
    return increase
}

然后你就会发现，之前counter1和counter2的例子的执行结果，和之前是一样的：

(0...2).forEach { _ in print(counter1()) } // 1 2 3
(0...5).forEach { _ in print(counter2()) } // 1 2 3 4 5 6

所以，捕获变量这种行为，实际上，跟用{}定义函数也没关系。