Swift 5.2 Functions and Closures 功能和关闭

功能和关闭

使用func声明一个函数。 通过在函数名称后加上括号中的参数列表来调用函数。 使用->将参数名称和类型与函数的返回类型分开。

func greet(person: String, day: String) -> String {
    return "Hello \(person), today is \(day)."
}
print(greet(person: "Bob", day: "Turesday"))

// Prints"Hello Bob, today is Turesday."

实验

删除日期参数。 添加一个参数，以在问候语中添加今天的特色午餐。

func greet(person: String, day: String, lunch: String) -> String {
    return "Hello \(person), today is \(day). We will eat \(lunch)."
}
print(greet(person: "Bob", day: "Tuesday", lunch:"noodles"))

// Prints"Hello Bob, today is Tuesday. We will eat noodles."

默认情况下，函数使用其参数名称作为其参数的标签。 在参数名称之前写一个自定义参数标签，或写_以不使用任何参数标签。

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)"
}
print(greet("John", on: "wednesday"))
//Prints"Hello John, today is wednesday"

greet 函数内直接输入person 字符串

使用元组生成复合值，例如，从函数返回多个值。 元组的元素可以通过名称或数字来引用。

//使用元组生成复合值，例如，从函数返回多个值。 元组的元素可以通过名称或数字来引用。
func calculateStastics(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 = calculateStastics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
//Prints"120"
print(statistics.max)
//Prints"100"
print(statistics.2)
//Prints"120"
print(statistics.1)
//Prints"100"

看到最后小数点后可以用名称、也可以用元素的数字代表。

函数可以嵌套。 嵌套函数可以访问在外部函数中声明的变量。 您可以使用嵌套函数将代码组织为长函数或复杂函数。

//函数可以嵌套。 嵌套函数可以访问在外部函数中声明的变量。 您可以使用嵌套函数将代码组织为长函数或复杂函数。

func returnFifiteen() -> Int{
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
print(returnFifiteen())
//Prints"15"

函数是一流？？（first-class type）的类型。 这意味着一个函数可以返回另一个函数作为其值。

//函数是一流??(first-class type)的类型。 这意味着一个函数可以返回另一个函数作为其值。

func makeIncremeter() -> ((Int) -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncremeter()
print(increment(7))
// Print"8"

一个函数可以将另一个函数作为其参数之一。

// 一个函数可以将另一个函数作为其参数之一。

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]
print(hasAnyMatches(list: numbers, condition: lessThanTen))
// Prints"true"

lessThanTen 函数返回是否有小于10 的值，hasAnyMatches 函数返回condition 情况，而condition 情况是可以选择的。

// 一个函数可以将另一个函数作为其参数之一。

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
}
func lessThanFive(number: Int) -> Bool {
    return number < 5
}
var numbers = [20, 19, 7, 12]
print(hasAnyMatches(list: numbers, condition: lessThanTen))
// Prints"true"
print(hasAnyMatches(list: numbers, condition: lessThanFive))
// Prints"false"

函数实际上是闭包的一种特殊情况：可以稍后调用的代码块。 闭包中的代码可以访问在创建闭包的范围内可用的变量和函数之类的东西，即使闭包在执行时位于不同的范围内，您也已经看到了嵌套函数的示例。 您可以使用大括号（{}）将代码括起来，以编写没有名称的闭包。 使用in分隔参数并从主体返回类型。

//您可以使用大括号（{}）将代码括起来，以编写没有名称的闭包。 使用in分隔参数并从主体返回类型。
var numbers = [20, 19, 7, 12]
numbers.map({ (number: Int) -> Int in
    let result = 3 * number
    print(result)
    return result
})
//Prints"60  57  21  36"

不明觉厉。。。

⚠️Result of call to 'map' is unused

调用“map”的结果未使用

实验

重写闭包以对所有奇数返回零。

//实验    重写闭包以对所有奇数返回零。

var numbers = [20, 19, 7, 12]
numbers.map({ (number: Int) -> Int in
//    func isEven(number: Int) -> Bool {
//        if number % 2 == 0 {
//            return true
//        }else {
//            return false
//        }
//    }
//
    if number % 2 == 0 {
        let result = number
        print(result)
    }else {
        let result = 0
        print(result)
    }
    
    return number
})

//Prints"20 0 0 12"

您有几种选择可以更简洁地编写闭包。 当已知闭包的类型（例如委托的回调）时，可以省略其参数的类型，返回类型或两者。 单个语句闭包隐式返回其唯一语句的值。

//您有几种选择可以更简洁地编写闭包。 当已知闭包的类型（例如委托的回调）时，可以省略其参数的类型，返回类型或两者。 
//单个语句闭包隐式返回其唯一语句的值。
var numbers = [20, 19, 7, 12]
let mappednumbers = numbers.map({ number in 3 * number })
print(mappednumbers)
//Prints"[60, 57, 21, 36]"

您可以通过数字而不是名称来引用参数-这种方法在非常短的闭包中特别有用。 作为最后一个参数传递给函数的闭包可以在括号后立即显示。 如果闭包是函数的唯一参数，则可以完全省略括号。

//您可以通过数字而不是名称来引用参数-这种方法在非常短的闭包中特别有用。 
//作为最后一个参数传递给函数的闭包可以在括号后立即显示。 
//如果闭包是函数的唯一参数，则可以完全省略括号。

var numbers = [20, 19, 7, 12]
let sortedNumbers = numbers.sorted() { $0 > $1 }
print(sortedNumbers)

//Prints"[20, 19, 12, 7]"

不明觉厉。。