Swift - 函数

函数是一组组织在一起的语句，用于执行特定任务。Swift 函数可以像简单的 C 函数一样简单，也可以像 Objective-C 语言函数一样复杂。它允许我们在函数调用中传递局部和全局参数值。此外，我们可以在另一个函数内部定义函数，以将其功能封装在另一个函数中。

函数在代码结构化、模块化和提高代码可读性方面发挥重要作用。它们还提供了诸如参数标签、默认参数值、可变参数和多种返回类型等各种特性。

Swift 中的函数定义

在 Swift 中，函数使用 "func" 关键字定义。当新定义一个函数时，它可以接受一个或多个值作为输入“参数”传递给函数，并在主体中处理这些函数，然后将值作为输出“返回类型”返回给函数。

每个函数都有一个函数名，用于描述函数执行的任务。要使用函数，您需要使用其名称“调用”该函数，并传递与函数参数类型匹配的输入值（称为 arguments）。函数参数也被称为“tuples”。

函数的 arguments 必须始终按照函数参数列表的相同顺序提供，返回值后跟 ->。

语法

以下是创建函数的语法 −

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

示例

Swift 程序演示如何创建函数。

// 有返回类型的函数
func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name:"About Functions"))

输出

它将产生以下输出 −

First Program
About Functions

Swift 中调用函数

调用函数意味着执行函数内部的语句集。我们可以通过函数名调用函数，在调用时必须提供所有 arguments（如果有）。

假设我们定义了一个名为 'display' 的函数，例如，为了显示数字，首先用持有 integer 数据类型的参数 'no1' 初始化名为 'display' 的函数。

然后，将参数 'no1' 分配给参数 'a'，此后 'a' 将指向相同的数据类型 integer。现在参数 'a' 返回给函数。这里 display() 函数将持有 integer 值，并在每次调用函数时返回 integer 值。

语法

以下是调用函数的语法 −

funcName(parameters)

示例

Swift 程序演示如何调用函数。

// 创建函数
func display(no1: Int) -> Int {
   let a = no1
   return a
}

// 调用函数
print(display(no1: 100))
print(display(no1: 200))

输出

它将产生以下输出 −

100
200

Swift 中函数参数的类型

参数是在函数声明中指定的变量，用于在调用函数时获取输入。或者，它们允许我们在调用函数时向函数传递值，并对这些值执行操作。它们总是与标签、类型和值（如果有）一起在函数内部指定。Swift 函数支持以下类型的参数 −

• 常规参数
• 可变参数
• 输入输出参数

让我们详细讨论所有类型的参数。

常规参数

常规参数是函数中最常用的参数类型。它们允许我们根据指定的值执行基本操作。一个函数可以有一个或多个常规参数。每个常规参数都有其参数标签、显式类型，并且它们由逗号分隔。

我们也可以在常规参数中指定默认值，这意味着如果我们在调用该函数时省略该参数，则该参数中的默认值将被使用。

语法

以下是常规参数的语法 −

func funcname(name1: Type, name2:Type = defualtValue) -> returntype {
   Statement
   return value
}

示例

Swift 程序演示如何创建带有常规参数的函数。

// 创建带有常规参数和默认值的函数
func Sum(num1: Int, num2: Int = 2) -> Int {
   var result = 0
   result = num1 + num2
   return result
}

// 调用函数 
print("Sum 1:", Sum(num1: 10))
print("Sum 2:", Sum(num1: 20, num2: 12))

输出

它将产生以下输出 −

Sum 1: 12
Sum 2: 32

可变参数

Swift 提供了一种特殊类型的参数，称为可变参数。可变参数允许我们在函数中接受相同类型的多个输入值。这种参数在我们要向函数传递任意数量的相同类型值而无需指定确切数量时非常有用。

一个函数可以包含多个可变参数，在第一个可变参数之后，后续的可变参数必须包含参数标签以区分它们。传递到可变参数中的值在函数中以数组形式可用。可变参数不能标记为 inout。

语法

以下是可变参数的语法 −

func funcname(_name1: Type, name2:Type, name3: Type) -> returntype
{
   Statement
   return value
}

示例

Swift 程序演示如何创建带有可变参数的函数。

// 创建带有可变参数的函数 
func Product(_ num: Int...) -> Int {

   var result = 1
   for x in num{
      result *= x
   }
   return result
}

// 调用函数并传递相同类型的多个值
print("Product:", Product(10, 20, 30))

输出

它将产生以下输出 −

