➽05函数

Posted 2021-11-01 itzyjr

定义和调用函数

func greet(person: String) -> String {
	return "Hello, " + person + "!"
}

以上函数，叫：greet(person:)，参数是名为person的String类型，返回类型为String。

print(greet(person: "Anna"))
// Prints "Hello, Anna!"
print(greet(person: "Brian"))
// Prints "Hello, Brian!"

如果这样调用:greet("Anna")则报错Missing argument label 'person:' in call。

多个参数

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

无返回值

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

严格地说，这个版本的greet(person:)函数仍然返回一个值，即使没有定义返回值。没有定义返回类型的函数返回Void类型的特殊值。这只是一个空的元组，写为()。

多个返回值

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)")
// Prints "min is -6 and max is 109"

可选的元组返回类型
如果要从函数返回的元组类型可能对整个元组具有“no value”，则可以使用可选的元组返回类型来反映整个元组可以为nil的事实。

可选的元组类型，如(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)
}

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("min is \\(bounds.min) and max is \\(bounds.max)")
}
// Prints "min is -6 and max is 109"

隐式的return
如果函数的整个主体是单个表达式，则函数将隐式返回该表达式。
下面两个函数行为是一样的：

func greeting(person: String) -> String {
    "Hello, " + person + "!"
}
print(greeting(person: "Dave"))
// Prints "Hello, Dave!"

func anotherGreeting(person: String) -> String {
    return "Hello, " + person + "!"
}
print(anotherGreeting(person: "Dave"))
// Prints "Hello, Dave!"

函数参数标签和参数名
每个函数参数都有一个参数标签和一个参数名。调用函数时使用参数标签；每个参数都写在函数调用中，前面有参数标签。参数名用于函数的实现。默认情况下，参数使用其参数名称作为参数标签。

func someFunction(firstParameterName: Int, secondParameterName: Int) {
    // In the function body, firstParameterName and secondParameterName
    // refer to the argument values for the first and second parameters.
}
someFunction(firstParameterName: 1, secondParameterName: 2)

参数标签加在参数名前面，用空格分隔。
参数标签的使用可以让函数以一种表达性的、类似句子的方式被调用，同时还提供了一个可读且意图清晰的函数体。

func someFunction(argumentLabel parameterName: Int) {
    // In the function body, parameterName refers to the argument value
    // for that parameter.
}

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

如果return语句中是：“Hello…from (from)”，直接报错：Cannot find 'from' in scope
如果print语句中是："greet(…, hometown: “Cupertino”)，直接报错：Incorrect argument label in call (have 'hometown:', expected 'from:')

省略参数标签

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    // In the function body, firstParameterName and secondParameterName
    // refer to the argument values for the first and second parameters.
}
someFunction(1, secondParameterName: 2)

如果参数具有参数标签，则在调用函数时必须标记参数。

默认参数值

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // If you omit the second argument when calling this function, then
    // the value of parameterWithDefault is 12 inside the function body.
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault is 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault is 12

可变参数

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)
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(3, 8.25, 18.75)
// returns 10.0, which is the arithmetic mean of these three numbers

in-out参数
默认情况下，函数参数是常量。试图从函数体中更改函数参数的值会导致编译时错误。这意味着您不能错误地更改参数的值。如果希望在函数体中修改参数的值，并且希望这些更改在函数调用结束后保持不变，请将该参数定义为in-out参数，用inout关键字，放在参数类型前。

inout参数不能有默认值。可变参数不能标记为inout。

下面是一个名为swapTwoInts(_:_:)的函数示例，该函数有两个名为a和b的in-out整数参数：

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)")
// Prints "someInt is now 107, and anotherInt is now 3"

请注意，someInt和anotherInt的名称在传递给swapTwoInts(_:_:)函数时，会以一个&符号作为前缀。

函数类型

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，即：一个没有参数也没有返回值的函数。

使用函数类型

var mathFunction: (Int, Int) -> Int = addTwoInts

定义一个名为mathFunction的变量，其类型为“接受两个Int值并返回一个Int值的函数”。将此新变量设置为引用名为addTwoInts的函数。

print("Result: \\(mathFunction(2, 3))")
// Prints "Result: 5"

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

函数类型作为参数类型

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

函数类型作为返回类型

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)
while currentValue != 0 {
    print("\\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!

嵌套函数
默认情况下，嵌套函数对外隐藏，但仍然可以由其封闭函数调用和使用。封闭函数还可以返回其一个嵌套函数，以允许在另一个作用域中使用该嵌套函数。

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)
while currentValue != 0 {
    print("\\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!