Swift3.0P1 语法指南——函数

原档：https://developer.apple.com/library/prerelease/ios/documentation/Swift/Conceptual/Swift_Programming_Language/Functions.html#//apple_ref/doc/uid/TP40014097-CH10-ID158

函数是完成指定任务的独立代码块。

Swift中的函数都有对应的类型，由参数类型和返回值类型共同组成。你可以像使用其他类型一样来使用函数类型，因此，可以将函数作为函数的参数，也可以将函数作为函数的返回值。函数中也可以嵌套函数，实现功能封装。

1、定义和调用函数

当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入（参数，parameters），也可以定义某种类型的值作为函数执行结束的输出（返回类型）。

要使用一个函数时，你用函数名“调用”，并传给它相应的输入值（称作实参，arguments）。一个函数的实参必须与函数参数表里参数的顺序一致。

func greet(person: String) -> String {
   let greeting = "Hello, " + person + "!"
   return greeting
}

输入不同的参数，返回不同的结果：

print(greet(person: "Anna"))
// prints "Hello, Anna!"
print(greet(person: "Brian"))
// prints "Hello, Brian!"

为了简化这个函数的定义，可以将问候消息的创建和返回写成一句：

func greetAgain(person: String) -> String {
    return "Hello again, " + person + "!"
}
print(greetAgain("Anna"))
// prints "Hello again, Anna!"

2、函数参数和返回值

（1）没有参数的函数

输入参数并不是必需的：

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())
// prints "hello, world"

（2）有多个参数的函数

函数可以有多个参数，都写在括号里，并用逗号分隔。每个参数都有一个label。

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return greetAgain(person)
    } else {
        return greet(person)
    }
}
print(greet("Tim", alreadyGreeted: true))
// prints "Hello again, Tim!"

当调用含有一个或多个参数的函数时，第一个参数之后的其他参数都会用参数名作标识。（V2.1）

（3）没有返回值的函数

返回值并不是必需的： 

func greet(person: String) {
    print("Goodbye, (person)!")
}
sayGoodbye("Dave")
// prints "Goodbye, Dave!"

没有返回值，箭头和返回类型就不用写了。

注意：严格来说，即使没有定义返回值，函数也必须返回一个值。没有返回值的函数实际上返回了一种特殊的值Void，这是一个空的元组，实际上也就是没有元素的元组，可以写成（）。

调用函数的时候，可以忽略它的返回值：

func printAndCount(stringToPrint: String) -> Int {
    print(stringToPrint)
    return stringToPrint.characters.count
}
func printWithoutCounting(stringToPrint: String) {
    printAndCount(stringToPrint)
}
printAndCount("hello, world")
// prints "hello, world" and returns a value of 12
printWithoutCounting("hello, world")
// prints "hello, world" but does not return a value

注意：函数的返回值可以不被使用，但是函数必须声明它会返回一个值。如果函数定义了返回值类型，但在函数底部没有返回一个值，将会报编译时错误。

（4）有多个返回值的函数

如果有多个返回值，可以用元组来作为函数的返回类型。

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

由于元组的成员名已在返回类型中声明，可以用点语法来取出元组中对应的值。

let bounds = minMax([8, -6, 2, 109, 3, 71])
print("min is (bounds.min) and max is (bounds.max)")
// prints "min is -6 and max is 109"

注意：元组的成员不需要在函数返回时命名，因为它们的名字已经在函数返回类型中有了定义。

（5）可选的元组返回类型

如果元组返回时，可能整个元组都没有值，那么，可以用可选元组来作为返回值类型，暗示返回的元组可能是nil。可选元组就是在元组的括号后面添加一个问号，例如(Int, Int)?或(String, Int, Bool)?。

注意：(Int, Int)?和(Int?, Int?)是不同的两个概念。可选元组是整个元组可能是nil，而不是各个成员的值可能是nil。

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

可以用可选绑定来检查函数是否返回了元组：

if let bounds = minMax([8, -6, 2, 109, 3, 71]) {
    print("min is (bounds.min) and max is (bounds.max)")
}
// prints "min is -6 and max is 109"

3、函数的参数名

函数的参数都有一个外部参数名（argument label）和局部参数名（parameter name）。

当调用函数时，外部参数名被用来标识参数。局部参数名则被用在函数的实现主体中。

默认情况下，局部参数名和外部参数名是相同的。

func someFunction(firstParameterName: Int, secondParameterName: Int) {
    // function body goes here
    // firstParameterName and secondParameterName refer to
    // the argument values for the first and second parameters
}
someFunction(1, secondParameterName: 2)

一般情况下，第一个参数省略其外部参数名，第二个以后的参数使用其局部参数名作为自己的外部参数名。

