14-Swift函数

Swift 统一的函数语法非常的灵活，可以用来表示任何函数，包括从最简单的没有参数名字的 C 风格函数，到复杂的带局部和外部参数名的 Objective-C 风格函数。

在 Swift 中，每个函数都有一个由函数的参数值类型和返回值类型组成的类型。你可以把函数类型当做任何其他 普通变量类型一样处理，这样就可以更简单地把函数当做别的函数的参数，也可以从其他函数中返回函数。函数 的定义可以写在其他函数定义中，这样可以在嵌套函数范围内实现功能封装。

1.函数的定义和调用

格式：func 函数（参数列表）-> 返回值类型

func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}
print(greet(person: "Swift "))  //  Hello, Swift !

//  简化上面的代码
func greetAgain(person: String) -> String {
    return "Hello again, " + person + "!"
}
print(greetAgain(person: "Anna")) // 打印 "Hello again, Anna!"


func sum(x: Int ,y: Int) -> Int {
    return x + y
}
print(sum(x: 10, y: 20))  //  30

2.函数参数与返回值

1> 无参数函数

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld()) // 打印 "hello, world"

2> 多参数函数

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return greetAgain(person: person)
    } else {
        return greet(person: person)
    }
}
print(greet(person: "Tim", alreadyGreeted: true)) // 打印 "Hello again, Tim!"
print(greet(person: "Tim", alreadyGreeted: false)) // 打印 "Hello, Tim!"

3> 无返回值函数

func greet(person: String) {
    print("Hello, \(person)!")
}
greet(person: "Dave")
// 打印 "Hello, Dave!"

// 1.直接省略
func person(){
    print("ningcol")
}
// 2.包含括号
func person1() ->(){
    print("ningcol")
}
// 3.Void
func person2() ->Void{
    print("ningcol")
}

person()
person1()
person2()

#被调用时，一个函数的返回值可以被忽略:
func printAndCount(string: String) -> Int {
    print(string)
    return string.characters.count
}
func printWithoutCounting(string: String) {
    let _ = printAndCount(string: string)  //  忽略了printAndCount方法的返回值
}
printAndCount(string: "hello, world")  // 打印 "hello, world" 并且返回值 12 
printWithoutCounting(string: "hello, world") // 打印 "hello, world" 但是没有返回任何值

#######注意：返回值可以被忽略，但定义了有返回值的函数必须返回一个值，如果在函数定义底部没有返回任何值，将导致编译时错误(compile-time error)。

4> 多重返回函数

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}
let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) 
print("min is \(bounds.min) and max is \(bounds.max)") // 打印 "min is -6 and max is 109"

5>可选元组返回类型

如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的( optional ) 元组返回类型反映 整个元组可以是nil的事实。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?
#######注意 可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的.可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。

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] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

//  使用可选绑定检查函数返回的是一个存在的元组值还是nil
 if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
     print("min is \(bounds.min) and max is \(bounds.max)")
}
// 打印 "min is -6 and max is 109"

3.函数参数标签和参数名称

每个函数参数都有一个参数标签( argument label )以及一个参数名称( parameter name )。参数标签在调用函数的时候使用;调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。

func someFunction(firstParameterName: Int, secondParameterName: Int) {
// 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(firstParameterName: 1, secondParameterName: 2)

1> 指定参数标签

func someFunction(argumentLabel parameterName: Int) {
    // 在函数体内，parameterName 代表参数值
}
someFunction(argumentLabel: 5)

func sum(num x: Int ,num y: Int) -> Int{
    return x + y
}
print(sum(num: 30, num: 40))
 
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."

2> 忽略参数标签

如果你不希望为某个参数添加一个标签，可以使用一个下划线( _ )来代替一个明确的参数标签。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    // 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)

func sum(_ x: Int ,_ y: Int) -> Int{
    return x + y
}
print(sum(40, 50))

3> 默认参数值

你可以在函数体中通过给参数赋值来为任意一个参数定义默认值(Deafult Value)。当默认值被定义后，调用这个函数时可以忽略这个参数。

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12

// 不指定参数的值就为默认值
func sum1(x: Int = 1 ,y: Int = 2) -> Int{
    return x + y
}
print(sum1())  //  输出结果 3
print(sum1(x: 10, y: 10))  //  输出结果 20
print(sum1(x: 20))  //  输出结果 22
print(sum1(y: 20))   //  输出结果 21

4> 可变参数

一个可变参数(variadic parameter)可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入( ... )的方式来定义可变参数。

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)
// 返回 3.0, 是这 5 个数的平均数。 
arithmeticMean(3, 8.25, 18.75)
// 返回 10.0, 是这 3 个数的平均数。

#注意：一个函数最多只能拥有一个可变参数。

5> 输入输出函数

函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误(compile-time error)。这意味着你不能错误地更改参数值。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数(In-Out Parameters)。

var one = 1
var four = 4
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}
swap(&one, &four)
print("one = \(one), fout = \(four)")
// 打印 one = 4, fout = 1

#定义在函数体外的变量one和four的原始值在函数中被修改了

4.函数类型

每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b 
}
// 这两个函数的类型是 (Int, Int) -> Int ，可以解读为“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值。”

func printHelloWorld() {
    print("hello, world")
}
// 这个函数的类型是: () -> Void ，或者叫“没有参数，并返回 Void 类型的函数”。

1> 使用函数类型

#“定义一个叫做mathFunction的变量，类型是‘一个有两个Int型参数并返回一个Int型的值的函数’，并让这个新变量指向addTwoInts函数”
var mathFunction: (Int, Int) -> Int = addTwoInts
 print("Result: \(mathFunction(2, 3))")
 //  "Result: 5"

mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
//   "Result: 6"

let anotherMathFunction = addTwoInts
// anotherMathFunction 被推断为 (Int, Int) -> Int 类型
#就像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推断其函数类型

2> 函数类型作为参数类型

你可以用 (Int, Int) -> Int 这样的函数类型作为另一个函数的参数类型

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印 "Result: 8"

3> 函数类型作为返回类型

你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头( -> )后写一个完整的函数类型。

 func stepForward(_ input: Int) -> Int {
     return input + 1
 }
 func stepBackward(_ input: Int) -> Int {
     return input - 1
 }

// 返回值类型为(Int) -> Int 类型的函数
 func chooseStepFunction(backward: Bool) -> (Int) -> Int {
     return backward ? stepBackward : stepForward
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)// backward 为ture
 // moveNearerToZero 现在指向 stepBackward() 函数。

print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!

5.嵌套函数

函数定义在别的函数体中，称作嵌套函数(nested functions)。
默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数(enclosing function)调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int {
        return input + 1
    }
    func stepBackward(input: Int) -> Int {
        return input - 1
    }
    return backward ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!