无参数函数
函数可以没有参数。下面这个函数就是一个无参数函数，当被调用时，它返回固定的 String 消息：
func sayHelloWorld() -> String {
return "hello, world"}
print(sayHelloWorld())
多参数函数
函数可以有多种输入参数，这些参数被包含在函数的括号之中，以逗号分隔
func greet(person: String, alreadyGreeted: Bool) -> String{
if alreadyGreeted{
return greetAgain(person: person)}else{
return greet(person: person)}}
print(greet(person: "Tim", alreadyGreeted: true))
无返回值函数
函数可以没有返回值。下面是 greet(person:) 函数的另一个版本，这个函数直接打印一个 String值，而不是返回它
func greet(person: String){
print("hello, \(person)")}
greet(person: "dave")
因为这个函数不需要返回值，所以这个函数的定义中没有返回箭头（->）和返回类型。
严格地说，即使没有明确定义返回值，该 greet(Person：) 函数仍然返回一个值。没有明确定义返回类型的函数的返回一个 Void 类型特殊值，该值为一个空元组，写成 ()。
func printAndCount(string: String) -> Int {
print(string)
return string.count}
func printWithoutCounting(string: String) {
let _ = printAndCount(string: string)
}
printAndCount(string: "hello, world")// 打印“hello, world”，并且返回值12
printWithoutCounting(string: "hello, world")// 打印“hello, world”，但是没有返回任何值
多重返回值函数
你可以用元组（tuple）类型让多个值作为一个复合值从函数中返回
下例中定义了一个名为 minMax(array:) 的函数，作用是在一个 Int 类型的数组中找出最小值与最大值。
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)")
需要注意的是，元组的成员不需要在元组从函数中返回时命名，因为它们的名字已经在函数返回类型中指定了。
可选元组返回类型
如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的 元组返回类型反映整个元组可以是 nil 的事实。你可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?
可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的。可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。
为了安全地处理这个“空数组”问题，将 minMax(array:) 函数改写为使用可选元组返回类型，并且当数组为空时返回 nil
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)}
你可以使用可选绑定来检查 minMax(array:) 函数返回的是一个存在的元组值还是 nil：
if let bounds = minMax(array: [8,-6,2,109,3,71]){
print("min is \(bounds.min) and max is \(bounds.max)")}
函数参数标签和参数名称
每个函数参数都有一个参数标签（argument label）以及一个参数名称（parameter name）。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。
func someFunction(firstParameterName: Int, secondParameterName: Int){
//在函数体内, firstParameterName和secondParameterName代表参数中的第一个和第二个值}
someFunction(firstParameterName: 1, secondParameterName: 2)
所有的参数都必须有一个独一无二的名字。虽然多个参数拥有同样的参数标签是可能的，但是一个唯一的函数标签能够使你的代码更具可读性。
指定参数标签
你可以在参数名称前指定它的参数标签，中间以空格分隔
func someFunction(argumentLabel parameterName: Int){
//在函数体内, parameterName代表参数值}
这个版本的 greet(person:) 函数，接收一个人的名字和他的家乡，并且返回一句问候
func greet(person: String, from hometown: String) -> String{
return "hello \(person)! glad you could visit from \(hometown)."}
print(greet(person: "bill", from: "Cupertino"))
参数标签的使用能够让一个函数在调用时更有表达力，更类似自然语言，并且仍保持了函数内部的可读性以及清晰的意图
忽略参数标签
如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签。
func someFunction(_ firstParameter: Int, secondParameterName: Int){
//在函数体内, firstParameter和secondParameterName代表参数中的第一个和第二个参数值}
someFunction(1, secondParameterName: 2)
如果一个参数有一个标签，那么在调用的时候必须使用标签来标记这个参数
默认参数值
你可以在函数体中通过给参数赋值来为任意一个参数定义默认值（Deafult Value）。当默认值被定义后，调用这个函数时可以忽略这个参数
func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 2){
// 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 2 传入到函数体中。}
someFunction(parameterWithoutDefault: 1, parameterWithDefault: 12)
someFunction(parameterWithoutDefault: 10)
将不带有默认值的参数放在函数参数列表的最前。一般来说，没有默认值的参数更加的重要，将不带默认值的参数放在最前保证在函数调用时，非默认参数的顺序是一致的，同时也使得相同的函数在不同情况下调用时显得更为清晰
可变参数
一个可变参数（variadic parameter）可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数
可变参数的传入值在函数体中变为此类型的一个数组。例如，一个叫做 numbers 的 Double... 型可变参数，在函数体内可以当做一个叫 numbers 的 [Double] 型的数组常量。
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)
arithmeticMean(3,8.25,18.75)
输入输出参数
函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。这意味着你不能错误地更改参数值。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）
定义一个输入输出参数时，在参数定义前加 inout 关键字。一个 输入输出参数有传入函数的值，这个值被函数修改，然后被传出函数，替换原来的值。想获取更多的关于输入输出参数的细节和相关的编译器优化，请查看输入输出参数一节
你只能传递变量给输入输出参数。你不能传入常量或者字面量，因为这些量是不能被修改的。当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改
下例中，swapTwoInts(_:_:) 函数有两个分别叫做 a 和 b 的输入输出参数：
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
swapTwoInts(_:_:) 函数简单地交换 a 与 b 的值。该函数先将 a 的值存到一个临时常量 temporaryA中，然后将 b 的值赋给 a，最后将 temporaryA 赋值给 b。
你可以用两个 Int 型的变量来调用 swapTwoInts(_:_:)。需要注意的是，someInt 和 anotherInt 在传入 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”
从上面这个例子中，我们可以看到 someInt 和 anotherInt 的原始值在 swapTwoInts(_:_:) 函数中被修改，尽管它们的定义在函数体外。
输入输出参数和返回值是不一样的。上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt 和 anotherInt 的值。输入输出参数是函数对函数体外产生影响的另一种方式。
函数类型
每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成
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，或者叫“没有参数，并返回 Void 类型的函数”。
使用函数类型
在 Swift 中，使用函数类型就像使用其他类型一样。例如，你可以定义一个类型为函数的常量或变量，并将适当的函数赋值给它：
var mathFunction: (Int, Int) -> Int = addTwoInts
这段代码可以被解读为：
”定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”
addTwoInts 和 mathFunction 有同样的类型，所以这个赋值过程在 Swift 类型检查（type-check）中是允许的
现在，你可以用 mathFunction 来调用被赋值的函数了
print("result: \(mathFunction(2, 3))")
有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样：
mathFunction = multiplyTwoInts
print("result: \(mathFunction(2, 3))")
就像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推断其函数类型：
let anotherMathFunction = addTwoInts
// anotherMathFunction 被推断为 (Int, Int) -> Int 类型
函数类型作为参数类型
你可以用 (Int, Int) -> Int 这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现留给函数的调用者来提供
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int){
print("result: \(mathFunction(20, 30))")}
printMathResult(addTwoInts, 3, 5)
函数类型作为返回类型
你可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型
下面的这个例子中定义了两个简单函数，分别是 stepForward(_:) 和 stepBackward(_:)。stepForward(_:) 函数返回一个比输入值大 1 的值。stepBackward(_:) 函数返回一个比输入值小 1 的值。这两个函数的类型都是 (Int) -> Int：
func stepForward(_input: Int) -> Int {
return input + 1}
func stepBackward(_input: Int) -> Int {
return input - 1}
如下名为 chooseStepFunction(backward:) 的函数，它的返回类型是 (Int) -> Int 类型的函数。chooseStepFunction(backward:) 根据布尔值 backwards 来返回 stepForward(_:) 函数或 stepBackward(_:) 函数：
func chooseStepFunction(backward: Bool) -> (Int) -> Int{
return backward ? stepForward : stepBackward}
你现在可以用 chooseStepFunction(backward:) 来获得两个函数其中的一个
var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
上面这个例子中计算出从 currentValue 逐渐接近到0是需要向正数走还是向负数走。currentValue的初始值是 3，这意味着 currentValue > 0 为真（true），这将使得 chooseStepFunction(_:) 返回 stepBackward(_:) 函数。一个指向返回的函数的引用保存在了 moveNearerToZero 常量中
现在，moveNearerToZero 指向了正确的函数，它可以被用来数到零
print("Counting to zero:")// Counting to zero:
while currentValue != 0 {
print("\(currentValue)... ")
currentValue = moveNearerToZero(currentValue)
}
print("zero!")
嵌套函数
到目前为止本章中你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。你也可以把函数定义在别的函数体中，称作 嵌套函数（nested functions）
默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用
你可以用返回嵌套函数的方式重写 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)
while currentValue != 0 {
print("\(currentValue)... ")
currentValue = moveNearerToZero(currentValue)
}
print("zero!")
