函数

使用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)