函数

1、默认参数值

• 参数可以有默认值

func check(name: String = "nobody", age: Int, job: String = "none") {
    print("name=\(name), age=\(age), job=\(job)")
}

check(name: "Jack", age: 28, job: "doctor")//name=Jack, age=28, job=doctor
check(name: "Tom", age: 18)//name=Tom, age=18, job=none
check(age: 10, job: "student")//name=nobody, age=10, job=student
check(age: 8)//name=nobody, age=8, job=none

• C++的默认参数值有个限制:必须从右往左设置。由于Swift拥有参数标签，因此并没有此类限制

• 但是在省略参数标签时，需要特别注意，避免出错

 // 注意：这里的middle不可以省略参数标签
func test(_ first: Int = 10, middle: Int, _ last: Int = 30) { } 
test(middle: 20)

2、可变参数

func sum(_ numbers: Int...) -> Int { 
    var total = 0
    for number in numbers {
        total += number
}
    return total
}
sum(10, 20, 30, 40) // 100

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

 // 参数string不能省略标签
func test(_ numbers: Int..., string: String, _ other: String) { }
test(10, 20, 30, string: "Jack", "Rose")

3、输入输出参数

• 可以用inout定义一个输入输出参数:可以在函数内部修改外部实参的值
  • 可变参数不能标记为inout
  • inout参数不能有默认值
  • inout参数只能传入可以被多次赋值的
  • 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)
}

4、函数重载

• 规则
  • 函数名相同
  • 参数个数不同 || 参数类型不同 || 参数标签不同

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

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

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

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

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

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

sum(v1: 10, v2: 20) // 30
sum(v1: 10, v2: 20, v3: 30) // 60
sum(v1: 10, v2: 20.0) // 30.0
sum(v1: 10.0, v2: 20) // 30.0
sum(10, 20) // 30
sum(a: 10, b: 20) // 30

• 函数重载注意点

  • 返回值类型与函数重载无关

    
    返回值类型不同但仍旧报错.png

  • 默认参数值和函数重载一起使用产生二义性时，编译器并不会报错

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

func sum(v1: Int, v2: Int, v3: Int = 10) -> Int {
    v1 + v2 + v3
}
//会调用sum(v1: Int, v2: Int)
sum(v1: 10, v2: 20) // 30

• 可变参数、省略参数标签、函数重载一起使用产生二义性时，编译器有可能会报错

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

func sum(_ numbers: Int...) -> Int {
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}
// error: ambiguous use of 'sum'
sum(10, 20)

5、函数类型

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

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

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

// 定义变量
var fn: (Int, Int) -> Int = sum
fn(2, 3) // 5，调用时不需要参数标签

• 函数类型作为函数参数

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) // Result: 7
printResult(difference, 5, 2) // Result: 3

• 函数类型作为函数返回值

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) // 4
forward(false)(3) // 2

返回值是函数类型的函数，叫做高阶函数。

6、嵌套函数

• 将函数定义在函数内部

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) // 4
forward(false)(3) // 2

7、别名（typealias）

• typealias用来给类型起别名

  • 按照Swift标准库的定义，Void就是空元组()

    
    Swift源码Void.png

typealias Byte = Int8
typealias Short = Int16
typealias Long = Int64

typealias Date = (year: Int, month: Int, day: Int)
func test(_ date: Date) {
    print(date.0)
    print(date.year)
}
test((2011, 9, 10))

typealias IntFn = (Int, Int) -> Int

func difference(v1: Int, v2: Int) -> Int {
    v1 - v2
}
let fn: IntFn = difference
fn(20, 10) // 10

func setFn(_ fn: IntFn) { }
setFn(difference)

func getFn() -> IntFn { difference }