Swift-函数，定义、调用、返回值、参数、隐式返回、可变参数、嵌套函数

最新推荐文章于 2021-07-07 11:00:58 发布

dev.xue

最新推荐文章于 2021-07-07 11:00:58 发布

阅读量447

点赞数

分类专栏： Swift语法

本文链接：https://blog.csdn.net/DevXue/article/details/104893902

版权

Swift语法专栏收录该内容

27 篇文章 0 订阅

订阅专栏

1. 函数的定义与调用

以 func 作为前缀。
函数返回类型： ->（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。

func greet(person: String) -> String {  //  函数的名字是 greet(person:)
    let greeting = "Hello, " + person + "!"
    return greeting
}
print(greet(person: "Anna"))    // 打印“Hello, Anna!”
print(greet(person: "Brian"))   // 打印“Hello, Brian!”

为了简化这个函数的定义，可以将问候消息的创建和返回写成一句：

func greetAgain(person: String) -> String {
    return "Hello again, " + person + "!"
}
print(greetAgain(person: "Anna"))   // 打印“Hello again, Anna!”

2. 函数参数与返回值

2.1 无参数函数

函数可以没有参数。

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())  // 打印“hello, world”

2.2 多参数函数

函数可以有多种输入参数，这些参数被包含在函数的括号之中，以逗号分隔。

func greet(person: String, alreadyGreeted: Bool) -> String {
    if alreadyGreeted {
        return greetAgain(person: person)
    } else {
        return greet(person: person)
    }
}
print(greet(person: "Tim", alreadyGreeted: true))   // 打印“Hello again, Tim!”

2.3 无返回值函数

函数可以没有返回值。

func greet(person: String) {
    print("Hello, \(person)!")
}
greet(person: "Dave")   // 打印“Hello, Dave!”

注意
    1. 严格地说，即使没有明确定义返回值。
    2. 该 greet(Person：) 函数仍然返回一个值。
    3. 没有明确定义返回类型的函数的返回一个 Void 类型特殊值，该值为一个空元组，写成 ()。

2.4 多重返回值函数

可以用元组（tuple）类型让多个值作为一个复合值从函数中返回。

func minMax(array: [Int]) -> (min: Int, max: Int) {
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("min is \(bounds.min) and max is \(bounds.max)")
// 打印“min is -6 and max is 109”

minMax(array:) 函数返回一个包含两个 Int 值的元组，这些值被标记为 min 和 max ，以便查询函数的返回值时可以通过名字访问它们。
因为元组的成员值已被命名，因此可以通过 . 语法来检索找到的最小值与最大值。

2.5 可选元组返回类型

如果函数返回的元组类型有可能整个元组都“没有值”，你可以使用可选的元组返回类型反映整个元组可以是 nil 的事实。

可以通过在元组类型的右括号后放置一个问号来定义一个可选元组，例如 (Int, Int)? 或 (String, Int, Bool)?

  注意：可选元组类型如 (Int, Int)? 与元组包含可选类型如 (Int?, Int?) 是不同的。可选的元组类型，整个元组是可选的，而不只是元组中的每个元素值。

为了安全地处理这个“空数组”问题，将 minMax(array:) 函数改写为使用可选元组返回类型，并且当数组为空时返回 nil：

func minMax(array: [Int]) -> (min: Int, max: Int)? {
    if array.isEmpty { return nil }
    var currentMin = array[0]
    var currentMax = array[0]
    for value in array[1..<array.count] {
        if value < currentMin {
            currentMin = value
        } else if value > currentMax {
            currentMax = value
        }
    }
    return (currentMin, currentMax)
}

可以使用可选绑定来检查 minMax(array:) 函数返回的是一个存在的元组值还是 nil：

if let bounds = minMax(array: [8, -6, 2, 109, 3, 71]) {
    print("min is \(bounds.min) and max is \(bounds.max)")
}
// 打印“min is -6 and max is 109”

2.6 隐式返回的函数

如果一个函数的整个函数体是一个单行表达式，这个函数可以隐式地返回这个表达式。

func greeting(for person: String) -> String {
    "Hello, " + person + "!"
}
print(greeting(for: "Dave"))    // 打印 "Hello, Dave!"

func anotherGreeting(for person: String) -> String {
    return "Hello, " + person + "!"
}
print(anotherGreeting(for: "Dave")) // 打印 "Hello, Dave!"

greeting(for:) 函数的完整定义是打招呼内容的返回，这就意味着它能使用隐式返回这样更简短的形式。
anothergreeting(for:) 函数返回同样的内容，却因为 return 关键字显得函数更长。
任何一个可以被写成一行 return 语句的函数都可以忽略 return。

3. 函数参数标签和参数名称

3.1 指定参数标签

在参数名称前指定它的参数标签，中间以空格分隔：

func greet(person: String, from hometown: String) -> String {
    return "Hello \(person)!  Glad you could visit from \(hometown)."
}
print(greet(person: "Bill", from: "Cupertino")) // 打印“Hello Bill!  Glad you could visit from Cupertino.”

参数标签的使用能够让一个函数在调用时更有表达力，更类似自然语言，并且仍保持了函数内部的可读性以及清晰的意图。

3.2 忽略参数标签

如果你不希望为某个参数添加一个标签，可以使用一个下划线（_）来代替一个明确的参数标签。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
     // 在函数体内，firstParameterName 和 secondParameterName 代表参数中的第一个和第二个参数值
}
someFunction(1, secondParameterName: 2)

