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的。