iOS Swift基础学习笔记(二)函数(Function)和闭

使用func来声明一个函数。通过在函数名后面添加包含参数列表的圆括号来执行函数。使用->来分离参数和返回类型。

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

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

func greet(person: String, lunch: String) -> String
{
    return "Hello \(person), I eat \(lunch) today."
}
greetWithLunch(person: "Jack", lunch: "sandwich")

默认情况下，函数使用它们的参数名称作为其参数的标签。在参数名称前写入自定义参数标签，或者写入_表示使用无参数标签。

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, 50, 8])
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, 583, 23)

练习：写一个函数来求传入参数的平均值。

func averageOf(numbers: [Int]) -> Int {
    var average = 0
    var sum = 0
    
    for number in numbers {
        sum += number
    }
    average = sum / numbers.count
    return average
}
averageOf(numbers: [45, 32, 19, 65, 84])

函数可以嵌套。嵌套函数可以访问在外部函数中声明的变量。你可以使用嵌套函数来包装冗长和复杂的代码。

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
}
makeIncrementer()
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, 18, 7, 11]
hasAnyMatches(list: numbers, condition: lessThanTen)

函数实际上是一种特殊的闭包：可以在之后调用的代码块。闭包中的代码可以访问在创建闭包的域（scope）中可用的变量和函数，即使闭包在执行时处于不同的域。你可以通过使用花括号({})包装一段代码来创建一个匿名闭包。使用in来分离闭包代码块与参数、返回类型。

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

练习：重写闭包来为所有奇数返回0。

numbers.map({
    (number: Int) -> Int in
    var odd = number % 2
    if odd != 0 {
        return 0
    } else {
        return number
    }
})

有一些简洁的办法来创建闭包。当闭包的类型已知，比如一个代理的回调，你可以忽略它的参数或者返回值，或者两者都忽略。单一语句的闭包隐式地返回语句值。

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

你可以通过数字而不是名字来引用一个参数——这个方法在特别短小的闭包里非常实用。作为函数的最后一个参数传递的闭包可以紧跟在圆括号后面。 当闭包是函数的唯一参数时，可以完全省略圆括号。

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

参考苹果官方文档