Product: 6000

输入输出参数

Swift 中的输入输出参数提供了即使在函数调用后修改其值，仍然保留参数值功能。在函数参数定义的开头，声明 'inout' 关键字来保留成员值。

它得名 'inout'，因为其值被 'in' 传递到函数中，其值被函数体访问和修改，然后 'out' 返回函数以修改原始参数。输入输出参数不包含默认值。

只有变量被作为输入输出参数的参数传递，因为只有它们的值在函数内部和外部被修改。因此，无需将字符串和字面量声明为输入输出参数。变量名前面的 '&' 表示我们正在将参数传递给输入输出参数。

语法

以下是输入输出参数的语法 −

func funcname(_name1: inout Type, _name2: inout Type) -> returntype
{
   Statement
   return value
}

示例

Swift 程序演示如何创建带有输入输出参数的函数。

// 交换两个值的函数
func swap(_ x: inout Int, _ y: inout Int) {
   let temp = x
   x = y
   y = temp
}

var p = 15
var q = 10

print("Before swapping: p = \(p), q = \(q)")

swap(&p, &q)

print("After swapping: p = \(p), q = \(q)")

输出

它将产生以下输出 −

Before swapping: p = 15, q = 10
After swapping: p = 10, q = 15

Swift 中的函数参数标签和参数名

函数可以为其参数和形参指定标签和名称。这些标签和名称为参数和形参提供了清晰且描述性的上下文。参数名用于函数的声明，而参数标签则在调用函数时使用。

默认情况下，参数标签和参数名是相同的，但多个参数可以具有相同的或唯一的参数标签。参数名应该是唯一的，以便函数能够轻松区分它们。我们还可以通过在参数名前放置下划线（_）来省略参数标签。

语法

以下是参数标签和参数名的语法 −

// 带参数标签的参数名
func funcname(argumentLabel parameterName: Type, parameterName: Type) -> returntype {
   Statement
   return value
}
funcname(name1:value, name2: value)

// 不带参数标签的参数名
func funcname(_name1: Type, _name2: Type) -> returntype {
   Statement
   return value
}
funcname(value1, value2)

示例

Swift 程序演示如何在函数中指定参数名和参数标签。

// 函数 1：带参数名和参数标签
func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   return res
}
print("Power:", pow(firstArg:5, secondArg:3))

// 函数 2：带参数名但不带参数标签
func product(_ a: Int,  b: Int) -> Int {
   let res = a * b
   return res
}
print("Product:", product(5, b:3))

输出

它将产生以下输出 −

Power: 125
Product: 15

Swift 中的参数和返回值

Swift 提供了灵活的函数参数及其返回值，从简单值到复杂值。我们可以创建各种形式的函数，例如 −

• 带参数的函数

• 不带参数的函数

• 带返回类型的函数

• 不带返回类型的函数

• 带可选返回类型的函数

让我们详细讨论所有形式的函数。

带参数的函数

通过将参数值传递给函数体来访问函数。我们可以在函数内部传递单个或多个参数值，每个参数都有自己的标签，以便编译器能够识别哪个对应哪个参数。

语法

以下是带参数的函数语法 −

func funcname(para1: Type, para2: Type) -> datatype {
   return datatype
}

示例

Swift 程序，创建带参数的函数。

// 带两个参数的函数
func mult(no1: Int, no2: Int) -> Int {
   return no1 * no2
}

// 调用函数
print(mult(no1: 2, no2: 20))
print(mult(no1: 3, no2: 15))
print(mult(no1: 4, no2: 30))

输出

它将产生以下输出 −

40
45
120

不带参数的函数

我们也可以定义不带任何参数的函数。此类函数在需要封装不依赖任何外部输入的代码块时非常有用。

语法

以下是不带参数的函数语法 −

func funcname() -> datatype {
   return datatype
}

示例

Swift 程序，创建不带参数的函数。

// 不带参数的函数
func votersname() -> String {
   return "Alice"
}

// 调用函数
print(votersname()) 

输出

它将产生以下输出 −

Alice

带返回值的函数

函数还用于返回 string、integer 和 float 数据类型的返回值。它可以返回单个或多个值。如果函数返回多个值，则使用 tuple 返回多个值。

语法

以下是带返回值的函数语法 −

func funcname(para1: Type, para2: Type) -> datatype {
   return datatype
}

示例

Swift 程序，创建返回值的函数。

