代碼是死的，人是活的，關鍵看你怎么把死的代碼玩活- 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)