Swift函数(Functions)

函数的参数

// 无参数函数
func sayHelloWorld() -> String {
    return "hello, world"
}

// 单参数函数
func sayHello(presonName: String) -> String {
    let greeting = "Hello," + presonName + "!"
    return greeting
}

private func sayHelloAgain(presonName: String) -> String {
    let greeting = "Hello again," + presonName + "!"
    return greeting
}

//多参数函数
func sayHello(personName: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return sayHelloAgain(personName)
    } else {
        return sayHello(personName)
    }
}

函数的参数名称

说明：函数参数都有一个外部参数名和一个局部参数名。外部参数名用于函数调用时标注传递给函数的参数，局部参数名在函数的实现内部使用。

一般情况下，第一个参数省略其外部参数名，第二个以及随后的参数使用其局部参数名称作为外部参数名。所有参数必须有独一无二的局部参数名。尽管多个参数可以有相同的外部参数名，但不同的外部参数名能让你的代码更有可读性。

   例：
    // 函数实现
    func someFunction(firstParamName: Int, secondParamName: Int) {
        // 这里是函数内部实现,打印传入的参数
        print("\(firstParamName) - \(secondParamName)")
    }

    // 函数调用
    someFunciton(1, secondParamName: 2)

1 指定外部参数名
    可以在局部参数名前面指定外部参数名，中间以空格分割：
    例：
        // 函数实现
        func someFunction(externalParamName localParamName: Int) {
            // 这里是函数内部实现,打印传入的参数
            print("\(localParamName)")
        }

        // 函数调用
        someFunction(externalParamName: 1)

2 忽略外部参数名
    如果不想为第二个及后续的参数设置外部参数名，用一个下划线(_)代替一个明确的参数名
    例：
        // 函数实现
        func someFunction(firstParamName: Int, _ secondParamName: Int) {
            print("\(firstParamName) - \(secondParamName)")
        }

        // 函数调用
        someFunction(1, 2)

3 默认参数值
    可以在函数体中为每个参数定义默认值。当默认值被定义后，调用这个函数值时可以忽略这个参数
    例：
        // 函数实现
        func someFunction(paramWithDefault: Int = 12) {
            print(paramWithDefault)
        }

        // 函数调用
        someFunction(6)     // 传入参数，打印结果为6
        someFunction(12)    // 忽略参数，则使用默认参数，打印结果12

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

4 可变参数
    可变参数用于接受零个或多个值(个数不确定)，通过在变量类型名后面加入(...)的方式定义

    例子：
        // 函数实现
        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)

5 常量参数和变量参数
    函数的参数默认是常量，在函数体内是不能修改的，这样防止用户意外的修改。
    但是，有时候必须需要修改，则可以指定参数为变量类型来进行修改

    例：
        // 函数实现
        func changeParam(var presonName: String) -> String {
            presonName = "chenwen"
            return presonName
        }

        // 函数调用
        changeParam("wangxg")

    注意：
        对变量参数所进行的修改在函数调用结束后便会消失，对于函数体外是不可见的，变量参数的声明周期随函数调用的结束而结束。

6 输入输出参数
    用途：
        如果想要一个函数可以修改参数的值，并且想要这些修改在函数调用结束后仍然存在，那么久应该把参数定义为输入输出参数

    例：
        // 函数实现
        func swapTowInts(inout a: Int, inout _ b: Int) {
            let temporaryA = a
            a = b
            b = temporaryA
        }

        // 函数调用
        var x = 5, y = 10
        function1.swapTowInts(&x, &y)
        print("x= \(x), y = \(y)")

    注意：
        1 只能传递变量给输入输出参数，不能传递常量和字面值(因为不能被修改)
        2 当传入的参数作为输入输出参数是，需要在参数名前面加&符号
        3 输入输出参数不能有默认值
        4 可变参数不能用inout标记，如果标记，这个参数不能被var或let标记
        5 输入输出参数和返回值是不一样的，输入输出参数是函数对外参数影响的另一种方式

函数的返回值

最常用的一种对外部参数影响的一种方式

// 无返回值
func sayGoodbye(personName: String) {
    print("Goodbye, \(personName)")
}

//多重返回值函数(通过元组返回)
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)
}

// 可选元组的返回类型
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)
}

函数类型

类似于c或Objective-C中的函数指针变量

1 基本使用

// 函数实现 (Swift实现)
func addTwoInts(a: Int, _ b: Int) -> Int {
    return a + b
}

// 定义并调用 (Swift调用)
var mathFunction: (Int, Int) ->Int = addTwoInts
mathFunction(2, 3)

2 函数类型作为参数类型
类似于c或Objective-C中把函数指针作为参数

// 函数实现
func addTowInts (a: Int, _ b: Int) -> Int {
    return a + b
} 

// 作为参数传递
func printMathResult(MathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(MathFunction(a, b))")
}

// 调用
printMathResult(addTowInts, 3, 7)

3 函数类型作为返回值

// 函数实现
func stepForward(input: Int) -> Int {
    return input + 1
}

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

// 作为返回值传递
func chooseStepFunction(backwards: Bool) -> (Int) -> Int {
    return backwards ? stepBackward : stepForward
}

// 调用
let currentValue = 3
let moveNearerToZero = chooseStepFunction(currentValue > 0)
print(moveNearerToZero(currentValue))