函数
使用func声明一个函数。 通过使用它的名称和括号中的参数列表来调用函数。 使用 - >将参数名称和类型与函数的返回类型分开。
//声明一个函数
func greet(person: String, day: String) -> String {
return "Hello \(person), today is \(day)."
}
//调用函数
greet(person: "Bob", day: "Tuesday")
默认情况下，函数使用它们的参数名称作为其参数的标签。 在参数名称前写入自定义参数标签，或者写入"" _ ""表示不使用参数标签。
func greet(_ person: String, on day: String) -> String {//_
return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")
给函数的参数添加自定义的标签
func greet(customName person: String, on day: String) -> String {
return "Hello \(person), today is \(day)."
}
greet(customName:"John", on: "Wednesday")
使用元组制作复合值 - 例如，从函数返回多个值。 元组的元素可以通过名称或通过下标来引用。
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)
print(statistics.2)
函数也可以采用可变数量的参数，将它们收集到数组中。
func sumOf(numbers: Int...) -> Int {
var sum = 0
for number in numbers {
sum += number
}
return sum
}
sumOf()
sumOf(numbers: 42, 597, 12)
函数可以嵌套。 嵌套函数可以访问在外部函数中声明的变量。
func returnFifteen() -> Int {
var y = 10
func add() { //声明一个嵌套函数
y += 5使用外部函数中声明的变量
}
add()//调用嵌套函数
return y
}
returnFifteen()
函数是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) {//如果condition函数返回为true，则外函数为true
return true
}
}
return false
}
func lessThanTen(number: Int) -> Bool {
return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(list: numbers, condition: lessThanTen)//将判断的函数传入，如果有满足条件的，返回为true
闭包
函数实际上是闭包的特殊情况：稍后可以调用的代码块。 闭包中的代码可以访问在创建闭包的时可用的变量和函数。 你可以使用大括号（{}）写一个没有名称的闭包。 使用in将参数和返回类型从主体中分离。
var numbers = [20, 19, 7, 12]
let num = numbers.map({
(number: Int) -> Int in //拿到变量和函数
let result = 3 * number //对变量和函数进行操作
return result //返回结果
})
如果是一个字典调用了map，会是下面这种情况
var numbers = ["key1":20, "key2":19, "key3":7, "key4":12]
let num = numbers.map({
numberA -> Int in //这时的numberA是一个元组
return numberA.value //拿到的是字典中的值，如果想要拿到字典中的键：：numberA.key
})
在以下情况发生的时候，你可以简化闭包的写法
- 当一个闭包的类型已经知道，例如一个代理的回调，你可以忽略它的参数的类型，它的返回类型，或参数类型和返回值类型。 只有一条语句的闭包会返回这条语句的值。
var numbers = [20, 19, 7, 12]
let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
你可以按数字来引用参数 - 这个方法在非常短的闭包中尤其有用。 作为函数的最后一个参数传递的闭包可以紧跟在括号后面。 当闭包是函数的唯一参数时，可以完全省略括号。
var numbers = [20, 19, 7, 12]
let sortedNumbers = numbers.sorted { $0 < $1 }
print(sortedNumbers)