Swift 函数

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

func clickOK(name:String) -> Int {        
    print("bbb")
    // 调用函数changeName
    changeName(num: 3, age: 12)
    return 2;
}
// 返回 void
func changeName(num:Int, age:Int) {
    let abrag = num + age        
}

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

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

可添加参数标签方便阅读

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



func greet(person: String, from hometown: String) -> String {
    return "Hello \(person)!  Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// 打印“Hello Bill!  Glad you could visit from Cupertino.”

隐式返回
如果整个函数体是一个单一表达式，那么函数会返回这个表达式。
任何一个可以被写成一行 return 语句的函数，都可以忽略 return。

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

返回元组：实现多返回值

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

// 返回 可选类型的元组（可以为空）
// 加上 ？ 即可
func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }   // 返回空

    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        ...
    }
    return (currentMin, currentMax)
}

传参默认值

func check(name: String = "Tom", age: Int = 12, job: String ) {
    // do something
}
// 2种调用方式
check(job: "player")
check(name: "Alex", age: 30, job: "IT")

可变参数（可以传0个或多个值）

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

通过在变量类型名后面加入...的方式，来定义可变参数。

 func sum(_ numbers: Int...) -> Int {
    var total = 0
// 此时参数numbers是一个数组，元素类型是Int
    for num in numbers {
        total += number
    }
    return total
}
sum(10, 20, 30, 40)

输入输出参数
在函数内部，可修改传参的值，本质是指针传递

用关键字inout标记，调用时传的是参数的地址，不能有默认值
可变参数不能标记为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)

函数重载(Function Overload)

函数名相同。参数个数不同 || 参数类型不同 || 参数标签不同
返回值类型与函数重载无关

内联函数(Inline Function)

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

函数类型
由函数的形参类型、返回值类型组成
可将一个变量定义为函数类型

用途：函数类型变量可作为函数的参数、函数的返回值

// 无参无返回值的 函数类型为： () -> Void 或者 () -> ()
func test() { }  

// 有参有返回值的 函数类型为： (Int, Int) -> Int
func sum(a: Int, b: Int) -> Int { 
 a+b
} 


// 定义一个函数变量aafunc，变量值为 某个同类型的 函数
var aafunc: (Int, Int) -> Int = sum 

// 调用时 不需要参数标签
aafun(2, 3) // 5，

函数类型变量，可作为另一个函数的参数类型：

它不关心传入函数是如何实现的，只关心传入的函数是不是一个正确的类型。

// 接着上面的例子
func printMathResult(_ aafunc: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(aafunc(a, b))")
}

// 调用时，传入一个函数
printMathResult(sum, 3, 5)

函数类型作为返回类型:

// 传入一个bool，返回一个函数
func chooseStepFunc(backward: Bool) -> (Int, Int) -> Int {
    return backward ? xxxfunc : sum
}

嵌套函数
在一个函数的代码块内，可以定义一个函数；
把函数，定义在另一个函数的代码块内。

默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。