Swift5.0笔记 - 3. 函数

1. 格式

1). 无返回值格式

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

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

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

2). 有返回值格式

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

• sum(v1: Int, v2: Int): 参数；
• -> Int 返回值
• 调用时sum(v1:10, v2:20),v1,v2参数名不能省略；
• 行参默认是let,也只能是let;

3). 隐式返回

• 如果整个函数体是一个单一表达式，那么函数会隐式返回这个表达式,即不用写"return"

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

4). 返回元组：实现返回值

• 事例:返回两个数的和、差、平均值

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

---

2. 函数的文档注释

• 格式如下
• 更详细参考：https://swift.org/documentation/api-design-guidelines/

/// 求和【概述】
///
/// 将两个数相加【更详细的描述】
///
/// - Parameter v1: 第1个整数
/// - Parameter v2: 第2个整数
/// - Returns: 2个整数之和
///
/// - Note:传入2个整数即可【批注】
///

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

---

3. 参数标签

• 可以修改参数标签；

// "at" 用来保证外面调用读起来比较通顺 ： 称为 “标签”
// "time" 用来保证你能理解传进来的参数的意思 ： 称为“形参”
//
func goToWork(at time: String) {
    print("this time is \(time)")
}
goToWork(at: "08:00")
// this time is 08:00

• 可以使用下划线“_” 省略参数标签:不推荐

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

---

4. 默认参数值

• 参数可以有默认值

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

---

5. 可变参数

• 一个函数，最多只能有一个不变参数

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

• 紧跟在可变参数后面的参数不能省略参数标签
• 如下：string01 前面不能加“_”,否则：test04(10, 20, 30,"Jack","Rose")，判别不了"Jack"是不是归属于numbers中的；

func test04(_ numbers: Int..., string01: String, _ other: String) {}
test04(10, 20, 30, string01: "Jack","Rose")

---

6. 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")

---

7. 输入输出参数

• 可以用inout定义一个输入输出参数：可以在函数内部修改外部实参的值需求：有一个变量，和函数，需求：执行完add05函数，number05数值加1:
  

  Error01

• 解析：num，行参是一个常量，不可修改；而且函数调用也只是一个值传递，与外面的number05没有关系解决:

  • 1. 加入关键字inout;
  • 2. 调用时使用&;

var number05 = 10
func add05(_ num: inout Int) {
    num += 1
}
add05(&number05)

• 解析：num行参是一个常量，不可修改；而且函数调用也只是一个值传递，与外面的number05没有关系
• 解决: 1. 加入关键字inout; 2. 输入输出参数必须加"&和普通参数区分开来

注意点：

• 可变参数不能标记为inout;
• inout 参数不能有默认值；
• inout 参数的本质是地址传递(引用传递)（可通过汇编验证）;
• inout 参数只能传入可以被多次赋值的变量；

var number05 = 10
func add05(_ num: inout Int) {
    num += 1
}
add05(&number05)
add05(&40) // 这种是错误的❌

---

8. 函数重载（Function Overload）

规则：

• 函数名相同；
• 参数个数不同or参数类型不同or参数标签不同；

// 以下函数在同一个作用域内都是可以调用成功的；相当于可区分成不同的函数；
func sumFun(v1: Int, v2: Int) -> Int {
    v1 + v2
}

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

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

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

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

注意点：

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

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

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

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

---

9. 内联函数（Inline Function）

1) 如果开启了编译器优化（Release模式默认会开启优化），编译器会自动将某些函数变成内联函数;

• 内联函数就是将函数调用展开成函数体;

  
  image

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

• 函数体比较长；
• 包含递归函数；
• 包含动态派发；（如：OC的动态绑定）：内联的前提是编译时已经确定调用哪个函数

3) @inline

• 永远不会被内联（即使开启了编译器优化）

@inline(never) func test() {
    print("test")
}

• 开启编译器优化后，即使代码很长，也会被内联（递归调用函数、动态派发的函数除外）

@inline(__always) func test() {
     print("test")
}

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

---

10. 函数类型（Function Type）

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

func test03(){} // 函数类型 ()->Void 或者 （）->（）

• 定义变量

func sum04(a: Int, b: Int) -> Int {
    a + b
} //函数类型：（Int， Int）-> Int

var fn: (Int, Int) -> Int = sum04

fn(10, 20) // 50,调用时不需要参数标签

1）函数类型作为参数

//函数类型作为参数
func sum05(v1: Int, v2: Int) ->Int {
    v1 + v2
}

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

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

printfResult(sum05, 5, 2) //7
printfResult(difference02, 5, 2)//3

2）函数类型作为返回值

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

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

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

func forword(_ forword: Bool) -> (Int) -> Int { // (Int) -> Int 函数类型
    forword ? next : previous
}
forword(true)(3) //4
forword(false)(3) //2

---

11. typealias

• typealias用来给类型起别名

1. Swift中是没有Byte、Short、Long这三个类型的

typealias Byte = Int8 //1个字节
typealias Short = Int16 //2个字节
typealias Long = Int64 // 8个字节

2. 给元组起别名

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

3. 给函数类型起别名

typealias IntFun = (Int, Int) -> Int

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

let fnTest: IntFun = difference03
fnTest(20, 10) // 10

func setFn(_ fn: IntFun) { }
setFn(difference03)
func getFun() -> IntFun { difference03 }

---

12. 嵌套函数（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