Swift学习（六）函数

一、函数

1.函数是一段完成特定任务的独立代码片段
2.参数可以提供默认值，以简化函数调用
3.参数可以即当作传入参数，也当作传出参数
4.函数可以当作参数传给函数，也可以当作返回值从函数中返回
5.函数的定义可以写在其他函数定义中
6.函数的输入值又称实参（eg: 10）
7.函数参数中出现下划线时代表可选的，例如print(_:separator:terminator:)第一个参数可选的，后两个参数默认的

二、函数实例

常规函数
        func greet(person: String) -> String { // func前缀，person参数，-> String返回值
            let greeting = "Hello," + person + "!"
            return greeting
            // 简化：return "Hello again, " + person + "!"
        }
        print(greet(person: "Anna"))
        print(greet(person: "Brian"))
        print()
        // 简化
        func greetAgain(person: String) -> String {
            return "Hello again, " + person + "!"
        }
        print(greetAgain(person: "Anna"))

1.无参数函数
        func sayHelloWorld() -> String {
            return "Hello, World"
        }
        print(sayHelloWorld())
2.多参数函数
        func checkGreet(person: String, alreadyGreeted: Bool) -> String {
            if alreadyGreeted {
                return greetAgain(person: person)
            } else {
                return greet(person: person)
            }
        }
        print(checkGreet(person: "小黄3", alreadyGreeted: true))
3.无返回值函数（void类型，该特殊值是一个空元组，写成()）
        func greet1(person: String) {
            print("Hello, \(person)!")
        }
        greet1(person: "小黄4")
4.有返回值的函数
        a.一个返回值
        func printAndCount(string: String) -> Int {
            print(string)
            return string.count
        } 
5.元组返回类型
        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)")
6.可选元组返回类型
如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的 元组返回类型反映整个元组可以是 nil 的事实，你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的。可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。如果 array 参数是一个空数组，如上定义的 minMax(array:) 在试图访问 array[0] 时会触发一个运行时错误。为了安全地处理这个“空数组”问题，将 minMax(array:) 函数改写为使用可选元组返回类型，并且当数组为空时返回 nil：
        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)
        }
        你可以使用可选绑定来检查 minMax(array:) 函数返回的是一个存在的元组值还是 nil：
         if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
             print("min is \(bounds.min) and max is \(bounds.max)")
         }
 7.隐式返回的函数
如果一个函数的整个函数体是一个单行表达式，这个函数可以隐式地返回这个表达式。举个例子，以下的函数有着同样的作用，任何一个可以被写成一行 return 语句的函数都可以忽略 return。
func greeting(for person: String) -> String {
    "Hello, " + person + "!"
}
print(greeting(for: "Dave")) // 打印 "Hello, Dave!" 

三、函数参数标签和参数名称
1.参数名称在函数内部实现中使用，参数标签在函数调用的时候使用
      func 函数名称(参数标签 参数名称: 类型) {
            函数体内，参数名称代表参数值
      }
      参数名称(参数标签：参数值)
      func greet(person: String, from hometown: String) -> String {
          return "Hello \(person)!  Glad you could visit from \(hometown)."
      }
      print(greet(person: "Bill", from: "Cupertino"))
2.忽略参数标签：如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签
        func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
            print("666")
        }
        someFunction(1, secondParameterName: 2)
3.参数默认值：你可以在函数体中通过给参数赋值来为任意一个参数定义默认值（Deafult Value）。当默认值被定义后，调用这个函数时可以忽略这个参数。
        func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
            print("666")
        }
        someFunction(parameterWithoutDefault: 1)
        someFunction(parameterWithoutDefault: 1, parameterWithDefault: 2)
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)
        arithmeticMean(1, 2, 3, 4, 5)
5.输入输出参数：函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。定义一个输入输出参数时，在参数定义前加 inout 关键字。你只能传递变量给输入输出参数。你不能传入常量或者字面量，因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。输入输出参数不能有默认值，而且可变参数不能用 inout 标记。输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。
        func swapTwoInts(_ a: inout Int, _ b: inout Int) {
            let temporaryA = a
            a = b
            b = temporaryA
        }
        var someInt = 3
        var anotherInt = 107
        swapTwoInts(&someInt, &anotherInt)
        print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")

四、函数类型
每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。
下面例子的函数名：addTwoInts(a:b:)，函数类型：(Int, Int) -> Int
      func addTwoInts(_ a: Int, _ b: Int) -> Int {
          return a + b
      }
下面例子的函数名：printHelloWorld()，函数类型：() - > Void
      func printHelloWorld() {
          print("hello, world")
      }
1.使用函数类型（例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它），有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样。就像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推断其函数类型。
      var mathFunction: (Int, Int) -> Int = addTwoInts
      print("Result: \(mathFunction(2, 3))")
      mathFunction = multiplyTwoInts
      print("Result: \(mathFunction(2, 3))")
2.函数类型作为参数类型：你可以用 (Int, Int) -> Int 这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现留给函数的调用者来提供。
        func addTwoInts(_ a: Int, _ b: Int) -> Int {
            return a + b
        }
        func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
            print("Result: \(mathFunction(a, b))")
        } // 说白了，就是这个函数告诉他有这么一个函数，然后再给两个值去调用
        printMathResult(addTwoInts(_:_:), 3, 5)
        printMathResult(addTwoInts, 3, 5)
3.函数类型作为返回类型：可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型
        func stepForward(_ input: Int) -> Int {
            return input + 1
        }
        func stepBackward(_ input: Int) -> Int {
            return input - 1
        }
        func chooseStepFunction(backward: Bool) -> (Int) -> Int {
            return backward ? stepBackward : stepForward
        }
        var currentValue = 3
        let moveNearerToZero = chooseStepFunction(backward: currentValue > 0) // 计算出从 currentValue 逐渐接近到0是需要向正数走还是向负数走。
        print("Counting to zero:")
        // Counting to zero:
        while currentValue != 0 {
            print("\(currentValue)... ")
            currentValue = moveNearerToZero(currentValue)
        }
        print("zero!")
4.嵌套函数：上面所有函数为全局函数，他们定义在全局域中，定义到别的函数体内叫做嵌套函数，默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。可以用返回嵌套函数的方式重写 chooseStepFunction(backward:) 函数
        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)
        }