函数是一段完成特定任务的独立代码片段。可以通过给函数命名来标识某个函数的功能。这个名字可以被用来在需要的时候调用这个函数来完成它的任务。
Swift统一的函数语法非常灵活，可以用来表示任何函数，包括从简单的没有参数名字的C风格函数，到复杂的带局部和外部参数名的OC风格。参数可以提供默认值，可以简化函数调用。参数也可以既当做传入参数，也当做传出参数，也就是说，一旦函数执行结束，传入的参数值将被修改。
在Swift中，每个函数都有一个由函数的参数值类型和返回值类型组成的类型。可以把函数类型当做任何其他普通变量类型一样处理，这样就可以简单的把函数当做别的函数的参数，也可以从其他函数中返回函数。函数的定义可以写在其他函数定义中，这样可以嵌套函数范围内实现功能封装。
本文涉及的内容有函数定义与调用、函数参数与返回值、函数参数标签和参数名称、函数类型、嵌套函数
函数的定义与调用
- 当定义一个函数时，可以定义一个或者多个有名字和类型的值作为函数的输入，称为参数，也可以定义某种类型的值作为函数执行结束的输出，称为返回类型。每个函数有个函数名（方法名）。使用函数名来调用这个函数，传入输入值（实参）。返回对应的返回值。举例如下：
func greet(person: String) -> String {let greeting = "Hello, " + person + "!"return greeting
}
print(greet(person: "Anna"))
// 打印 "Hello, Anna!"
print(greet(person: "Brian"))
// 打印 "Hello, Brian!"
复制代码注： 在greet（person：）的函数体中，先定义了一个新的名为greeting的String常量。同时，把对personName的问候消息赋值给了greeting。然后用return关键字把这个问候返回出去。一旦return greening被调用，该函数结束它的执行并返回greeting的当前值。
函数参数与返回值
- 函数可以没有参数或者多个参数，可以没有返回值或者多重返回值。
无参数函数
无参数函数，返回String举例如下：
func sayHelloWorld() -> String {return "hello, world"
}
print(sayHelloWorld())
// 打印 "hello, world"
复制代码注： 尽管没有参数，但是定义在函数名后还是需要一对圆括号。
多重参数函数
- 函数可以有多种输入参数，这些参数被包含在函数的括号中，用逗号分开。举例如下：
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!"
复制代码无返回值函数
- 函数可以没有返回值，函数的定义中没有返回箭头
->和返回类型，举例如下：
func greet(person: String) {print("Hello, \(person)!")
}
greet(person: "Dave")
// 打印 "Hello, Dave!"
复制代码注： 严格来说，虽然返回值没有被定义，但是green（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)")
// 打印 "min is -6 and max is 109"复制代码注： 元组的成员不需要在元组从函数中返回时命名，因为它们的名字已经在函数返回类型中指定了。
可选元组返回类型
- 如果函数返回的元组类型没有值，可以使用可选的元组返回类型反映整个元组可以是
nil的事实。通过在元组类型的右括号后放置一个问号来定义一个可选元组。前面的minMax（array：）函数返回了一个包含两个Int值的元组。但是函数不会对传入的数组执行任何安全检查，如果array参数是一个空数组，运行就可能会报错，所以就需要进行容错处理。举例如下:
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)
}
复制代码注： 可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的。可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。
函数参数标签和参数名称
- 每个函数参数都有一个参数标签以及一个参数名称。参数标签在调用函数的时候使用。调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。为了避免多个参数有同样的参数标签，命名尽量清楚，这样会使代码的可读性更强。
指定参数标签
- 可以在参数名称前指定它的参数标签，中间以空格分隔。举例如下：
func someFunction(argumentLabel parameterName: Int) {// argumentLabel 即为参数标签 // 在函数体内，parameterName 代表参数值
}
复制代码- 如果你不希望为某个参数添加一个标签，可以使用一个下划线（
_）来代替一个明确的参数标签 - 调用时，有参数标签、（
_）代替参数标签和无参数标签对比如下：
func someFunction(parameterName: Int) {}
func someFunctions(_ parameterName: Int) {}
func someFunctions_(argumentLabel parameterName: Int) {}someFunction(parameterName: 3)
someFunctions(3)
someFunctions_(argumentLabel: 3)
复制代码默认参数
可以在函数体中通过给参数赋值来为任意一个参数定义默认值。当默认值被定义后，调用这个函数可以忽略这个参数。举例如下：
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {// 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12
复制代码多个参数
- 函数的参数可以是零个或多个。函数调用时。通过在变量类型名后面加入（
...）的方式来定义多个参数（可变参数）。 - 多个参数的传入值在函数体中变为此类型的一个数组。例如一个叫做
numbers的Double...型可变参数，在函数体内可以当做一个叫numbers的[Double]型的数组常量。举例如下：
func arithmeticMean(_ numbers: Double...) -> Double {var total: Double = 0for 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 个数的平均数。
复制代码输入输出参数
- 函数参数默认值是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误的更改参数值。如果你想要一个函数可以修改参数值，并且想要这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数。
- 定义一个输入输出参数时，在参数定义前加
inout关键字。一个输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。 - 在传递时只能传递变量给输入输出参数。不能传入常量。当传入的参数作为输入输出参数时，需要在参数名前加
&符表示这个值可以被修改。 - 输入输出参数不能有默认值，而且可变参数不能用
inout标记。
一个简单的交换值方法举例如下：
func swapTwoInts(_ a: inout Int, _ b: inout Int) {let temporaryA = aa = bb = temporaryA
}
复制代码- 可以用两个
Int型的变量来调用swapTwoInts（_:_:）。在传入参数时都加了&的前缀，举例如下：
var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// 打印 "someInt is now 107, and anotherInt is now 3"
复制代码注： 输入输出参数和返回值是不一样的。上面的swapTwoInts函数并没有定义任何返回值，但仍然修改了someInt和anotherInt的值。输入输出参数是函数对函数体外产生影响的另一种方式。
函数类型
每个函数都有种特定的函数类型，函数的类型是由函数的参数类型和返回类型组成。 例如：
func addTwoInts(_ a: Int, _ b: Int) -> Int {return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {return a * b
}
复制代码这个例子中定义了两个简单的数学函数：addTwoInts 和 multiplyTwoInts。这两个函数都接受两个 Int 值， 返回一个 Int 值。
这两个函数的类型是 (Int, Int) -> Int，可以解读为:
“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值”。
下面是另一个例子，一个没有参数，也没有返回值的函数：
func printHelloWorld() {print("hello, world")
}
复制代码这个函数的类型是：() -> Void，或者叫“没有参数，并返回 Void 类型的函数”。
使用函数类型
- 在Swift中，使用函数类型就像使用其他类型一样。例如，可以定义一个类型为函数的常量或者变量，并将适合的函数赋值给它，举例如下：
var mathFunction: (Int, Int) -> Int = addTwoInts
复制代码”定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”。
addTwoInts 和 mathFunction 有同样的类型，所以这个赋值过程在 Swift 类型检查中是允许的。
现在，可以用 mathFunction 来调用被赋值的函数如下：
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 5"
复制代码有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样：
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 6"
复制代码就像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推断其函数类型：
let anotherMathFunction = addTwoInts
// anotherMathFunction 被推断为 (Int, Int) -> Int 类型
复制代码函数类型作为参数类型
- 可以用
（Int， Int）-> Int这样的函数类型作为另一个函数的参数类型。意思就是说，函数也能作为参数传入。举例如下：
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印 "Result: 8"
复制代码这个例子定义了 printMathResult(_:_:_:) 函数，它有三个参数：第一个参数叫 mathFunction，类型是 (Int, Int) -> Int，第二个和第三个参数叫 a 和 b，它们的类型都是 Int。printMathResult(_:_:_:)中实现mathFunction的方法，输出结果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)
// moveNearerToZero 现在指向 stepBackward() 函数。while currentValue != 0 {print("\(currentValue)... ")currentValue = moveNearerToZero(currentValue)
}
print("end!")
// 3...
// 2...
// 1...
// end!
复制代码上述例子中， chooseStepFunction(backward:) 的函数，它的返回类型是 (Int) -> Int 类型的函数，而stepForward(_:) 和 stepBackward(_:)实际就是 (Int) -> Int 的类型。当传入3时，执行stepBackward(_:)，然后重新复制给函数外部的currentValue。
嵌套函数
- 到目前为止本文中你所见的函数都叫全局函数， 他们定义在全局中，也可以把函数定义在别的函数体中，成为嵌套函数，默认情况下嵌套函数是对外界不可见的，但是可以被它们的外围函数调用。一个外围函数也可以是返回嵌套函数，似的这个函数可以在其他域中被使用。
- 用返回嵌套函数的方式重写
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)
}
print("end!")
// -4...
// -3...
// -2...
// -1...
// end!
复制代码