文章结构.png

一、函数

1、定义

1、声明：func 函数名（形参名：形参类型，形参名：形参类型）-> 返回值类型

// func 函数名（形参名：形参类型，形参名：形参类型）-> 返回值类型
func sum(num1: Int, num2: Int) -> Int {
    return num1 + num2
}

2、调用：函数名（形参名：实参，形参名：实参）

// 函数名（形参名：实参，形参名：实参）
sum(num1: 10, num2: 20)

2、知识点

2、无返回值的三种写法：

// 1、直接不写返回值
func sum(num1: Int, num2: Int) {
    
}

// 2、Void
func sum(num1: Int, num2: Int) -> Void {
    
}

// 3、返回空元组
func sum(num1: Int, num2: Int) -> () {
    
}

3、隐式返回
条件：如果整个函数体都是一个单一表达式，那么函数会隐式返回这个表达式

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

4、返回元组（作用：实现多返回值）
对比C语言：C语言返回值都只有一个

// 计算后返回：和、差、平均
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

5、函数文档注释
Swift代码规范：https://swift.org/documentation/api-design-guidelines/

/// 求和【概述】
///
/// 将2个整数相加【更详细的描述】
///
/// - Parameter v1: 第1个整数
/// - Parameter v2: 第2个整数
/// - Returns: 2个整数的和
///
/// - Note:传入2个整数即可【批注】
///
func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}

函数注释样式.png

6、参数标签（Argument Label）

• 修改参数标签

func goToWork(at time: String) {
print("this time is \(time)")
}
goToWork(at: "08:00") // 如果没有写at这个参数标签时，调用：goToWork(time: "08:00")
// this time is 08:00

• 可以使用 _ 省略参数标签

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

二、默认参数值(Default Parameter Value)

1、参数可以有默认值

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

2、C++的默认参数值有个限制：必须从右往左设置。由于Swift拥有参数标签，因此并没有此类限制
3、但是在省略参数标签时，需要特别注意，避免出错

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

 }
test(middle: 20)

三、可变参数(Variadic Parameter)

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

注意：

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

// 参数string不能省略标签
func test(_ numbers: Int..., string: String, _ other: String) { 

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

例子：Swift自带的print函数

/// - Parameters:
/// 
- items: Zero or more items to print.
/// 
- separator: A string to print between each item. The default is a single space (`" "`).
/// 
- terminator: The string to print after all items have been printed. The
/// 
default is a newline (`"\n"`).
public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")

print(1, 2, 3, 4, 5) // 1 2 3 4 5
print(1, 2, 3, 4, 5, separator: "_") // 1_2_3_4_5
print("My name is Jake.", terminator: "")
print("My age is 18.")
// My name is Jake.My age is 18.

四、输入输出参数（In-Out Parameter）

描述：可以用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参数只能传入可以被多次赋值的(不能是let类型)
• inout参数的本质是地址传递（引用传递）

五、函数重载（Function Overload）

1、规则：

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

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(1020) // 30

2、注意

1、返回值类型与函数重载无关
2、默认参数值和函数重载一起使用产生二义性时，编译器并不会报错（在C++中会报错）

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)

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

func sum(v1: Int, v2: Int) -> Int {
    v1 + v2
}
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)

六、内联函数（Inline Function）

1、内联函数

如果开启了编译器优化（Release模式默认会开启优化），编译器会自动将某些函数变成内联函数：将函数调用展开成函数体

Swift编译优化设置.png

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

• 函数体比较长
• 包含递归调用
• 包含动态派发
• ......

2、@linline

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

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

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

七、函数类型（Function Type）

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

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，调用时不需要参数标

1.1、函数类型作为函数参数

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

1.2、函数类型作为函数返回值
返回值是函数类型的函数，叫做高阶函数（Higher-Order Function)

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

八、嵌套函数（Nested Function）

将函数定义在函数内部（不想暴露内部函数）

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