iOS-swift-函数和闭包

一、函数

    关键字：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")

使用元组（tuple）构建复合类型值。比如一个函数返回多个值。元组的元素可以通过名字或者下标获取。

    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)

 二、闭包（closures）    函数是闭包的的一种特殊情况：代码块延时调用。

    可以用大括号 {} 写一个闭包。 使用 "in" 把闭包参数和返回值从闭包体区分开来。

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

    可以更简单，功能一样。

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

    可以使用数值下标代替名字访问参数，这个对于简短的闭包很有用。

    当一个闭包是函数的唯一参数，可以省略圆括号。

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

嗯，努力！