如果一个参数有一个标签，那么在调用的时候必须使用标签来标记这个参数。

3.3 默认参数值

可以在函数体中通过给参数赋值来为任意一个参数定义默认值（Deafult Value）。

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // 如果你在调用时候不传第二个参数，parameterWithDefault 会值为 12 传入到函数体中。
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault = 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault = 12

3.4 可变参数

一个可变参数（variadic parameter）可以接受零个或多个值。函数调用时，你可以用可变参数来指定函数参数可以被传入不确定数量的输入值。通过在变量类型名后面加入（...）的方式来定义可变参数。
可变参数的传入值在函数体中变为此类型的一个数组。

func arithmeticMean(_ numbers: Double...) -> Double {
    var total: Double = 0
    for number in numbers {
        total += number
    }
    return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5)   // 返回 3.0, 是这 5 个数的平均数。
arithmeticMean(3, 8.25, 18.75)  // 返回 10.0, 是这 3 个数的平均数。

注意：一个函数最多只能拥有一个可变参数。

3.5 输入输出参数

函数参数默认是常量，试图在函数体中更改参数值将会导致编译错误。
如果你想要一个函数可以修改参数的值，并且想要在这些修改在函数调用结束后仍然存在，那么就应该把这个参数定义为输入输出参数（In-Out Parameters）。
定义一个输入输出参数时，在参数定义前加 inout 关键字

func swapTwoInts(_ a: inout Int, _ b: inout Int) {
    let temporaryA = a
    a = b
    b = temporaryA
}

var someInt = 3
var anotherInt = 107
swapTwoInts(&someInt, &anotherInt)
print("someInt is now \(someInt), and anotherInt is now \(anotherInt)")
// 打印“someInt is now 107, and anotherInt is now 3”

注意1：

你只能传递变量给输入输出参数。
你不能传入常量或者字面量，因为这些量是不能被修改的。
当传入的参数作为输入输出参数时，需要在参数名前加 & 符，表示这个值可以被函数修改。

注意2：

输入输出参数和返回值是不一样的。
上面的 swapTwoInts 函数并没有定义任何返回值，但仍然修改了 someInt 和 anotherInt 的值。
输入输出参数是函数对函数体外产生影响的另一种方式。

4. 函数类型

每个函数都有种特定的函数类型，函数的类型由函数的参数类型和返回类型组成。

func addTwoInts(_ a: Int, _ b: Int) -> Int {
    return a + b
}
func multiplyTwoInts(_ a: Int, _ b: Int) -> Int {
    return a * b
}

这两个函数的类型是 (Int, Int) -> Int，可以解读为：
“这个函数类型有两个 Int 型的参数并返回一个 Int 型的值”。

func printHelloWorld() {
    print("hello, world")
}

这个函数的类型是：() -> Void，或者叫“没有参数，并返回 Void 类型的函数”。

4.1 使用函数类型

在 Swift 中，使用函数类型就像使用其他类型一样。

//  定义一个类型为函数的常量或变量，并将适当的函数赋值给它：
var mathFunction: (Int, Int) -> Int = addTwoInts
print("Result: \(mathFunction(2, 3))")  // Prints "Result: 5"

//  有相同匹配类型的不同函数可以被赋值给同一个变量，就像非函数类型的变量一样：
mathFunction = multiplyTwoInts
print("Result: \(mathFunction(2, 3))")  // Prints "Result: 6"

//  像其他类型一样，当赋值一个函数给常量或变量时，你可以让 Swift 来推断其函数类型：
let anotherMathFunction = addTwoInts    // anotherMathFunction 被推断为 (Int, Int) -> Int 类型

