05-Swift函数

1.函数的定义

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

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

/// 无返回值 等价
func sayHello1() -> Void {}
func sayHello2() -> () {}
func sayHello3() {}

1.2隐式返回

• 如果函数体是个单一表达式，则可以省略return

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

1.3返回元组，实现多返回值

func calculate(v1: Int, v2: Int) -> (sum: Int, difference: Int, average: Int) {
    let sum = v1 + v2  // 大于两句 添加return
    return (sum, v1-v2, sum>>1)
}

let result = calculate(v1: 20, v2: 10)
result.sum
result.difference
result.average

2.文档注释

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

3.参数标签

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

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

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

4.默认参数值

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

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

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

5.可变参数Int...

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

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

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

6.Swift自带的print函数可变参数

// 可变参数  拼接符 “”  并换行
public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")
print(1, 2, 3, 4, 5, separator: "_") // 1_2_3_4_5 
print("My name is Jake.", terminator: "") // 不再换行

7.输入输出参数

• 用inout定义一个输入输出参数:可以在函数内部修改外部实参的值
  • 不可变参数不能标记为inout
  • inout参数不能有默认值
  • inout参数只能传入可以被多次赋值的 (let、字面量不能使用)
  • inout参数的本质是地址传递(引用传递)

//可以用inout定义一个输入输出参数：可以在函数内部修改外部实参的值
func swapValues(_ v1: inout Int, _ v2: inout Int) {
//    let tmp = v1
//    v1 = v2
//    v2 = tmp
    (v1, v2) = (v2, v1)
}
var num1 = 10
var num2 = 20
swapValues(&num1, &num2)

8.函数重载

• 规则：
  • 函数名相同
  • 参数个数不同 || 参数类型不同 || 参数标签不同
• 注意点
  • 返回值类型与函数重载无关
  • 默认参数值和函数重载一起使用产生二义性时，编译器并不会报错(在C++中会报错)
  • 可变参数、省略参数标签、函数重载一起使用产生二义性时，编译器有可能会报错

func testSum(v1: Int, v2: Int) -> Int {
    v1 + v2
}
func testSum(v1: Int, v2: Int, v3: Int) -> Int {
    v1 + v2 + v3
}/// 参数个数不同
func testSum(v1: Int, v2: Double) -> Double {
    Double(v1) + v2
}/// 参数类型不同
func testSum(_ v1: Int, _ v2: Int) -> Int {
    v1 + v2 + 1
}/// 参数标签不同

print(testSum(v1: 10, v2: 20))
print(testSum(v1: 10, v2: 20, v3: 30))
print(testSum(v1: 10, v2: 20.0))
print(testSum(10, 20))

/// 1、返回值类型与函数重载无关
func testSum1(v1: Int, v2: Int) -> Int { v1 + v2 }
func testSum1(v1: Int, v2: Int) {}
//testSum1(v1: 10, v2: 20)

/// 2、默认参数值和函数重载一起使用产生二义性时，编译器不会报错、 C++中会报错
func testSum2(v1: Int, v2: Int) -> Int { v1 + v2 }
func testSum2(v1: Int, v2: Int, v3: Int = 10) -> Int { v1 + v2 + v3 }
/// 会调用上面的
testSum2(v1: 10, v2: 20)

/// 3、可变参数、省略参数标签，函数重载一起使用产生二义性时，编译器有可能会报错
func testSum3(_ v1: Int, _ v2: Int) -> Int {
    print("+")
    return v1 + v2
}
func testSum3(_ numbers: Int...) -> Int {
    print("numbers")
    var total = 0
    for number in numbers {
        total += number
    }
    return total
}

9.内联函数

• 如果开启了编译器优化(Release模式默认会开启优化)，编译器会自动将某些函数变成内联函数 - 在Release模式下，编译器已经开启优化，会自动决定哪些函数需要内联，因此没必要使@inline

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

• 哪些函数不会被自动内联?

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

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

10.函数类型

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

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

11.函数类型作为函数参数

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

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

typealias

• typealias用来给类型起别名
• 按照Swift标准库的定义，Void就是空元组() public typealias Void = ()

// 日期
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)

func setFn(_ fn: IntFn) { } setFn(difference)
func getFn() -> IntFn { difference }

12.嵌套函数

• 将函数定义在函数内部

func forward1(_ result: Bool) -> (Int) -> Int {
    func next(_ input: Int) -> Int {
        input + 1
    }
    func previous(_ input: Int) -> Int {
        input - 1
    }
    return result ? next : previous
}

forward1(true)(3)
forward1(false)(3)