Swift-无敌的函数与闭包(FunctionsAndClosu

代码是死的，人是活的，关键看你怎么把死的代码玩活- Hunter

使用func定义一个函数, 通过函数名、参数列表, 调用者个函. 使用->与参数独立开，后面接这个函数的返回类型.

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

默认的，函数使用它们的参数名字作为它们的形参标签。在它们的参数名字前面，写一个自定义的参数标签。如果不用参数标签，写_

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

使用元祖作为复合值，如下例子从这个函数中返回多个值。可以通过名字或数字访问这个元祖的元素。

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(scores: [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(numbers: 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(list: numbers, condition: lessThanTen)

可以确切的说函数是一个特殊的闭包。包体的代码之后会被调用。闭包体内可以能问变量像，变量、函数。使用in将参数和返回值与闭包体分离。

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

你可以选择更简洁的写这个闭包。当一个闭包的类型是已知的，作为代理，你可以忽略它的参数类型、返回值类型，甚至都可以忽略。它的语句就是它的返回值

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