Swift - 函数

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

函数在代码结构、模块化和提高代码可读性方面发挥着重要作用。它们还提供各种功能，例如参数标签、默认参数值、可变参数和多个返回值。

Swift 中的函数定义

在 Swift 中，函数由“func”关键字定义。当新定义函数时，它可以将一个或多个值作为输入“参数”传递给函数，并且它将在主体中处理函数并将值作为输出“返回值”传递回函数。

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

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

语法

以下是创建函数的语法：

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

示例

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

// Function with return type
func student(name: String) -> String {
   return name
}

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

输出

它将产生以下输出：

First Program
About Functions

在 Swift 中调用函数

调用函数意味着执行函数内部的一组语句。我们可以通过函数的名称来调用函数，并且在调用时必须提供所有参数（如果可用）。

让我们假设我们定义了一个名为“display”的函数，例如，考虑一个函数名称为“display”的函数，首先用参数“no1”（它持有整数数据类型）初始化。

然后将参数“no1”赋值给参数“a”，此后“a”将指向相同的数据类型整数。现在参数“a”被返回到函数。此处，display() 函数将保存整数值并在每次调用函数时返回整数值。

语法

以下是调用函数的语法：

funcName(parameters)

示例

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

// Creating function
func display(no1: Int) -> Int {
   let a = no1
   return a
}

// Calling function
print(display(no1: 100))
print(display(no1: 200))

输出

它将产生以下输出：

100
200

Swift 中的函数参数类型

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

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

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

常规参数

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

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

语法

以下是常规参数的语法：

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

示例

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

// Creating function with regular parameters and default value
func Sum(num1: Int, num2: Int = 2) -> Int {
   var result = 0
   result = num1 + num2
   return result
}

// Calling function 
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 程序演示如何创建具有可变参数的函数。

// Creating function with variadic parameter 
func Product(_ num: Int...) -> Int {

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

// Calling function and passing multiple values of the same type
print("Product:", Product(10, 20, 30))

输出

它将产生以下输出：

Product: 6000

输入输出参数

Swift 中的输入输出参数提供了一种功能，即使在函数调用后修改了参数值，也能保留参数值。在函数参数定义的开头，声明“inout”关键字以保留成员值。

它派生关键字“inout”，因为它的值被“传入”函数，并且它的值被函数体访问和修改，并且它被“传出”函数以修改原始参数。输入输出参数不包含默认值。

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

语法

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

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

示例

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

// Function to swap two values
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 中的函数参数标签和参数名称

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

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

语法

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

// Parameter name With argument label
func funcname(argumentLabel parameterName: Type, parameterName: Type) -> returntype {
   Statement
   return value
}
funcname(name1:value, name2: value)

// Parameter name without argument label
func funcname(_name1: Type, _name2: Type) -> returntype {
   Statement
   return value
}
funcname(value1, value2)

示例

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

// Function 1 with parameter names and argument label
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))

// Function 2 with parameter names and without argument label
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 程序创建带参数的函数。

// Function with two parameters
func mult(no1: Int, no2: Int) -> Int {
   return no1 * no2
}

// Calling function
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 程序创建无参数的函数。

// Function without parameters
func votersname() -> String {
   return "Alice"
}

// Calling function
print(votersname())

输出

它将产生以下输出：

Alice

带返回值的函数

函数也用于将字符串、整数和浮点数数据类型值作为返回值类型返回。它可以返回单个或多个值。如果函数返回多个值，则它将使用元组返回多个值。

语法

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

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

示例

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

// Function to find out the largest and smallest number in a given array 
func ls(array: [Int]) -> (large: Int, small: Int) { 
   var lar = array[0]
   var sma = array[0]
   
   // Comparing value with its previous value
   for i in array[1..<array.count] 
   {
   
      // If the value is lesser than the previous one it is stored in 'sma' argument
      if i < sma {
         sma = i
      }
      // Otherwise it is stored in 'lar' argument
      else if i > lar {
         lar = i
      }
   }
   
   // Returning multiple values using 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 程序创建不返回值的函数。

// Function with parameters but no return type
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 引入了“可选”功能，通过引入安全措施来解决问题。“可选”用于检查“nil”或垃圾值，从而节省了大量调试时间，并使代码对用户高效且易读。

例如，我们声明函数值返回值类型为整数，但当函数返回字符串值或 nil 值时会发生什么？在这种情况下，编译器将返回错误值。“可选”是为了解决这些问题而引入的。

可选函数将采用两种形式“值”和“nil”。我们将使用关键保留字符“？”来提及“可选”，以检查元组是返回值还是 nil 值。

示例

Swift 程序创建返回可选类型的函数。

// Function with optional return type
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 中，函数类型用于表示函数的类型以及其参数类型和返回值类型。函数类型允许我们以类型安全的方式创建、传递和使用函数作为变量或参数。参数类型表示将存储在函数中的参数的类型，而返回值类型表示函数将返回的值的类型。

示例

Swift 程序演示函数类型。

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 函数是一等公民。因此，我们允许将函数分配给变量，就像我们将值分配给变量一样。将函数分配给变量后，该变量将保存该函数的引用。

语法

以下是将函数赋值给变量的语法：

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

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

示例

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

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

// Assigning a function to a variable
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

输出

它将产生以下输出：

Result: 129

函数类型作为参数类型

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

示例

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

// Function type is (Int, Int) -> Int
func add(_ x: Int, _ y: Int) -> Int {
   return x + y
}

// Function type as a parameter
func Display(_ myOperation: (Int, Int) -> Int, _ p: Int, _ q: Int) -> Int {
   return myOperation(p, q)
}

// Passing function as an argument
let sum = Display(add, 5, 7)

print("Sum: \(sum)")

输出

它将产生以下输出：

Sum: 12

函数类型作为返回值类型

在 Swift 中，我们可以在另一个函数中使用函数类型作为返回值类型，这意味着一个函数可以从另一个函数返回。

示例

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

// Function type is (Int, Int) -> Int
func add(_ x: Int, _ y: Int) -> Int {
   return x + y
}

// Display() function will return add() function
func Display()->(Int, Int) -> Int {
   return add
}

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

print("Sum: \(result)")

输出

它将产生以下输出：

Sum: 11

打印页面