Swift中的函数和闭包

Swift的函数引入了许多新概念，比如区分内部和外部参数名字，参数个数可变，使用元组作为参数，使用->来指定返回类型，也可以返回多个返回值。甚至，函数本身可以作为参数或者返回值来使用。

闭包是自包含的函数代码块，可以在代码中被传递和使用。 Swift 中的闭包与 C 和 Objective-C 中的代码块（blocks）以及其他一些编程语言中的 lambdas 函数比较相似。闭包可以捕获和存储其所在上下文中任意常量和变量的引用。 这就是所谓的闭合并包裹着这些常量和变量，俗称闭包。

1）函数定义

使用关键字 func 来定义函数，用冒号来说明参数类型，用 -> 来说明返回值类型，如: 

func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", day: "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])
print(statistics.sum)
print(statistics.0)     //min

参数个数可变

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

内嵌函数

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

2）函数是 first-class 类型，这意味着 一个函数可以使用 函数 作为返回类型

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

使用 {} 和 in 关键字来 定义一个闭包，如

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

也可简写成

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

类似的，我们可以使用这样的一中方式来做排序

<pre name="code" class="plain">let sortedNumbers = numbers.sort { $0 > $1 }

print(sortedNumbers)

3）函数可以有多个返回值

func getSize() -> (weight: Double, height: Double) {return (180, 360)}
let x = getSize()
print("weight is \(x.weight)")

// ===== or ========
print("height is \(getSize().height)")

4）函数参数的内部名和外部名

方法和参数名


函数的每个参数都有一个 内部名 和 外部名 ; 内部名供函数内部处理使用，外部名供调用函数时指定参数使用

func foo(<span style="color:#3333ff;">externalFirst</span> <span style="color:#ff6600;">first</span>: Int, <span style="color:#3333ff;">externalSecond</span> <span style="color:#ff6600;">second</span>: Int) {
    for i in 0..<<span style="color:#ff6600;">first</span> {
    }
}
let result = foo(<span style="color:#3333ff;">externalFirst</span>: 123, <span style="color:#3333ff;">externalSecond</span>: 222) 

如果你不希望使用外部名，可以用 _ 来消除这个用法，而这对于第一个参数来说是默认的（除了在初始化函数中）。

func foo(<span style="color:#3333ff;">_</span> <span style="color:#ff6600;">first</span>: Int, externalSecond <span style="color:#ff6600;">second</span>: Int) {
        for i in 0..<first {
        }
}
let result = foo(123, externalSecond: 222) 

等同于

func foo(first: Int, externalSecond second: Int) {
        for i in 0..<first {
        }
}
let result = foo(123, externalSecond: 222) 

除了第一个参数，除非额外指定，其他参数的内部名也是默认的外部名

func foo(first: Int, <span style="color:#ff6600;">sec</span><span style="color:#3333ff;">ond</span>: Int) {
        for i in 0..<first {
        }
}
let result = foo(123, second: 222) 

每个参数的外部名可以被改变（设置可以强制第一个参数使用外部名）

func foo(<span style="color:#3333ff;">forceFirst</span> first: Int, _ second: Int) {
        for i in 0..<first {
        }
}
let result = foo(<span style="color:#3333ff;">forceFirst</span>: 123, 222) 

只不过这种做法（强制第一个外部名或强制改变其他参数外部名）是不推荐的，是反SWIFT的。