Swift函数

概览
函数定义
隐式返回
返回元组(实现多值返回)
函数参数
参数标签
默认参数值
可变参数
输入输出参数
函数重载
内联函数
函数类型
嵌套函数

函数定义

函数是用来完成特定任务的独立的代码块。你给一个函数起一个合适的名字，用来标识函数做什么，并且当函数需要执行的时候，这个名字会被“调用”。

func pi() -> Double {
    return 3.14
}

func sum(v1: Int, v2: Int) -> Int {
    return v1 + v2
}
sum(v1: 10, v2: 20)

• 形参默认是let，也只能是let

func sayHello() -> Void {
    print("Hello")
}

func sayHello() -> () {
    print("Hello")
}

func sayHello() {
    print("Hello")
}

• 无返回值

隐式返回

如果整个函数体是一个单一的表达式，那么函数会隐式返回这个表达式

func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}
sum(v1: 10, v2: 20) // 30

返回元组(实现多值返回)

func calculate(v1: Int, v2: Int) -> (sum: Int, difference: Int, average: Int) {
    let sum = v1 + v2
    return (sum, v1 - v2, sum >> 1)
}

let result = calculate(v1: 20, v2: 10)
result.sum //30
result.difference // 10
result.average // 15

参数标签

函数参数标签和参数名称

每个函数参数都有一个参数标签（argument label）以及一个参数名称（parameter name）。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。

• 可以修改参数标签

func gotoWork(at time: String) {
    print("this time is \(time)")
}
gotoWork(at: "8:00")

• 可以使用下划线省略参数标签

func sum(_ v1: Int,_ v2: Int) -> Int {
    v1 + v2
}
sum(20, 20)

默认参数值

func check(name: String = "nobody", age: Int, job: String = "none") {
    print("name=\(name), age=\(age), job=\(job)")
}
check(name: "Jack", age: 20, job: "Doctor")
check(name: "Rose", age: 18)
check(age: 10, job: "Batman")
check(age: 15)

可变参数

func sum(_ numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}

sum(10,20,30) // 60

• 一个函数最多只有一个可变参数
• 紧跟在可变参数后面的参数不能省略参数标签

func test(_ numbers: Int..., string: String, _ other: String) {

}
test(10,20,30, string: "Jack", "Rose")

输入输出参数

• 可以用inout定义一个输入输出参数：可以在函数内部修改外部实参的值

func swapValues(_ v1: inout Int, _ v2: inout Int) {
    let tmp = v1
    v1 = v2
    v2 = tmp
}

var num1 = 10
var num2 = 20
swapValues(&num1, &num2)

func swapValues(_ v1: inout Int, _ v2: inout Int) {
    (v1, v2) = (v2, v1)
}

• 可变参数不能标记inout
• inout参数不能有默认值
• inout参数只能传入可以被多次赋值的
• inout参数本质是地址传递（引用传递）

参数重载

规则

1. 函数名相同
2. 参数个数不同 || 参数类型不同 || 参数标签不同

func sum(v1: Int, v2: Int, v3: Int) -> Int {
    v1 + v2 + v3
}//参数个数不同

func sum(v1: Int, v2: Double) -> Double {
    Double(v1) + v2
}//参数类型不同

func sum(a: Int, b: Int) -> Int {
    a + b
}//参数标签不同

func sum(_ v1: Int, _ v2: Int) -> Int {
    v1 + v2
}//参数标签不同

注意事项

1. 返回值类型与重载无关
2. 默认参数值和函数重载一起使用产生二义性，编译器不会报错
3. 可变参数、省略参数、函数重载一起使用产生二义性时，编译器可能报错
   image.png

内联函数

• 如果开启编译器优化（release模式会自动开启）,编译器会自动将某些函数变成内联函数
  将函数调用展开成函数体
  

  image.png

• 哪些函数不会被自动内联？

1. 函数比较长
2. 包含递归调用
3. 包含动态派发

@inline

// 永远不会被内联（即使开启了编译器优化）
@inline(never) func test() {
    print("test")
}

// 开启编译器优化后，即使代码很长，也会被内联（递归调用，动态派发的函数除外）
@inline(__always) func test() {
    print("test")
}

• 在release模式下，编译器已经开启优化，会自动决定哪些函数需要内联，因此没必要使用@inline

函数类型

• 每个函数都是有类型的，函数类型有形式参数类型，返回值类型组成

func test() {} //() -> Void 或 () -> ()

func sum(a: Int, b: Int) -> Int {
    a + b
} // (Int, Int) -> Int

var fn: (Int, Int) -> Int
fn(2, 3)

函数类型作为函数参数

func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}

func difference(v1: Int, v2: Int) -> Int {
    v1 - v2
}

func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFn(a, b))")
}

printResult(sum, 5, 2)

函数类型作为函数返回值

func next(_ input: Int) -> Int {
    input + 1
}

func previous(_ input: Int) -> Int {
    input - 1
}

func forward(_ forward: Bool) -> (Int) -> Int {
    forward ? next : previous
}

forward(true)(3)
forward(false)(3)

嵌套函数

将函数定义在函数内部

func forward(_ forward: Bool) -> (Int) -> Int {
    func next(_ input: Int) -> Int {
        input + 1
    }

    func previous(_ input: Int) -> Int {
        input - 1
    }
    return forward ? next : previous
}

forward(true)(3)
forward(false)(3)