Swift基础语法 - 函数

函数的定义

func 函数名(形参列表) -> 返回值类型 {
   // 函数体...
}

形参列表的格式：
形参名1: 形参类型1, 形参名2: 形参类型2, …

func num() -> Double {
    return 3.1415926
}

num()

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

sum(v1: 20, v2: 30)

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

如果函数没有返回值，有3种写法
一个函数如果没有形参，函数名后面的小括号也不能省略

func 函数名(形参列表) -> Void {
    // 函数体...
}

func 函数名(形参列表) -> () {
    // 函数体...
}

func 函数名(形参列表) {
    // 函数体...
}

//无返回值写法
func sayGo() -> Void {
    print("Go")
}
sayGo()

func saySiri() -> (){
    print("Siri")
}
saySiri()

func sayBye() {
    print("Bye")
}
sayBye()

隐式返回

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

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

返回元组：实现多返回值

//返回这组数的和、差、平均值
func calculate (v1: Int, v2: Int) -> (sum : Int, dif: Int, ave: Int){
    let sum = v1 + v2
    return (sum, v1 - v2, sum >> 1)
}

let result = calculate(v1: 30, v2: 20)
result.sum // 50
result.dif // 10
result.ave // 25

函数的文档注释

• 快捷键 option + command + /

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

• 参考 官方文档

参数标签（Argument Label）

• 可以修改参数标签

func 函数名(外部参数名 局部参数名:形参类型)

func goToWork(at time: String) {
    print("this time is \(time)")
}
goToWork(at: "10:00")
//this time is 10:00

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

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

默认参数值（Default Parameter Value）

func 函数名(形参名称:形参类型 = 默认值)

• 参数可以有默认值

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

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

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

可变参数（Variadic Parameter）

• 一个可变参数可以接受一个或多个值
• 函数调用时，可以用可变参数来传入不确定数量的输入参数
• 通过在变量类型名后面加入 … 的方式来定义可变参数
• 传入可变参数的值在函数体内当做这个类型的一个数组。例如，一个叫做 numbers 的 Int… 型可变参数，在函数体内可以当做一个叫 numbers 的 Int[] 型的数组常量

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 test1(_ numbers: Int..., string: String, _ other: String){
    
}

test1(10, 20, 30, string: "Jack", "Rose")

Swift 自带的print函数

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 定义一个输入输出参数：可以再函数内部修改外部实参的值

var number = 20
func test (_ num: inout Int){
    num = 30
}
test(&number)
print(number) // 30

//交换两个值
func swapValues(_ v1: inout Int, _ v2: inout Int){
    let tmp = v1
    v1 = v2
    v2 = tmp
}
var num1 = 20
var num2 = 30
swapValues(&num1, &num2)
print(num1, num2)

//可以用元组实现交换两个值
func swapValues(_ v1: inout Int, _ v2: inout Int){
    (v1, v2) = (v2, v1)
}
var num1 = 20
var num2 = 30
swapValues(&num1, &num2)
print(num1, num2)

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

函数重载（Function Overload）

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

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(x v1: Int, y 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(x: 10, y: 20) // 30
sum(a: 10, b: 20) // 30

函数重载注意点

• 返回值类型与函数重载无关
  
• 默认参数值和函数重载一起使用产生二义性时，编译器并不会报错（在 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)

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

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）

• 如果开启了编译器优化（Release 模式默认会开启优化），编译器会自动将某些函数变成内联函数
• • 将函数调用展开成函数体
    
• 哪些函数不会被自动内联？
• • 函数体比较长
• • 包含递归调用
• • 包含动态派发等

@inline

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

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

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

函数类型（Function Type）

• 函数类型是一种数据类型
• 每一个函数都是有类型的，函数类型由形式参数类型、返回值类型组成
• 分三步：1、定义函数；2、声明函数类型变量或常量；3、给函数类型变量赋值（2、3步骤可以合并）

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
}

var fn: (Int) -> Int = forward(true)
fn(3)

forward(false)(3)

• 返回值是函数类型的函数，叫做高阶函数（Higher-Order Function）

typealias

• typealias 用来给类型起别名

typealias Byet = Int8
typealias Short = Int16
typealias Long = Int64

var num1: Byet = 0
var num2: Short = 0
var num3: Long = 0

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

typealias IntFn = (Int, Int) -> Int

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

let fn: IntFn = difference
fn(30, 10) // 20

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

func getFn() -> IntFn {
    difference
}

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

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