第六章：函数

1.1 定义和调用

函数名前面一定要有关键字func；函数名要符号驼峰命名法；函数的参数要写在函数名后面的()里面，如果没有参数，也需要写()；函数的返回值前面需要加上->；如果没有返回值则不需要写->。

1.2 函数形参

// 有参有返
func function1(parameterName1: parameterType, parameterName2: parameterType) -> returnType {
    statements
}

// 无参有返
func function2() -> returnType {
    statements
}

// 无参无返
func function3() {
    statements
}

如果函数的返回值为多个，那么就需要用元祖作为返回值类型。

// 元祖作为返回值类型
func function4() -> (returnName1: returnType, returnName2: returnType)) {
    statements
}

为了增加函数的可读性，有时需要使用外部形参：

// 没有外部形参
func mulAdd(no1: Int, no2: Int) -> Int {
    return no1 + no2;
}
let result = mulAdd(no1: 3, no2: 5)

// mul为外部形参，no1 和 no2 为本地形参
func mulAdd(mul no1: Int, mul no2: Int) -> Int {
    return no1 + no2;
}
let result = mulAdd(mul: 3, mul: 5)

// 有时外部形参可以使用“_”
func mulAdd(_ no1: Int, _ no2: Int) -> Int {
    return no1 + no2;
}
let result = mulAdd(3, 5)

Swift还支持一种可变的形参方式，即在函数定义的时候不知道形参的类型和数目，只有在具体调用的时候才能确定形参的数目。在定义的时候需要定义参数名和参数类型，不同之处在于参数类型后面要加上"..."来表示该形参为可变形参。可变形参在函数体内是以数组的形式存在的。

func sum(nums: Int...) -> Int {
    var result = 0
    for i in nums {
        result += i
    }
    
    return result
}

let result = sum(nums: 1, 2, 3)

调用函数的时候，如果要修改参数的值，会报错误Cannot assign to value: 'xx' is a 'let' constant，此时需要在参数类型前面加上关键字inout，表示传入的是变量的地址。

func swape(a: inout Int, b: inout Int) {
    let tmp = a
    a = b
    b = tmp
}

var a = 5
var b = 7
swap(&a, &b)
print(a, b)

1.3 函数类型

函数类型由形参类型和返回值类型组成。函数类型可以像其他数据类型一样使用。

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

func hello() {
    print("hello")
}

var mathOperation: (Int, Int) -> Int = add
var sayOperation: () -> () = hello

mathOperation(4, 5)
sayOperation()

var operation = add
operation(5, 6)

函数类型还可以作为一个函数的参数或者返回值来使用，极大的增加的函数定义的灵活性。

func sub(a: Int, b: Int) -> Int {
    return a - b
}

// 函数做为参数
func autoSub(operation: (Int, Int) -> Int, a: Int, b: Int) -> Int {
    if a >= b {
        return operation(a, b)
    } else {
        return operation(b, a)
    }
}

autoSub(operation: sub, a: 10, b: 3)

// 函数做为返回值
func mathOperation() -> (Int, Int) -> Int {
    return sub
}

let result = mathOperation()
result(9, 8)

1.4 嵌套函数

在函数体内可以定义新的函数，成为嵌套函数。

func getOperation(name: String) -> (Int, Int) -> Int {
    func add(a: Int, b: Int) -> Int {
        return a + b
    }
    
    func sub(a: Int, b: Int) -> Int {
        return a - b
    }
    
    if name == "add" {
        return add
    } else {
        return sub
    }
}

let result = getOperation(name: "add")
// result = 10
result(4, 6)