函数和闭包

使用func来声明一个函数，使用名字和参数来调用函数。使用->来指定函数返回值的类型。

func greet(name: String, day: String) -> String { return "Hello \(name), today is \(day)." } greet("Bob", day: "Tuesday")

练习： 删除day参数，添加一个参数来表示今天吃了什么午餐。

使用元组来让一个函数返回多个值。该元组的元素能够用名称或数字来表示。

func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) { var min = scores[0] var max = scores[0] var sum = 0 for score in scores { if score > max { max = score } else if score < min { min = score } sum += score } return (min, max, sum) } let statistics = calculateStatistics([5, 3, 100, 3, 9]) print(statistics.sum) print(statistics.2)

函数能够带有可变个数的参数，这些参数在函数内表现为数组的形式：

func sumOf(numbers: Int...) -> Int { var sum = 0 for number in numbers { sum += number } return sum } sumOf() sumOf(42, 597, 12)

练习： 写一个计算参数平均值的函数。

函数能够嵌套。被嵌套的函数能够访问外侧函数的变量，你可使用嵌套函数来重构一个太长或者太复杂的函数。

func returnFifteen() -> Int { var y = 10 func add() { y += 5 } add() return y } returnFifteen()

函数是第一等类型，这意味着函数能够做为另外一个函数的返回值。

func makeIncrementer() -> (Int -> Int) { func addOne(number: Int) -> Int { return 1 + number } return addOne } var increment = makeIncrementer() increment(7)

函数也能够当作参数传入另外一个函数。

func hasAnyMatches(list: [Int], condition: Int -> Bool) -> Bool { for item in list { if condition(item) { return true } } return false } func lessThanTen(number: Int) -> Bool { return number < 10 } var numbers = [20, 19, 7, 12] hasAnyMatches(numbers, condition: lessThanTen)

函数其实是一种特殊的闭包:它是一段能以后被调取的代码。闭包中的代码能访问闭包所建做用域中能获得的变量和函数，即便闭包是在一个不一样的做用域被执行的 - 你已经在嵌套函数例子中所看到。你可使用{}来建立一个匿名闭包。使用in将参数和返回值类型声明与闭包函数体进行分离。

numbers.map({
    (number: Int) -> Int in let result = 3 * number return result })

练习： 重写闭包，对全部奇数返回0。

有不少种建立更简洁的闭包的方法。若是一个闭包的类型已知，好比做为一个回调函数，你能够忽略参数的类型和返回值。单个语句闭包会把它语句的值当作结果返回。

let mappedNumbers = numbers.map({ number in 3 * number }) print(mappedNumbers)

你能够经过参数位置而不是参数名字来引用参数——这个方法在很是短的闭包中很是有用。当一个闭包做为最后一个参数传给一个函数的时候，它能够直接跟在括号后面。当一个闭包是传给函数的惟一参数，你能够彻底忽略括号。

let sortedNumbers = numbers.sort { $0 > $1 } print(sortedNumbers)