所有参数必须有不同的局部参数名（parameter name），尽管外部参数名（argument label）可以是相同的，独特的外部参数名还是能让代码更具有可读性。

（1）指定外部参数名（Label）

可以在本地参数名前指定外部参数名，中间以空格分隔。

func someFunction(argumentLabel parameterName: Int) {
    // function body goes here, and can use parameterName
    // to refer to the argument value for that parameter
}

注意：如果提供了外部参数名，那么函数在被调用时，必须使用外部参数名。

下面的例子中有多个参数：

func greet(person: String, from hometown: String) -> String {
    return "Hello (person)!  Glad you could visit from (hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// Prints "Hello Bill!  Glad you could visit from Cupertino.

为每个参数指定外部参数名，在你调用函数greet(person:from:)函数时两个参数都必须被标记出来。

（2）忽略外部参数名

如果你不想为参数设置label，可以用下划线(_)代替。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    // function body goes here
    // firstParameterName and secondParameterName refer to
    // the argument values for the first and second parameters
}
someFunction(1, 2)

注意：第一个参数的外部名默认是省略的，所以 不必为它添加下划线。（V2.1）

4、默认参数值

当默认值被定义后，调用这个函数时可以忽略这个参数。

func someFunction(parameterWithDefault: Int = 12) {
    // function body goes here
    // if no arguments are passed to the function call,
    // value of parameterWithDefault is 12
}
someFunction(6) // parameterWithDefault is 6
someFunction() // parameterWithDefault is 12

注意： 带有默认值的参数要放在函数参数列表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。

5、不定参数

不定参数（variadic parameter）可以接受零个或多个值。函数调用时，你可以用不定参数来传入不确定数量的输入参数。

通过在变量类型名后面加入（...）的方式来定义不定参数。

不定参数的传入值在函数体内实际是同类型的一个数组。例如，一个 Double... 型可变参数numbers，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8.25, 18.75)
// returns 10.0, which is the arithmetic mean of these three numbers

注意：每个函数最多有一个不定参数。

6、In-Out参数

函数的参数默认看做常量，在函数体内试图改变参数的值会报编译时错误。

如果你想在函数中改变某个参数的值，并将这种变化保留到函数外部，那么可以将参数定义为in-out参数。

in-out参数通过在参数类型前面加上inout关键字来定义。

只能将变量传给in-out参数，常量和字面量不能使用。

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
   let temporaryA = a
   a = b
   b = temporaryA
}

当把变量名传给in-out参数时，要在变量名前面加上&符号，表示函数可以修改该变量。

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now (someInt), and anotherInt is now (anotherInt)")
// Prints "someInt is now 107, and anotherInt is now 3”

注意： in-out参数不能有默认值，而且不定参数不能用 inout 标记。

7、函数类型

每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

上面的两个函数的函数类型都是(Int, Int) -> Int。

另一种函数：

func printHelloWorld() {
    print("hello, world")
}

其返回类型是() -> Void。

（1）使用函数类型

函数类型的使用和其他类型一样，例如，可以把一个函数赋值给一个常量或变量。

var mathFunction: (Int, Int) -> Int = addTwoInts

这样，可以用mathFunction的名字来调用addTwoInts函数：

print("Result: (mathFunction(2, 3))")
// prints "Result: 5"

同一函数类型的其他函数也可以赋值给这个变量：

mathFunction = multiplyTwoInts
print("Result: (mathFunction(2, 3))")
// prints "Result: 6"

由于函数推断，可以不用显示声明变量的类型：

let anotherMathFunction = addTwoInts
// anotherMathFunction is inferred to be of type (Int, Int) -> Int

（2）函数类型作为参数类型

你可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现交由给函数的调用者。

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: (mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// prints "Result: 8"

（3）函数类型作为返回类型

可以用函数类型作为另一个函数的返回类型。

例如，下面是两个简单函数。

func stepForward(_ input: Int) -> Int {
    return input + 1
}
func stepBackward(_ input: Int) -> Int {
    return input - 1
}

下面这个叫做 chooseStepFunction(_:) 的函数，它的返回类型是 (Int) -> Int 的函数。

chooseStepFunction(backward:) 根据布尔值 backwards 来返回 stepForward(_:) 函数或 stepBackward(_:) 函数：

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    return backward ? stepBackward : stepForward
}

可以用chooseStepFunction(_:) 来获得一个函数：

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the stepBackward() function

moveNearerToZero已获得了正确的函数，就可以用来将数字数到0：

print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    print("(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!

8、嵌套函数

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    func stepForward(_ input: Int) -> Int { return input + 1 }
    func stepBackward(_ input: Int) -> Int { return input - 1 }
    return backward ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    print("(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!