”定义一个叫做 mathFunction 的变量，类型是‘一个有两个 Int 型的参数并返回一个 Int 型的值的函数’，并让这个新变量指向 addTwoInts 函数”。
addTwoInts 和 mathFunction 有同样的类型，所以这个赋值过程在 Swift 类型检查（type-check）中是允许的。

4.2 函数类型作为参数类型

可以用 (Int, Int) -> Int 这样的函数类型作为另一个函数的参数类型。这样你可以将函数的一部分实现留给函数的调用者来提供。

/*  它有三个参数：
    第一个参数叫 mathFunction，类型是 (Int, Int) -> Int，你可以传入任何这种类型的函数；
    第二个和第三个参数叫 a 和 b，它们的类型都是 Int，这两个值作为已给出的函数的输入值。
*/
func printMathResult(_ mathFunction: (Int, Int) -> Int, _ a: Int, _ b: Int) {
    print("Result: \(mathFunction(a, b))")
}
printMathResult(addTwoInts, 3, 5)
// 打印“Result: 8”

printMathResult( _ : _ : _ : ) 被调用时，它被传入 addTwoInts 函数和整数 3 和 5。它用传入 3 和 5 调用 addTwoInts，并输出结果：8。
printMathResult( _ : _ : _ : ) 函数的作用就是输出另一个适当类型的数学函数的调用结果。它不关心传入函数是如何实现的，只关心传入的函数是不是一个正确的类型。这使得 printMathResult( _ : _ : _ : ) 能以一种类型安全（type-safe）的方式将一部分功能转给调用者实现。

4.3 函数类型作为返回类型

可以用函数类型作为另一个函数的返回类型。你需要做的是在返回箭头（->）后写一个完整的函数类型。

func stepForward(_ input: Int) -> Int { //  stepForward(_:) 函数返回一个比输入值大 1 的值
    return input + 1
}
func stepBackward(_ input: Int) -> Int { // stepBackward(_:) 函数返回一个比输入值小 1 的值。
    return input - 1
}
func chooseStepFunction(backward: Bool) -> (Int) -> Int { //    chooseStepFunction(backward:) 的函数，它的返回类型是 (Int) -> Int 类型的函数
    return backward ? stepBackward : stepForward    //  chooseStepFunction(backward:) 根据布尔值 backwards 来返回 stepForward(_:) 函数或 stepBackward(_:) 函数.
}

var currentValue = 3
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)   // moveNearerToZero 现在指向 stepBackward() 函数。

currentValue 的初始值是 3，这意味着 currentValue > 0 为真（true），这将使得 chooseStepFunction(_ : ) 返回 stepBackward(_ : ) 函数。一个指向返回的函数的引用保存在了 moveNearerToZero 常量中。

moveNearerToZero 指向了正确的函数，它可以被用来数到零：

print("Counting to zero:")
// Counting to zero:
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// 3...
// 2...
// 1...
// zero!

5. 嵌套函数

到目前为止本章中你所见到的所有函数都叫全局函数（global functions），它们定义在全局域中。
也可以把函数定义在别的函数体中，称作嵌套函数（nested functions）。
默认情况下，嵌套函数是对外界不可见的，但是可以被它们的外围函数（enclosing function）调用。一个外围函数也可以返回它的某一个嵌套函数，使得这个函数可以在其他域中被使用。
用返回嵌套函数的方式重写 chooseStepFunction(backward:) 函数：

func chooseStepFunction(backward: Bool) -> (Int) -> Int {
    func stepForward(input: Int) -> Int { return input + 1 }
    func stepBackward(input: Int) -> Int { return input - 1 }
    return backward ? stepBackward : stepForward
}
var currentValue = -4
let moveNearerToZero = chooseStepFunction(backward: currentValue > 0)
// moveNearerToZero now refers to the nested stepForward() function
while currentValue != 0 {
    print("\(currentValue)... ")
    currentValue = moveNearerToZero(currentValue)
}
print("zero!")
// -4...
// -3...
// -2...
// -1...
// zero

dev.xue

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Swift-函数，定义、调用、返回值、参数、隐式返回、可变参数、嵌套函数

1. 函数的定义与调用以 func 作为前缀。函数返回类型： ->（一个连字符后跟一个右尖括号）后跟返回类型的名称的方式来表示。func greet(person: String) -> String { // 函数的名字是 greet(person:) let greeting = "Hello, " + person + "!" ret...
复制链接

扫一扫

专栏目录