函数
当你定义一个函数时，你可以定义一个或多个有名字和类型的值，作为函数的输入，称为参数，也可以定义某种类型的值作为函数执行结束时的输出，称为返回类型。
每个函数有个函数名，用来描述函数执行的任务。要使用一个函数时，用函数名来调用这个函数，并传给它匹配的输入值实参。函数的实参必须与函数参数表里参数的顺序一致。
函数参数与返回值
函数的定义以func作为前缀，后接方法名，后跟一对括号定义参数，参数用,隔开；指定函数返回类型时，用返回箭头->后跟返回类型的名称的方式来表示。
无参数函数
func sayHelloWorld() -> String {
return "hello, world"
}
print(sayHelloWorld())
// 打印 "hello, world"
多参数函数
func add(num1: Int, num2: Int) -> String {
return "sum is \(num1+num2)"
}
print(add(num1: 3, num2: 5))
// 打印 "sum is 8"
无返回值函数
func say(message: String) {
print("say \(message)")
}
say(message: "hello")
// 打印 say hello
严格上来说，虽然没有返回值被定义，say(message:)函数依然返回了值。没有定义返回类型的函数会返回一个特殊的Void值。它其实是一个空的元组tuple，没有任何元素，可以写成()。
多重返回值函数
你可以用元组tuple类型让多个值作为一个复合值从函数中返回。
func minmax(array: [Int]) -> (min: Int, max: Int) {
let min = array.min()!
let max = array.max()!
return (min, max)
}
let (min, max) = minmax(array: [2, 4, 9, 1])
print("min: \(min), max: \(max)")
// 打印 min: 1, max: 9
可选元组返回类型
如果函数返回的元组类型有可能整个元组都没有值，你可以使用可选的optional元组返回类型反映整个元组可以是nil的事实。
可选元组类型如(Int, Int)?与元组包含可选类型如(Int?, Int?)是不同的。可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。
func minmax(array: [Int]) -> (min: Int, max: Int)? {
if array.count == 0 {
return nil
}
let min = array.min()!
let max = array.max()!
return (min, max)
}
// 通过可选绑定取值
if let (min, max) = minmax(array: [2, 4, 9, 1]) {
print("min: \(min), max: \(max)")
}
函数参数标签和参数名称
每个函数参数都有一个参数标签argument label以及一个参数名称parameter name。参数标签在调用函数的时候使用；调用的时候需要将函数的参数标签写在对应的参数前面。参数名称在函数的实现中使用。默认情况下，函数参数使用参数名称来作为它们的参数标签。
func someFunction(firstParameterName: Int, secondParameterName: Int) {
// firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(firstParameterName: 1, secondParameterName: 2)
所有的参数都必须有一个独一无二的名字。虽然多个参数拥有同样的参数标签是可能的，但是一个唯一的函数标签能够使你的代码更具可读性。
指定参数标签
你可以在参数名称前指定它的参数标签，中间以空格分隔：
func greet(person: String, from hometown: String) -> String {
return "Hello \(person)! Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino"))
// 打印 "Hello Bill! Glad you could visit from Cupertino."
忽略参数标签
如果你不希望为某个参数添加一个标签，可以使用一个下划线_来代替一个明确的参数标签。
func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
// firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)
默认参数值
你可以在函数体中通过给参数赋值来为任意一个参数定义默认值Deafult Value。当默认值被定义后，调用这个函数时可以忽略这个参数。
func double(num: Int, multiple: Int = 2) -> Int {
return num * multiple
}
print(double(num: 5))
// 打印 10
可变参数
一个可变参数variadic parameter可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入...的方式来定义可变参数。
func sum(_ numbers: Int...) -> Int {
var sum = 0
for num in numbers {
sum = sum + num
}
return sum
}
print(sum(2, 3, 5))
注意：一个函数最多只能拥有一个可变参数。
输入输出参数
函数参数默认是常量。试图在函数体中更改参数值将会导致编译错误。如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数In-Out Parameters。
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temp = a;
a = b
b = temp
}
var a = 3
var b = 5
swapTwoInts(&a, &b)
print("a: \(a), b: \(b)")
// 打印 a: 5, b: 3
函数类型
每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。
func addTwoInts(_ a: Int, _ b: Int) -> Int {
return a + b
}
函数的类型是(Int, Int) -> Int。
func printHelloWorld() {
print("hello, world")
}
函数的类型是() -> Void。
使用函数类型
var mathFunction: (Int, Int) -> Int = addTwoInts
print("Result: \(mathFunction(2, 3))")
// Prints "Result: 5"
addTwoInts和mathFunction有同样的类型，并让这个新变量指向addTwoInts函数”，就可以用mathFunction来调用被赋值的函数了。
函数类型作为参数类型
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印 "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
}
嵌套函数
到目前为止本章中你所见到的所有函数都叫全局函数global functions，它们定义在全局域中。你也可以把函数定义在别的函数体中，称作嵌套函数nested functions。
func getTwice(_ num: Int) -> () -> Int {
let multiple = 2
func twice () -> Int {
return num * multiple
}
return twice
}
闭包
Swift的闭包表达式拥有简洁的风格，并鼓励在常见场景中进行语法优化，主要优化如下：
- 利用上下文推断参数和返回值类型
- 隐式返回单表达式闭包，即单表达式闭包可以省略
return关键字 - 参数名称缩写
- 尾随闭包语法
闭包表达式
闭包表达式语法有如下的一般形式：
{ (parameters) -> returnType in
statements
}
以sorted(by:)方法为例，
let numbers = [3, 9, 5, 1, 7]
sorted(by:)方法接受一个闭包，排序闭包函数类型需为(Int, Int) -> Bool。
func backward(_ num1: Int, _ num2: Int) -> Bool {
return num1 > num2
}
然而，以这种方式来编写一个实际上很简单的表达式num1 > num2，确实太过繁琐了。对于这个例子来说，利用闭包表达式语法可以更好地构造一个内联排序闭包。
let backwardNums = numbers.sorted(by: {(num1, num2) -> Bool in
num1 > num2
})
根据上下文推断类型
Swift可以推断其参数和返回值的类型，sorted(by:)方法被一个Int数组调用，因此其参数必须是(Int, Int) -> Bool类型的函数。这意味着参数和返回值类型并不需要作为闭包表达式定义的一部分。因为所有的类型都可以被正确推断:
let backwardNums = numbers.sorted(by: {num1, num2 in return num1 > num2})
单表达式闭包隐式返回
单行表达式闭包可以通过省略return关键字来隐式返回单行表达式的结果，如上版本的例子可以改写为：
let backwardNums = numbers.sorted(by: {num1, num2 in num1 > num2})
参数名称缩写
Swift自动为内联闭包提供了参数名称缩写功能，你可以直接通过 $0，$1，$2来顺序调用闭包的参数，以此类推。
let backwardNums = numbers.sorted(by: {$0 > $1})
运算符方法
实际上还有一种更简短的方式来编写上面例子中的闭包表达式。Swift的Int类型定义了关于大于号>的实现，其作为一个函数接受两个Int类型的参数并返回Bool类型的值。而这正好与sorted(by:)方法的参数需要的函数类型相符合。因此，你可以简单地传递一个大于号，Swift可以自动推断出你想使用大于号的字符串函数实现：
let backwardNums = numbers.sorted(by: >)
尾随闭包
如果你需要将一个很长的闭包表达式作为最后一个参数传递给函数，可以使用尾随闭包来增强函数的可读性。尾随闭包是一个书写在函数括号之后的闭包表达式，函数支持将其作为最后一个参数调用。在使用尾随闭包时，你不用写出它的参数标签：
func myFunc(completion: () -> Void) {
completion()
}
不使用尾随闭包进行函数调用:
myFunc(completion: {
print("hello world")
})
使用尾随闭包进行调用:
myFunc() {
print("hello world")
}
如果闭包表达式是函数或方法的唯一参数，则当你使用尾随闭包时，你甚至可以把()省略掉：
myFunc {
print("hello world")
}
值捕获
闭包可以在其被定义的上下文中捕获常量或变量。即使定义这些常量和变量的原作用域已经不存在，闭包仍然可以在闭包函数体内引用和修改这些值。
func makeIncrementer(forIncrement amount: Int) -> () -> Int {
var runningTotal = 0
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
return incrementer
}
如果我们单独考虑嵌套函数incrementer()，会发现它有些不同寻常：
func incrementer() -> Int {
runningTotal += amount
return runningTotal
}
incrementer()函数并没有任何参数，但是在函数体内访问了 runningTotal和amount变量。这是因为它从外围函数捕获了runningTotal和amount变量的引用。捕获引用保证了runningTotal和amount变量在调用完makeIncrementer后不会消失，并且保证了在下一次执行incrementer函数时，runningTotal依旧存在。
let incrementByTen = makeIncrementer(forIncrement: 10)
incrementByTen()
// 返回的值为10
incrementByTen()
// 返回的值为20
incrementByTen()
// 返回的值为30
Swift闭包可以在其被定义的上下文中捕获常量或变量，而Objective-C需要使用__block捕获上下文中常量或变量；所以闭包不同于block。
闭包是引用类型
上面的例子中，`incrementByTen是常量，但是这些常量指向的闭包仍然可以增加其捕获的变量的值。这是因为函数和闭包都是引用类型。
无论你将函数或闭包赋值给一个常量还是变量，你实际上都是将常量或变量的值设置为对应函数或闭包的引用。上面的例子中，指向闭包的引用incrementByTen是一个常量，而并非闭包内容本身。
解决闭包引起的循环强引用
Swift有如下要求：只要在闭包内使用self的成员，就要用self.someProperty或者self.someMethod()（而不只是someProperty或someMethod()）。这提醒你可能会一不小心就捕获了self，造成循环强引用。
定义捕获列表
捕获列表中的每一项都由一对元素组成，一个元素是weak或unowned关键字，另一个元素是类实例的引用（例如self）或初始化过的变量（如delegate = self.delegate!）。这些项在方括号中用逗号分开。
如果闭包有参数列表和返回类型，把捕获列表放在它们前面：
lazy var someClosure: (Int, String) -> String = {
[unowned self, weak delegate = self.delegate!] (index: Int, stringToProcess: String) -> String in
// 这里是闭包的函数体
}
如果闭包没有指明参数列表或者返回类型，即它们会通过上下文推断，那么可以把捕获列表和关键字in放在闭包最开始的地方：
lazy var someClosure: Void -> String = {
[unowned self, weak delegate = self.delegate!] in
// 这里是闭包的函数体
}
注意:
在闭包和捕获的实例总是互相引用并且总是同时销毁时，将闭包内的捕获定义为无主引用。
如果被捕获的引用绝对不会变为nil，应该用无主引用，而不是弱引用。
逃逸闭包
当一个闭包作为参数传到一个函数中，但是这个闭包在函数返回之后才被执行，我们称该闭包从函数中逃逸。当你定义接受闭包作为参数的函数时，你可以在参数名之前标注@escaping，用来指明这个闭包是允许逃逸出这个函数的。
一种能使闭包逃逸出函数的方法是，将这个闭包保存在一个函数外部定义的变量中。举个例子，很多启动异步操作的函数接受一个闭包参数作为completion handler。这类函数会在异步操作开始之后立刻返回，但是闭包直到异步操作结束后才会被调用。在这种情况下，闭包需要“逃逸”出函数，因为闭包需要在函数返回之后被调用。例如：
var completionHandlers: [() -> Void] = []
func escapingClosureFunc(completionHandler: @escaping () -> Void) {
completionHandlers.append(completionHandler)
}
将一个闭包标记为@escaping意味着你必须在闭包中显式地引用self。
自动闭包
自动闭包是一种自动创建的闭包，用于包装传递给函数作为参数的表达式。这种闭包不接受任何参数，当它被调用的时候，会返回被包装在其中的表达式的值。这种便利语法让你能够省略闭包的花括号，用一个普通的表达式来代替显式的闭包。
自动闭包让你能够延迟求值，因为直到你调用这个闭包，代码段才会被执行。延迟求值对于那些有副作用和高计算成本的代码来说是很有益处的，因为它使得你能控制代码的执行时机。下面的代码展示了闭包如何延时求值。
var customersInLine = ["Chris", "Alex", "Ewa", "Barry", "Daniella"]
print(customersInLine.count)
// 打印出 "5"
let customerProvider = { customersInLine.remove(at: 0) }
print(customersInLine.count)
// 打印出 "5"
print("Now serving \(customerProvider())!")
// Prints "Now serving Chris!"
print(customersInLine.count)
// 打印出 "4"