Swift 函数总结

1. 函数
函数是执行某一特定任务的自包含代码块。你可以给函数一个名字来说明函数它是做什么的，而且当需要执行任务时使用这个名字调用函数。

Swift的统一的函数参数是非常灵活的，可以表示从单一的C风格没有参数的函数，到复杂的Objective-C具有名字和参数标签的方法。
参数可以提供默认值来简化函数调用，也可以传递in-out参数，一旦函数执行完，它可以修改传入的变量的值。

每一个Swift中的函数都有类型，由函数的参数类型和返回类型组成。在Swift中你可以像其他类型一样来使用这个函数类型。
这样将函数作为另一个函数的参数和作为返回值将变得更简单。函数可以写在其他函数的内置函数中，封装有用的功能。

2. 函数的定义和调用
定义：
func functionName(para1: ParamentType1, para2: ParamentType2,...)->ReturnType{
...
}

函数的定义是由func关键字来指定。functionName是函数名字，para1和para2是函数的参数，ParamentType是参数类型，
ReturnType是返回值类型。当返回值类型是Void时，可以省略。
如下面的函数：

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

函数调用：

print(greet("ZHUO Zeng-si"))

输出结果：
Hello, ZHUO Zeng-si!
Program ended with exit code: 0

3. 函数参数和返回值

    a. 无参数函数

        func sayHello()->String{
            return "Hello, world!"
        }

    虽然没有参数，但是括号还是要跟的。

    b. 多参数函数
    各个参数用逗号隔开。

    func getPersonInfo(name: String, age: Int) -> String {
            let greeting = name + ", age: " + String(age)
            return greeting
    }

    c. 没有返回值的函数

        func greetWithPerson(person: String){
            print("Hello," + person + "!")
        }

    无返回值函数可以省略“->”和Void。

    d. 多个返回值的函数
    可以将元组作为函数的返回类型返回多个值。

        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)
        }

    e. 可选元组返回类型
    d中的函数没有考虑全面，当输入的数组是空数组的时候，将会引发异常。可以改为如下的函数。

        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)
        }

    返回值的类型是可选元组，当输入的数组是空数组时，将会返回nil。

4. 函数参数标签和参数名字
    a. 参数标签的用法
    每一个函数参数都有一个参数标签和一个参数名字。
    参数标签是当调用这个函数的时候使用，参数的名字是在实现函数的时候使用。
    参数标签默认是参数的名字。

    func someFunction(label1 firstParameterName: Int, label2 secondParameterName: Int) {
    // In the function body, firstParameterName and secondParameterName
    // refer to the argument values for the first and second parameters.
    }

    someFunction(label1: 1, label2: 2)

    默认标签：

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

    someFunction(1, secondParameterName: 2)

注：在Swift 3之前，当使用默认标签的时候，调用函数的时候，第一个参数不能带标签，如下：
someFunction(firstParameterName:1, secondParameterName: 2)
将会出错。但是，在Swift 3中将不会有这样的错误。
b. 删除参数标签
如果你不想使用参数标签，用下划线“_”代替标签：

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

    someFunction(1, 2)

5. 默认参数值

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

6. 可变参数
可变参数的函数可以接受0个或者多个指定类型的值。你可以使用可变参数来说明函数调用的时候可以传入若干个值。
在参数类型后面加三个点“...”来表示可变参数。
传递给可变参数的值在函数体重会转换为合适的数组。比如一个Double...类型的可变参数numbers， 在函数体中将为变为[Double]类型。

    func sum(numbers: Double...) -> Double{
        var s: Double = 0;

        for value in numbers {
            s += value
        }

        return s
    }

    let s = sum(1,2,4,4.5)
    print("the sum of 1,2,4,4.5 is: \(s)")

    let s1 = sum(1,2,4,4.5,10.4, 12.2)
    print("the sum of 1,2,4,4.5,10.4, 12.2 is: \(s1)")

输出结果
the sum of 1,2,4,4.5 is: 11.5
the sum of 1,2,4,4.5,10.4, 12.2 is: 34.1
Program ended with exit code: 0

7. In-Out 参数
函数参数默认是常量，所以在函数体中修改函数参数的值将会导致运行时错误。
但是如果你想修改函数参数的值而且当函数调用结束后修改后的值还能维持不变，那就使用in-out 参数。
调用函数时，你只能传递变量作为参数，而不能传递传递常量和字面量作为参数，而且需要在变量前面加“&”符号。
注：in-out参数不能有默认值，而且可变参数不能是inout类型参数。

    func swapTwoValue(inout a: Int, inout _ b: Int){
        let temp = a
        a = b
        b = temp
    }

    var a = 3;
    var b = 4;
    swapTwoValue(&a, &b)

    print("a = \(a); b = \(b)")

结果为：
a = 4; b = 3
Program ended with exit code: 0

在Swift 3 中，inout关键字的位置是位于冒号之后，参数类型之前，如下：

    func swapTwoValue(_ a: inout Int, _ b: inout Int){
        let temp = a
        a = b
        b = temp
    }

这样可以理解为参数是一个inout Int类型的参数。

8. 函数类型
每一个函数都有一个指定的函数类型，有参数类型和返回值类型构成。

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

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

这两个函数的函数类型都是(Int, Int) -> Int

    func sayHello()->String{
        return "Hello, world!"
    }

这个函数的类型是 () -> String。

9. 使用函数类型
在Swift中，函数类型和其他类型的地位是一样的，可以将函数类型用作参数类型或者是返回值类型。
a. 变量或者常量

    var mathFunction = addTwoInts
    print("result: \(mathFunction(2,3))")

    mathFunction = multiplyTwoInts
    print("result: \(mathFunction(2,3))")

b. 函数类型作为参数类型

    func printMathResult(mathFunction: (Int, Int)->Int, _ a: Int, _ b: Int){
        print("result: \(mathFunction(a,b))")
    }

    printMathResult(multiplyTwoInts, 3, 4)

c. 函数类型作为返回值类型

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

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

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

10. 内置函数（Nested-Functions）
    在其他函数体中定义的函数，称之为内置函数。
    内置函数默认对外界是隐藏的，也就是说外界无法调用这个内置函数，内置函数只能在方法体中调用。

    func chooseStepFunction(isBackward: Bool) -> (Int) -> Int {

        func forward(input: Int)->Int{
            return input+1
        }

        func backward(input: Int)->Int{
            return input-1;
        }

        return isBackward ? backward : forward
    }