Swift函数

函数参数标签(外部参数，别名)和参数名称（内部参数）

// firstParameterName,secondParameterName 即为内部参数也为外部参数，
默认情况下函数参数使用参数名称来作为它们的参数标签。
func someFunction(firstParameterName: Int, secondParameterName: Int) {
   
}
someFunction(firstParameterName: 1, secondParameterName: 2)
//argumentLabel为外部参数，parameterName内部参数
func someFunction(argumentLabel parameterName: Int) {
    
}
someFunction(argumentLabel: 3)

忽略参数标签

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

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {

}
someFunction(1, secondParameterName: 2)

默认参数值

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

输入输出参数

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

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}
var qqq = 4, www = 8
swapTwoInts(&qqq, &www)
print(qqq,www) //输出 8   4

---

函数类型

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

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

• 使用函数类型
  在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：

func tempFunction(a: Int, b: Int)->Int {
    return a + b
}
var mathFunction: (Int, Int)-> Int = tempFunction  
print(mathFunction(1,2))   // 输出 3 

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

func getForward(input: Int)->Int {
    return input + 1
}

func getBackward(input: Int)->Int {
    return input - 1
}

func chooseFunction(parama: Bool)->(Int)->Int {
    return parama ? getBackward : getForward
}

var currentValue = 3
let afterValue = chooseFunction(parama: currentValue > 0)
print(afterValue(1))

---

嵌套函数

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

func makeIncrementer() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7) 

多重返回值函数

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)
}
print(minMax(array: [1,2,3,4,5,6]))