Swift--方法（函数）

Posted 2020-10-15 一人前行

方法是执行特殊任务的自包含代码块。你可以给方法名字来表示它的功能，而且在需要的时候调用这个名字的方法来执行它的任务。

 

Swift方法的语法表达很灵活，从类似c的没有参数名的方法到oc复杂的带有名字和参数的方法。参数在简单方法的调用中可以提供默认的初始值，也可以传入一个变量的参数，当方法执行完后可以修改这个参数。

 

每个方法在Swift中都有一个类型，其中包括参数类型和返回类型。你可以享其他任何在Swift类型一样使用这些类型，它可以让方法更容易的为作为另外一个方法的一个参数值，从方法的返回值获取返回值。函数也可以写在其他的函数中，以便在嵌套的函数范围内封装有效的功能。

 

1.函数的声明与调用

当你定义一个函数的时候，你可能定义一个或者多个名字，函数的传入值的类型称为参数。你也可以选择定义一个方法执行后可能返回值的类行，称为返回值。

 

每个函数的名字最好能描述出它的功能。使用函数的时候，调用这个函数的名字并出入一个输入值（及我们所称的参数），这个参数的类型要与这个函数的参数类型一致。函数的参数必须始终以与函数的参数列表相同的顺序提供。

 

下面的例子定义了一个greet(person:),该函数输入一个人的名字，返回一个对这个人的问候字符串。为了实现这个例子，可以定义输入的参数，参数名为person、类型为String；以及返回一个String类型的返回值。

func greet(person: String) -> String {
    let greeting = "Hello, " + person + "!"
    return greeting
}

 定义一个函数时把所有这些都组合一起，其中前缀用func 关键字。你定义函数返回值时用return的箭头“->”,后面跟着类型的名字返回。

这个函数的定义描述了它的功能是什么，接收什么参数，以及函数执行后返回的参数。这个定义可以让你在代码中任何地方更容易清楚的调用。

 

2.函数的参数与返回值

Swit函数中的参数和返回值是相当灵活的。你可以用从一个功能函数带一个没有命名的参数到 带有表达函数的参数和不同可选的参数的复杂函数定义一切。

（1）没有参数的函数

函数不需要定义输入参数。如下的这个函数没有带参数，每次调用该函数的时候，返回相同的字符串信息。

func sayHelloWorld() -> String {
    return "hello, world"
}
print(sayHelloWorld())
// Prints "hello, world"

 函数定义的时候仍然需要在函数名后面加上括号，尽管括号里面并没有参数。当函数调用的时候，函数名后面把空括号写上。

（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))
// Prints "Hello again, Tim!"

 （3）函数不带返回值

函数不需要定义一个返回类型。

func greet(person: String) {
    print("Hello, \(person)!")
}
greet(person: "Dave")
// Prints "Hello, Dave!"

 因为不需要返回一个值，这个函数在定义的时候不包含返回箭头（->）或者返回值。

注意：严格的说，greet(person: String)的函数也有返回值，尽管它的返回并没有定义。函数没有定义返回值的类型时通常返回的是一个特殊类型值Void。它是一个简单的空元组，可以用“（）”表示。

 

调用一个函数的时候，它的返回值可以忽略。

func printAndCount(string: String) -> Int {
    print(string)
    return string.count
}
func printWithoutCounting(string: String) {
    let _ = printAndCount(string: string)
}
printAndCount(string: "hello, world")
// prints "hello, world" and returns a value of 12
printWithoutCounting(string: "hello, world")
// prints "hello, world" but does not return a value

 第一个方法 printAndCount(string:，打印一个字符串，然后返回Int类型的字符串个数。第二个方法 printWithoutCounting(string:)调用了第一个方法，但是忽略的它的返回值。当调用第二个函数的时候，第一个函数的信息依然打印，但是它的返回值并没有用到。

（4）函数带有多个返回值

你可以用元组的返回类型作为一个函数的多个返回值。

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)
}

 minMax(array:)这个函数返回一个带有两个Int值的元组。

因为元组中的成员值被命名为函数返回值的一部分，它们可以通过点语法来获取到最小和最大值。

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

 注意：tuple的成员不需要在tuple从函数返回的时候被命名，因为它们的名称已经被指定为函数的返回类型的一部分。

 

（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)")
}
// Prints "min is -6 and max is 109"

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

每个函数的参数都有参数的标签和参数名称。参数标签在函数调用时很有用的。在函数的实现用方法名会用得到。通常，参数用它们的参数名作为它们参数标签。

func someFunction(firstParameterName: Int, secondParameterName: Int) {
    // In the function body, firstParameterName and secondParameterName
    // refer to the argument values for the first and second parameters.
}
someFunction(firstParameterName: 1, secondParameterName: 2)

 所有的参数必须用不一样的名字。尽管，多个参数可能会有相同的参数标签，唯一的参数标签可以帮助你的代码更加易读。

（1）指定参数标签

你可以在参数名字面前写上参数标签，用 空格分隔开。

func someFunction(argumentLabel parameterName: Int) {
    // In the function body, parameterName refers to the argument value
    // for that parameter.
}

 当下是一个关于greet:(person:)的方法，输入一个人的名字还有家乡，返回一个问候语：

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

 标签的使用使得函数像表达式一样调用，类似于句子，同时还使得函数体更容易解读、更清晰。

（2）省略参数标签

如果你的参数不需要参数标签，用下划线代替参数的参数标签。

func someFunction(_ firstParameterName: Int, secondParameterName: Int) {
    // In the function body, firstParameterName and secondParameterName
    // refer to the argument values for the first and second parameters.
}
someFunction(1, secondParameterName: 2)

 如果一个参数有参数标签，当你调用函数的时候，参数必须被标记。

（3）默认参数值

你可以在函数中为任何的参数定义一个默认的值，通过在参数类型的后面为参数分配一个值。如果你设置了默认的值，当你调用函数的时候，可以省略参数。

func someFunction(parameterWithoutDefault: Int, parameterWithDefault: Int = 12) {
    // If you omit the second argument when calling this function, then
    // the value of parameterWithDefault is 12 inside the function body.
}
someFunction(parameterWithoutDefault: 3, parameterWithDefault: 6) // parameterWithDefault is 6
someFunction(parameterWithoutDefault: 4) // parameterWithDefault is 12

 在函数的参数列表开始时，在具有默认值的参数之前，放置没有默认值的参数。没有默认值的参数通常对函数的意义更为重要——首先编写它们使识别相同的函数被调用变得更加容易，无论是否省略了默认参数。