Swift之函数

函数定义

// 有返回值参数
func pi() -> Double{
    return 3.14;
}
func sum(v1: Int, v2: Int) -> Int{
    return v1 + v2
}
// 无返回值参数
func sayHello() -> Void{
    print("Hello")
}
func sayHello() -> (){
    print("Hello")
}
func sayHello(){
    print("Hello")
}

形参默认是let,也只能是let

隐式返回（Implicit Return）

如果整体函数是一个单一表达式，那么函数会隐试返回这个表达式，不用显示使用return

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

返回元组：实现多返回值

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: 10, v2: 20)
result.sum        // 30
result.difference // -10
result.average    // 15

函数的文档注释

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

参考：文档

参数标签（Argument Label）

可以修改参数标签

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

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

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

默认参数值（Default Parameter Value）

参数可以有默认值

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 sum(_ first: Int = 10 ,middle: Int, _ last: Int = 30){}
sum(middle:20)

可变参数（Variadic Parameter）

func sum(_ numbers: Int...) -> Int{
    var total
    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")

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,separator:" *** ",terminator: " 本次打印?")

第一个参数：输入的内容，第二个参数：间隔符号内容，第三个：处理完所有字符串之后的操作，后面两个选项可以进行自定义

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

可以用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) // num1 = 20 num2 = 10

注意

• 可变参数不能标记为inout
• inout参数不能有默认值
• inout参数只能传入可以被多次赋值的变量；不能传递具体的数值，例如：1 2 Tom
  *inout参数的本质是地址传递（引用传递）

函数重载（Function Overload）

规则：1.函数名相同；2.参数个数不同 || 参数类型不同 || 参数标签不同

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

返回值类型与函数重载无关

func sum(v1: Int , v2: Int) -> Int {
    v1 + v2
}
func sum(v1: Int , v2: Int){
    v1 + v2
}
// ❌ Ambiguous use of 'sum(v1:v2:)'
sum(v1: 10, v2: 20) 

默认参数值和函数重载一起使用产生二义性时,编译器并不会报错（在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)
print(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
}
// ❌ Ambiguous use of 'sum'
sum(10, 20)

内联函数（Inline Function）

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

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

@inline

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

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

函数类型（Function Type）

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

// () -> Void 或者 () ->()
func test(){}
// （Int,Int） -> Int
func sum(v1: Int, v2: Int) -> Int{
    v1 + v2
}
// 定义变量
var fn: (Int, Int) -> Int = sum
// 调用时不需要参数标签
fn(1,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,v1: Int, v2: Int){
    print("Result \(mathFn(v1,v2))")
}
printResult(sum, v1: 10, v2: 20)        // Result = 30
printResult(difference, v1: 20, v2: 10) // Result = 10

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

//示例2
func next(_ input: Int) -> Int{
    input + 1
}
func previou(_ input: Int) -> Int{
    input - 1
}
func forward(_ forward: Bool) -> (Int) -> Int{
    forward ? next : previou
}
forward(true)(2)   // 3
forward(false)(2)  // 1

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就是空元组()

public typealias 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

参考内容：
从入门到精通Swift编程