Swift基础语法预览（二）

函数和闭包

使用func声明一个函数。调用函数需要函数名，和括号中一系列的参数。

使用->来分隔参数名和返回值。

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

     greet("Bob", "Tuesday")

使用元组来返回复合值。例如，函数的多值返回。元组的元素使用名字或者值可以被返回。

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])

statistics.min // statistics.0  3

statistics.max // statistics.1 100

statistics.sum // statistics.2 120

函数也可以传递个数可变的参数

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

sumOf()  // 0
sumOf(42, 597, 12) // 651

函数可以被嵌套。嵌套的函数可以使用外部声明的变量。

你可以使用嵌套函数来组织长且复杂的函数。

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

returnFifteen() // 15

函数被作为第一类类型。这意味着函数可以作为返回值。

func makeIncrementer() -> (Int -> Int) {
   
    func addOne(number: Int) -> Int {
        return 1 + number
    }
   
    return addOne
}

var incrementer = makeIncrementer()

incrementer(7) // 8

一个函数也可以将其它函数作为参数。

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, lessThanTen) // true

函数是特殊的闭包：代码块可以可以延迟调用。

闭包里的代码能够获取在可获取领域的（即创建到闭包）变量和方法，即使闭包在不同的领域被执行。

你可以看到一个被嵌套的函数。你可以使用花括号 { } 来包围匿名闭包，使用 in 来分隔参数和返回类型后的闭包体。

var numbers = [20, 19, 7, 12]

numbers.map({  // 20, 0, 0, 12
   
    (number: Int) -> Int in
   
    if (number % 2 != 0) {
        return 0
    }
    return number
   
    })

numbers // 20 19 7 12

你还有一些更方便的方式编写闭包。当一个闭包类型已知，例如作为回调函数的代理，你可以忽略参数类型和返回值类型。

单条闭包语句的值会被隐式地当作返回值。

numbers.map({ number in 3 * number }) // 60, 57, 21, 36

你可以使用数值代替名字作为返回值，这种方法在简短的闭包中非常有用。

一个闭包传递给函数作为最后一个参数可直接跟在圆括号的后面。

sort([1, 5, 3, 12, 2]) { $0 > $1 } // 12, 5, 3, 2, 1