函数是完成指定任务的独立代码块。
Swift中的函数都有对应的类型，由参数类型和返回值类型共同组成。你可以像使用其他类型一样来使用函数类型，因此，可以将函数作为函数的参数，也可以将函数作为函数的返回值。函数中也可以嵌套函数，实现功能封装。
1、定义和调用函数
当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入（参数，parameters），也可以定义某种类型的值作为函数执行结束的输出（返回类型）。
要使用一个函数时，你用函数名“调用”，并传给它相应的输入值（称作实参，arguments）。一个函数的实参必须与函数参数表里参数的顺序一致。
func greet(person: String) -> String {
let greeting = "Hello, " + person + "!"
return greeting
}
输入不同的参数，返回不同的结果：
print(greet(person: "Anna"))
// prints "Hello, Anna!"
print(greet(person: "Brian"))
// prints "Hello, Brian!"
为了简化这个函数的定义，可以将问候消息的创建和返回写成一句：
func greetAgain(person: String) -> String {
return "Hello again, " + person + "!"
}
print(greetAgain("Anna"))
// prints "Hello again, Anna!"
2、函数参数和返回值
（1）没有参数的函数
输入参数并不是必需的：
func sayHelloWorld() -> String {
return "hello, world"
}
print(sayHelloWorld())
// prints "hello, world"
（2）有多个参数的函数
函数可以有多个参数，都写在括号里，并用逗号分隔。每个参数都有一个label。
func greet(person: String, alreadyGreeted: Bool) -> String {
if alreadyGreeted {
return greetAgain(person)
} else {
return greet(person)
}
}
print(greet("Tim", alreadyGreeted: true))
// prints "Hello again, Tim!"
当调用含有一个或多个参数的函数时，第一个参数之后的其他参数都会用参数名作标识。（V2.1）
（3）没有返回值的函数
返回值并不是必需的：
func greet(person: String) {
print("Goodbye, \(person)!")
}
sayGoodbye("Dave")
// prints "Goodbye, Dave!"
没有返回值，箭头和返回类型就不用写了。
注意：严格来说，即使没有定义返回值，函数也必须返回一个值。没有返回值的函数实际上返回了一种特殊的值Void，这是一个空的元组，实际上也就是没有元素的元组，可以写成（）。
调用函数的时候，可以忽略它的返回值：
func printAndCount(stringToPrint: String) -> Int {
print(stringToPrint)
return stringToPrint.characters.count
}
func printWithoutCounting(stringToPrint: String) {
printAndCount(stringToPrint)
}
printAndCount("hello, world")
// prints "hello, world" and returns a value of 12
printWithoutCounting("hello, world")
// prints "hello, world" but does not return a value
注意：函数的返回值可以不被使用，但是函数必须声明它会返回一个值。如果函数定义了返回值类型，但在函数底部没有返回一个值，将会报编译时错误。
（4）有多个返回值的函数
如果有多个返回值，可以用元组来作为函数的返回类型。
func minMax(array: [Int]) -> (min: Int, max: Int) {
var currentMin = array[]
var currentMax = array[]
for value in array[..<array.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
由于元组的成员名已在返回类型中声明，可以用点语法来取出元组中对应的值。
let bounds = minMax([, -, , , , ])
print("min is \(bounds.min) and max is \(bounds.max)")
// prints "min is -6 and max is 109"
注意：元组的成员不需要在函数返回时命名，因为它们的名字已经在函数返回类型中有了定义。
（5）可选的元组返回类型
如果元组返回时，可能整个元组都没有值，那么，可以用可选元组来作为返回值类型，暗示返回的元组可能是nil。可选元组就是在元组的括号后面添加一个问号，例如(Int, Int)?或(String, Int, Bool)?。
注意：(Int, Int)?和(Int?, Int?)是不同的两个概念。可选元组是整个元组可能是nil，而不是各个成员的值可能是nil。
func minMax(array: [Int]) -> (min: Int, max: Int)? {
if array.isEmpty { return nil }
var currentMin = array[]
var currentMax = array[]
for value in array[..<array.count] {
if value < currentMin {
currentMin = value
} else if value > currentMax {
currentMax = value
}
}
return (currentMin, currentMax)
}
可以用可选绑定来检查函数是否返回了元组：
if let bounds = minMax([, -, , , , ]) {
print("min is \(bounds.min) and max is \(bounds.max)")
}
// prints "min is -6 and max is 109"
3、函数的参数名
函数的参数都有一个外部参数名（argument label）和局部参数名（parameter name）。
当调用函数时，外部参数名被用来标识参数。局部参数名则被用在函数的实现主体中。
默认情况下，局部参数名和外部参数名是相同的。
func someFunction(firstParameterName: Int, secondParameterName: Int) {
// function body goes here
// firstParameterName and secondParameterName refer to
// the argument values for the first and second parameters
}
someFunction(, secondParameterName: )
一般情况下，第一个参数省略其外部参数名，第二个以后的参数使用其局部参数名作为自己的外部参数名。
所有参数必须有不同的局部参数名（parameter name），尽管外部参数名（argument label）可以是相同的，独特的外部参数名还是能让代码更具有可读性。
（1）指定外部参数名（Label）
可以在本地参数名前指定外部参数名，中间以空格分隔。
func someFunction(argumentLabel parameterName: Int) {
// function body goes here, and can use parameterName
// to refer 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.
为每个参数指定外部参数名，在你调用函数greet(person:from:)函数时两个参数都必须被标记出来。
（2）忽略外部参数名
如果你不想为参数设置label，可以用下划线(_)代替。
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// function body goes here
// firstParameterName and secondParameterName refer to
// the argument values for the first and second parameters
}
someFunction(, )
注意：第一个参数的外部名默认是省略的，所以 不必为它添加下划线。（V2.1）
4、默认参数值
当默认值被定义后，调用这个函数时可以忽略这个参数。
func someFunction(parameterWithDefault: Int = ) {
// function body goes here
// if no arguments are passed to the function call,
// value of parameterWithDefault is 12
}
someFunction() // parameterWithDefault is 6
someFunction() // parameterWithDefault is 12
注意： 带有默认值的参数要放在函数参数列表的最后。这样可以保证在函数调用时，非默认参数的顺序是一致的，同时使得相同的函数在不同情况下调用时显得更为清晰。
5、不定参数
不定参数（variadic parameter）可以接受零个或多个值。函数调用时，你可以用不定参数来传入不确定数量的输入参数。
通过在变量类型名后面加入（...）的方式来定义不定参数。
不定参数的传入值在函数体内实际是同类型的一个数组。例如，一个 Double... 型可变参数numbers，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。
func arithmeticMean(_ numbers: Double...) -> Double {
var total: Double =
for number in numbers {
total += number
}
return total / Double(numbers.count)
}
arithmeticMean(, , , , )
// returns 3.0, which is the arithmetic mean of these five numbers
arithmeticMean(, 8.25, 18.75)
// returns 10.0, which is the arithmetic mean of these three numbers
注意：每个函数最多有一个不定参数。
6、In-Out参数
函数的参数默认看做常量，在函数体内试图改变参数的值会报编译时错误。
如果你想在函数中改变某个参数的值，并将这种变化保留到函数外部，那么可以将参数定义为in-out参数。
in-out参数通过在参数类型前面加上inout关键字来定义。
只能将变量传给in-out参数，常量和字面量不能使用。
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
当把变量名传给in-out参数时，要在变量名前面加上&符号，表示函数可以修改该变量。
var someInt =
var anotherInt =
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// Prints "someInt is now 107, and anotherInt is now 3”
注意： in-out参数不能有默认值，而且不定参数不能用 inout 标记。
7、函数类型
每个函数都有种特定的函数类型，由函数的参数类型和返回类型组成。
func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
return a * b
}
上面的两个函数的函数类型都是(Int, Int) -> Int。
另一种函数：
func printHelloWorld() {
print("hello, world")
}
其返回类型是() -> Void。
（1）使用函数类型
函数类型的使用和其他类型一样，例如，可以把一个函数赋值给一个常量或变量。
var mathFunction: (Int, Int) -> Int = addTwoInts
这样，可以用mathFunction的名字来调用addTwoInts函数：
print("Result: \(mathFunction(2, 3))")
// prints "Result: 5"
同一函数类型的其他函数也可以赋值给这个变量：
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")
// prints "Result: 6"
由于函数推断，可以不用显示声明变量的类型：
let anotherMathFunction = addTwoInts
// anotherMathFunction is inferred to be of type (Int, Int) -> Int
（2）函数类型作为参数类型
你可以用(Int, Int) -> Int这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现交由给函数的调用者。
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, , )
// prints "Result: 8"
（3）函数类型作为返回类型
可以用函数类型作为另一个函数的返回类型。
例如，下面是两个简单函数。
func stepForward(_ input: Int) -> Int {
return input +
}
func stepBackward(_ input: Int) -> Int {
return input -
}
下面这个叫做 chooseStepFunction(_:) 的函数，它的返回类型是 (Int) -> Int 的函数。
chooseStepFunction(backward:) 根据布尔值 backwards 来返回 stepForward(_:) 函数或 stepBackward(_:) 函数：
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
return backward ? stepBackward : stepForward
}
可以用chooseStepFunction(_:) 来获得一个函数：
var currentValue =
let moveNearerToZero = chooseStepFunction(backward: currentValue > )
// moveNearerToZero now refers to the stepBackward() function
moveNearerToZero已获得了正确的函数，就可以用来将数字数到0：
print("Counting to zero:")
// Counting to zero:
while currentValue != {
print("\(currentValue)... ")
currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!
8、嵌套函数
func chooseStepFunction(backward: Bool) -> (Int) -> Int {
func stepForward(_ input: Int) -> Int { return input + }
func stepBackward(_ input: Int) -> Int { return input - }
return backward ? stepBackward : stepForward
}
var currentValue = -
let moveNearerToZero = chooseStepFunction(backward: currentValue > )
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != {
print("\(currentValue)... ")
currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero!