在上一篇Swift函数文章中，我们了解了函数。现在，我们来看看不同的方式和类型，我们可以创建Swift在一个函数的函数 ，即处理输入和输出。

没有参数且没有返回值的函数

这些类型的函数不接受任何输入和返回值。

func funcname() {
    //statements
}
OR
func funcname() -> () {
    //statements
}
OR
func funcname() -> Void {
    //statements
}

以上所有语法对于创建不带参数且不返回值的函数都是有效的。

上面的语法func funcname() -> ()也等效于func funcname() -> Void因为Void只是()的类型别名。您可以访问Swift Typealias来了解更多信息。

示例1：没有传递参数，也没有返回值

func greetUser() {
    print("Good Morning!")
}
greetUser()

当您运行上述程序时，输出将是：

Good Morning!

没有参数但返回值的函数

这些类型的函数不接受任何输入参数，而是返回一个值。要添加返回类型，您需要添加箭头( -> )和返回类型。

func funcname() -> ReturnType {
    //statements
    return value
}

示例2：没有传递参数但返回值

func greetUser() -> String {
    return "Good Morning!"
}
let msg = greetUser()
print(msg)

当您运行上述程序时，输出将是：

Good Morning!

在上面的程序中，您已将return Type定义为String 。现在，该语句必须从函数内部的语句中返回一个字符串 ，否则您将得到一个错误。

return关键字将程序的控制权从函数主体转移到函数调用。如果需要从函数返回值，请在return关键字后添加值。

return "Good Morning!"语句从函数返回String类型的值。请注意，返回值的类型和值必须匹配。

您还可以将返回值分配给变量或常量。 let msg =将返回值分配给常量msg 。因此，语句print(msg)输出早安！在控制台中。

如果您想忽略该值，则可以简单地使用_作为let _ = 。

有参数但无返回值的函数

参数用于在函数输入。该参数包含一个参数名称和类型后面跟着冒号( : )。这些类型的函数采用输入参数，但不返回值。

func funcname(parameterName:Type) {
    //statements
}

示例3：参数传递但没有返回值

func greetUser(msg:String) {
    print(msg)
}
greetUser(msg: "Good Morning!")

当您运行上述程序时，输出将是：

Good Morning!

在上面的程序中，该函数接受String类型的单个参数。该参数只能在函数内部使用。 msg是参数的名称。

您可以通过传递一个带有参数名称为greetUser(msg: "Good Morning!")的字符串值来调用该函数 。 msg参数名称仅在函数 greetUser()内部可见。

因此，语句print(msg)输出早安！在控制台中。

具有参数和返回值的功能

这些类型的函数使用参数并返回值。

func funcname(parameterName:Type) -> ReturnType {
    //statements
}

示例4：传递参数并返回值

func greetUser(name:String) -> String {
    return "Good Morning! " + name
}
let msg = greetUser(name: "Jack")
print(msg)

当您运行上述程序时，输出将是：

Good Morning! Jack

在上述程序中，该函数接受String类型的单个参数，并且还返回值Good Morning！类型为String Jack 。

具有多个参数和多个返回值的函数

这些类型的函数采用以逗号分隔的多个参数，并且还返回多个值。您可以使用元组在Swift中返回多个值。请参阅Swift Tuples了解更多信息。

func funcname(parameterName:Type, parameterName2:Type ,...) -> (ReturnType, ReturnType...) {
    //statements
}

示例5：传递了多个参数和多个返回值

func greetUser(name:String, age:Int) -> (String, Int) {
    
    let msg = "Good Morning!" + name
    var userage = age
    if age < 0 {
            userage = 0
    }
    return (msg, userage)
}
let msg = greetUser(name: "Jack", age: -2)
print(msg.0)
print("You have \(msg.1) coins left")

当您运行上述程序时，输出将是：

Good Morning!Jack
You have 0 coins left

在上面的程序中， 函数 greetUser()接受String和Int类型的多个参数。该函数还以String和Int类型的元组返回多个值。

要访问每个返回值，我们使用索引位置0、1…在这里，我们使用msg.0访问Good Morning！Jack ，使用msg.1访问0 。

有时使用索引位置可能是不直观和不可读的。我们可以通过给名称指定返回值来优雅地解决此问题。上面的程序也可以如下重写。

示例6：具有名称的多个返回值

func greetUser(name:String, coins:Int) -> (name:String, coins:Int) {
    
    let msg = "Good Morning!" + name
    var userCoins = coins
    if coins < 0 {
        userCoins = 0
    }
    return (msg, userCoins)
}

let msg = greetUser(name: "Jack",coins: -2)
print(msg.name)
print("You have \(msg.coins) coins left")

在此程序中，返回类型为元组，其中包含具有该类型的变量名称。这样做的主要优点是可以使用变量名msg.name和msg.coins代替msg.0和msg.1访问结果。

带参数标签的功能

定义接受输入的函数 ，可以在参数名称的帮助下定义输入名称。但是，还有另一种名称可以与参数名称一起使用，称为参数标签。

使用参数标签允许函数在表现方式调用，句子状的方式，同时还提供了一个函数体是可读的，明确的意图。

每个函数参数都具有参数标签和参数名称。默认情况下，参数使用其参数名称作为其参数标签。但是，如果您明确定义了参数名称，则在调用函数时会使用参数标签。

带参数标签的函数的语法为

func funcname(argumentLabel parameterName:Type)-> Return Type {
    //statements
}

让我们在下面的示例中看到这一点。

示例7：不带参数标签的函数

func sum(a:Int, b:Int) -> Int {
    
    return a + b
}
let result = sum(a: 2, b: 3)
print("The sum is \(result)")

当您运行上述程序时，输出将是：

The sum is 5

在上面的示例中，我们没有指定参数标签，因此在调用函数 ，它将默认参数名称a和b作为参数标签。

您可能会注意到，在调用函数时， 函数调用不是表达性/句子。如果您可以将函数调用为：

let result = sum(of: 2, and: 3)

现在让我们将函数更改为：

示例8：具有更好的函数调用但不作为参数名称的函数

func sum(of:Int, and:Int) -> Int {

    return of + and
}
let result = sum(of: 2, and: 3)
print("The sum is \(result)")

现在，方法调用是可表达的。但是，现在我们必须使用＆的参数名称， 并以return of + and找到两个数字的和。现在，这使得函数体不可读。 的使用和B的，而不是与和会使函数体中更有意义。

为此，我们必须将参数标签明确定义为：

示例9：带有参数标签的函数

func sum(of a :Int, and b:Int) -> Int {

    return a + b
}
let result = sum(of: 2, and: 3)
print("The sum is \(result)")

在上述程序中，该函数接受Int类型的两个参数。的函数调用使用的 ＆参数标签和这是有意义的，而调用该函数为sum(of: 2, and: 3)而不是sum(a: 2, b: 3)

此外， 函数体使用参数名称a和b，而不是与和这也使得更多的意义，而应用的操作。

您还可以通过在参数名称前写一个_来省略参数标签。

func sum(_ a :Int, _ b:Int) -> Int {

    return a + b
}
let result = sum(2, 3)
print("The sum is \(result)")

具有默认参数值的功能

您可以为函数中的任何参数提供默认值， 函数是在该参数的类型之后为该参数分配一个值。提供默认参数可以使您在调用函数忽略该参数。

如果在调用函数时未将值传递给参数，则使用其默认值。但是，如果在调用时将值显式传递给参数，则使用指定的值。

func funcname(parameterName:Type = value) -> Return Type {
    //statements
}

示例10：具有默认参数值的函数

func sum(of a :Int = 7, and b:Int = 8) -> Int {

    return a + b
}
let result1 = sum(of: 2, and: 3)
print("The sum is \(result1)")

let result2 = sum(of: 2)
print("The sum is \(result2)")

let result3 = sum(and: 2)
print("The sum is \(result3)")

let result4 = sum()
print("The sum is \(result4)")

当您运行上述程序时，输出将是：

The sum is 5
The sum is 10
The sum is 9
The sum is 15

在上述程序中， 函数 sum(of a :Int = 7 , and b:Int = 8) -> Int接受两个类型为Int参数，但还指定了参数a = 7和b = 8.的默认值b = 8.

如果在函数调用中将值作为参数传递为sum(of: 2, and: 3)则使用2和3代替参数默认值。

但是，如果不将参数值作为sum()传递，则将默认值7和8用作参数值。

具有可变参数的功能

可变参数可以接受零个或多个特定类型的值。您可以通过在参数的类型名称后插入三个句点字符 (…)来指定可变参数。

当需要在调用函数时将各种数量的输入值传递给参数时，通常使用可变参数。例如，数字列表，字母列表等。

具有可变参数的函数的语法为：

func funcname(parameterName:Type...) -> Return Type {
    //statements
}

示例11：具有可变参数的函数

func sum(of numbers:Int...) {
    var result = 0
    for num in numbers {
        result += num
    }
    print("The sum of numbers is \(result)")
}
sum(of: 1, 2, 3, 4, 5, 6, 7, 8)

在上述程序中， 函数 sum(of numbers:Int...) ofnumbers sum(of numbers:Int...)接受类型为Int的可变参数。可变参数可以接受多个以逗号分隔的值作为sum(of: 1, 2, 3, 4, 5, 6, 7, 8) 。

作为可变参数传递的值1、2、3、4、5、6、7、8在函数体内可以作为Int类型的数组使用。因此，我们可以像for num in numbers值中应用for-in循环。

当您运行上述程序时，输出将是：

The sum of numbers is 36

注意：内置的print() 函数的 Swift也接受Any类型的可变参数。

Any表示Swift中任何数据类型，例如Int ， Float ， Double ， String等。

具有输入输出参数的功能

定义函数参数时，无法在体内修改函数参数。因此，默认情况下它们是常量。让我们在示例中看一下：

func process(name:String) {
    if name == ""{
        name = "guest"
    }
}

上面的程序会导致编译时错误，因为您无法更改参数的值。

如果要让函数修改参数值，则需要将参数定义为in-out参数。您可以通过将inout关键字放在参数类型的前面来编写in-out参数。

在幕后，一个在出参数具有被传递到该函数的值，由函数修改，并且被传递回该函数的，以取代原来的值。因此， 函数调用中传递的值不能为常数。您必须将其声明为变量。

具有inout参数的函数的语法为：

func funcname(parameterName:inout Type) -> Return Type {
    //statements
}

示例12：带有in out参数的函数

func process(name:inout String) { 
    if name == ""{
        name = "guest"
    }
}
var userName = ""
process(name: &userName)
print(userName)

当您运行上述程序时，输出将是：

guest

在上面的程序中，我们声明了一个接受inout参数名称的函数 ，以便可以在函数体内更改/更改参数。

在将参数传递给in-out参数时，必须在变量名称前直接使用ampersand (&) ，以便可以通过函数对其进行修改。