Swift学习笔记（11）——函数

1.基本内容

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

（1） func 作为前缀
（2） 函数的名字是greet(person:)
（3） 需输入一个String类型的参数
（4） 指定函数返回类型是String，用返回箭头 ->（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。如果函数不需要返回值，就不要写返回箭头（->）和返回类型。

函数被调用：

print(greet(person: "Anna"))// 打印 "Hello, Anna!"

2.多重返回值函数

（1）用元组（tuple）类型让多个值作为一个复合值从函数中返回。

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)}

minMax(array:) 函数返回一个包含两个 Int 值的元组，这些值被标记为 min 和 max ，以便查询函数的返回值时可以通过名字访问它们。

因为元组的成员值已被命名，因此可以通过 . 语法来检索找到的最小值与最大值：

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"

（2）可选元组返回类型

返回的元组类型有可能整个元组都“没有值”，可以使用可选的（ optional ） 元组。例如：（Int, Int)?

func minMax(array: [Int]) -> (min: Int, max: Int)? {    ……    return (currentMin, currentMax)}

把 minMax(array:) 函数改写为使用可选元组返回类型，可以安全处理传入的参数是“空”的问题。
可以使用可选绑定来检查 minMax(array:) 函数返回的是一个存在的元组值还是 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. 函数参数标签

（1）指定参数标签

你可以在函数名称前指定它的参数标签，中间以空格分隔：

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

所有的参数都必须有一个独一无二的名字。虽然多个参数拥有同样的参数标签是可能的，但是一个唯一的函数标签能够使你的代码更具可读性。

（2）忽略参数标签

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

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

如果一个参数有一个标签，那么在调用的时候必须使用标签来标记这个参数。

4.参数

（一）默认参数值

（1）

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

（2）可变参数

一个可变参数（variadic parameter）可以接受零个或多个值。通过在变量类型名后面加入（…）的方式来定义可变参数。

可变参数的传入值在函数体中变为此类型的一个数组。

一个函数最多只能拥有一个可变参数。

func arithmeticMean(_ numbers: Double...) -> Double {   // 传入numbers 的 [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 个数的平均数。

（二）输入输出参数

（1）函数参数默认是常量。
（2）不能错误地更改参数值。
（3）如果把某个函数的参数定义为输入输出参数（In-Out Parameters），那么该函数可以修改参数的值，并且修改后的结果在函数调用结束后仍然存在。
（4）定义一个输入输出参数时，在参数定义前加 inout 关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。
（5）只能传递变量给输入输出参数，不能传递常量。
（6）当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。
（7）输入输出参数不能有默认值，而且可变参数不能用 inout 标记。

func swapTwoInts(_ a: inout Int, _ b: inout Int) {    let temporaryA = a    a = b    b = temporaryA}var someInt = 3var anotherInt = 107swapTwoInts(&someInt, &anotherInt)print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")// 打印 "someInt is now 107, and anotherInt is now 3"

5.使用函数类型

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

定义一个叫做 mathFunction 的变量，其类型为(Int, Int) -> Int，新变量指向 addTwoInts 函数（addTwoInts 函数符合(Int, Int) -> Int）。

可以用 mathFunction 来调用被赋值的函数了：

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

（1）函数类型作为参数类型

func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {    print("Result: \(mathFunction(a, b))")}printMathResult(addTwoInts, 3, 5)// 打印 "Result: 8"// 函数的参数有：// 1.(Int, Int) -> Int型的mathFunction// 2. Int型的a // 3. Int型的b// 调用时，传入 addTwoInts 函数和整数 3 和 5

（2）函数类型作为返回类型

func stepForward(_ input: Int) -> Int {    return input + 1}func stepBackward(_ input: Int) -> Int {    return input - 1}func chooseStepFunction(backward: Bool) -> (Int) -> Int { // chooseStepFunction函数的返回类型是，类型为(Int) -> Int的函数return backward ? stepBackward : stepForward// stepBackward 和 stepForward函数的类型都为(Int) -> Int}