// 函数用于找出给定数组中的最大值和最小值 
func ls(array: [Int]) -> (large: Int, small: Int) { 
   var lar = array[0]
   var sma = array[0]
   
   // 将值与其前一个值进行比较
   for i in array[1..<array.count] 
   {
   
      // 如果值小于前一个值，则存储在 'sma' 参数中
      if i < sma {
         sma = i
      }
      // 否则存储在 'lar' 参数中
      else if i > lar {
         lar = i
      }
   }
   
   // 使用 tuple 返回多个值
   return (lar, sma)
}

let num = ls(array: [40, 12, -5, 78, 98])
print("Largest number is: \(num.large) and smallest number is: \(num.small)")

输出

它将产生以下输出 −

Largest number is: 98 and smallest number is: -5

不带返回值的函数

某些函数可能在函数内部声明参数，但不带任何返回值

语法

以下是不带返回类型的函数语法 −

func funcname(para1: Type, para2: Type){
   return datatype
}

示例

Swift 程序，创建不返回值的函数。

// 带参数但无返回类型的函数
func sum(a: Int, b: Int) {
   let a = a + b
   let b = a - b
   print(a, b)
}

sum(a: 20, b: 10)
sum(a: 40, b: 10)
sum(a: 24, b: 6)

输出

它将产生以下输出 −

30 20
50 40
30 24

带可选返回类型的函数

Swift 引入了 'optional' 特性，通过安全措施来消除问题。'Optional' 用于检查 'nil' 或垃圾值，从而节省大量调试时间，使代码更高效且易于用户阅读。

例如，我们声明函数返回值类型为 integer，但如果函数返回 string 值或 nil 值会发生什么。在这种情况下，编译器将返回错误值。'optional' 就是为了解决这些问题而引入的。

Optional 函数将采用两种形式 'value' 和 'nil'。我们将使用保留字符 '?' 来标记 'Optionals'，以检查 tuple 是返回值为还是 nil 值。

示例

Swift 程序，创建返回 optional 类型的函数。

// 带可选返回类型的函数
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)
}

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

函数类型

在 Swift 中，function type 用于表示函数的类型以及其参数类型和返回类型。function type 允许我们以类型安全的方式创建、传递和使用函数，作为变量或参数。参数类型表示将存储在函数中的参数类型，而返回类型表示函数将返回的值类型。

示例

Swift 程序演示 function type。

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}
print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2:6))

输出

它将产生以下输出 −

2
6

将函数赋值给变量

Swift 中的函数是 first-class citizens。因此，我们可以将函数赋值给变量，就像将值赋值给变量一样。将函数赋值给变量后，该变量将持有该函数的引用。

语法

将函数赋值给变量的语法如下 −

var addition: (Int, Int) -> Int = sum

这里 sum 是一个函数名，具有整数变量 'a' 和 'b'，现在被声明为变量 addition 的函数名。此后，addition 和 sum 函数都具有相同数量的整数数据类型的参数，并且都返回整数值作为引用。

示例

Swift 程序演示如何将函数赋值给变量。

// 函数
func sum(a: Int, b: Int) -> Int {
   return a + b
}

// 将函数赋值给变量
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

输出

它将产生以下输出 −

Result: 129

函数类型作为参数类型

在 Swift 中，我们可以将 function type 用作另一个函数的参数类型，这意味着我们可以将一个函数作为参数传递给另一个函数。

示例

Swift 程序演示如何将函数作为参数传递给另一个函数。

// 函数类型是 (Int, Int) -> Int
func add(_ x: Int, _ y: Int) -> Int {
   return x + y
}

// 函数类型作为参数
func Display(_ myOperation: (Int, Int) -> Int, _ p: Int, _ q: Int) -> Int {
   return myOperation(p, q)
}

// 将函数作为参数传递
let sum = Display(add, 5, 7)

print("Sum: \(sum)")       

输出

它将产生以下输出 −

Sum: 12

函数类型作为返回类型

在 Swift 中，我们可以将 function type 用作另一个函数的返回类型，这意味着一个函数可以从另一个函数返回。

示例

Swift 程序演示一个函数如何返回另一个函数。

// 函数类型是 (Int, Int) -> Int
func add(_ x: Int, _ y: Int) -> Int {
   return x + y
}

// Display() 函数将返回 add() 函数
func Display()->(Int, Int) -> Int {
   return add
}

let myFunc = Display()
let result = myFunc(9, 2)

print("Sum: \(result)")

输出

它将产生以下输出 −

Sum: 11