Swift语法 -- [03 - 函数]

1. 定义和调用函数

• func的为函数关键字前缀, ->表示 函数返回的类型

func greet(person: String) -> String{
    let greeting = "hello" + person + "!"
    return greeting
}
greet(person: "Alex")

2. 隐式返回

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

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

3. 返回元组:实现多返回值

func calculate(v1 : Int, v2: Int) -> (sum: Int, subtract: Int, average: Int){
    let sum = v1 + v2;
    let subtract = v1 - v2;
    let average = sum / 2
    return (sum, subtract, average)
}
calculate(v1: 20, v2: 10)

4. 参数标签

• 可以修改参数标签,方便阅读

func gotowork(at time: String){
    print("this time is \(time)")
}
gotowork(at: "08:00")

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

func sum(_ v1: Int, _ v2: Int) -> Int {
    return v1 + v2;
}
let result =  sum(10, 20)

5. 默认参数值

• 参数可以有默认值

func check(name: String = "nobody", age: Int, job: String = "none") {
    print("name=\(name), age=\(age), job=\(job)")
}
// 2种调用方式
check(age: 10)
check(name: "alex", age: 30, job: "it")

6. 可变参数

• 一个参数可以传入多个值

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

7. 输入输出参数(In-Out Parameter)

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

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

func swapValues(v1: inout Int, v2: inout Int) {
    let tmp = v1
    v1 = v2
    v2 = tmp
}
var num1 = 10
var num2 = 20
swapValues(v1: &num1, v2: &num2)

8. 函数重载(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: Int, _ v2: Int) -> Int { 
    v1 + v2
} // 参数标签不同

9. 内联函数(Inline Function)

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

• 将函数调用展开成函数体

哪些函数不会被内联?

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

10. 函数类型(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，调用时不需要参数标签

• 函数类型作为函数参数

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

11. typealias

• typealias用来给类型起别名

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 }

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

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