iOS-swift-函数和闭包

一、函数

关键字：func

参数列表用 , 分割

使用 -> 分割参数和返回值

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

在参数名前面加 _ 表示隐藏参数标签，也可以添加参数名。

1     func greet(_ person: String, on day: String) -> String {
2         return "Hello \(person), today is \(day)."
3     }
4     greet("John", on: "Wednesday")

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

 1     func calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
 2         var min = scores[0]
 3         var max = scores[0]
 4         var sum = 0
 5
 6         for score in scores {
 7             if score > max {
 8                 max = score
 9             } else if score < min {
10                 min = score
11             }
12             sum += score
13         }
14
15         return (min, max, sum)
16     }
17     let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
18     print(statistics.sum)
19     print(statistics.2)

函数可以使用变化的参数，这些参数将会放进数组里面。

1     func sumOf(numbers: Int...) -> Int {
2         var sum = 0
3         for number in numbers {
4             sum += number
5         }
6         return sum
7     }
8     sumOf()
9     sumOf(numbers: 42, 597, 12)

函数里面可以嵌套函数。

1     func returnFifteen() -> Int {
2         var y = 10
3         func add() {
4             y += 5
5         }
6         add()
7         return y
8     }
9     returnFifteen()

函数可以作为另一个函数的类型

1     func makeIncrementer() -> ((Int) -> Int) {
2         func addOne(number: Int) -> Int {
3             return 1 + number
4         }
5         return addOne
6     }
7     var increment = makeIncrementer()
8     increment(7)

函数可以作为另一个函数的参数

 1     func hasAnyMatches(list: [Int], condition: (Int) -> Bool) -> Bool {
 2         for item in list {
 3             if condition(item) {
 4                 return true
 5             }
 6         }
 7         return false
 8     }
 9     func lessThanTen(number: Int) -> Bool {
10         return number < 10
11     }
12     var numbers = [20, 19, 7, 12]
13     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)

嗯，努力！