使用func声明一个函数。在函数名后面加上括号中的参数列表调用函数。使用->将参数名和类型与函数的返回类型分离。
func greet(person:String,day:String) -> String {
return "Hello \(person), today is \(day)."
}
print(greet(person: "zhaobin", day: "4"))
默认情况下，函数使用参数名作为参数的标签。在参数名之前写入自定义参数标签，或者写入_以不使用参数标签。
使用元组来创建复合值——例如，从函数返回多个值。元组的元素可以通过名称或数字引用。
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, 3, 9])
print(statistics.sum)
// Prints "120"
print(statistics.2)
// Prints "120"
函数可以嵌套。嵌套函数可以访问外部函数中声明的变量。您可以使用嵌套函数来组织长或复杂函数中的代码。
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
}
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(list: numbers, condition: lessThanTen)
函数实际上是闭包的特殊情况:稍后可以调用的代码块。闭包中的代码可以访问在创建闭包的作用域中可用的变量和函数，即使闭包在执行时处于不同的作用域中——您已经看到了嵌套函数的例子。可以通过使用大括号({})围绕代码编写一个没有名称的闭包。使用in分隔参数和从主体返回类型。
var numbers = [20, 19, 7, 12]
let map123 = numbers.map({ (number: Int) -> Int in
let result = 3 * number
return result
})
print(map123)
[60, 57, 21, 36]
有几个选项可以更简洁地编写闭包。当已经知道闭包的类型(例如委托的回调)时，可以省略它的参数类型、返回类型或两者。单个语句闭包隐式地返回它们唯一语句的值。
var numbers = [20, 19, 7, 12]
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
[60, 57, 21, 36]
您可以通过数字而不是名字来引用参数，这种方法在非常短的闭包中特别有用。作为最后一个参数传递给函数的闭包可以立即出现在括号后面。当闭包是函数的唯一参数时，可以完全省略括号。
let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
// Prints "[20, 19, 12, 7]"
