功能（ Functions）

优质

小牛编辑

135浏览

2023-12-01

函数是组合在一起执行特定任务的一组语句。 Swift 4函数可以像简单的C函数一样简单，也可以像Objective C语言函数一样复杂。它允许我们在函数调用中传递本地和全局参数值。

Function Declaration - 告诉编译器函数的名称，返回类型和参数。
Function Definition - 它提供Function Definition的实际主体。

Swift 4函数包含参数类型及其返回类型。

函数定义 (Function Definition)

在Swift 4中，函数由“func”关键字定义。当一个函数被新定义时，它可能需要一个或多个值作为函数的输入'参数'，它将处理主体中的函数并将值作为输出'返回类型'传递回函数。

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

函数的参数必须始终以与函数参数列表相同的顺序提供，返回值后跟→。

语法 (Syntax)

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

看看下面的代码。学生的名字被声明为在函数'student'中声明的字符串数据类型，当调用该函数时，它将返回学生的姓名。

func student(name: String) -> String {
   return name
}
print(student(name: "First Program"))
print(student(name: "About Functions"))

当我们使用游乐场运行上述程序时，我们得到以下结果 -

First Program
About Functions

调用一个函数 (Calling a Function)

让我们假设我们定义了一个名为'display'的函数来考虑例如显示数字，一个函数名为'display'的函数首先用参数'no1'初始化，该参数保存整数数据类型。然后将参数'no1'分配给参数'a'，此后将指向相同的数据类型整数。现在参数'a'返回给函数。这里display（）函数将保存整数值，并在每次调用函数时返回整数值。

func display(no1: Int) -> Int {
   let a = no1
   return a
}
print(display(no1: 100))
print(display(no1: 200))

当我们使用游乐场运行上述程序时，我们得到以下结果 -

100
200

参数和返回值

Swift 4提供灵活的函数参数及其从简单到复杂值的返回值。与C和Objective C类似，Swift 4中的函数也可以采用多种形式。

带参数的函数

通过将其参数值传递给函数体来访问函数。我们可以将单个参数值作为元组传递给函数内的元组。

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

没有参数的函数

我们也可能没有任何参数的功能。

语法 (Syntax)

func funcname() -> datatype {
   return datatype
}

以下是具有不带参数的函数的示例 -

func votersname() -> String {
   return "Alice"
}
print(votersname())

当我们使用游乐场运行上述程序时，我们得到以下结果 -

Alice

具有返回值的函数

函数还用于将字符串，整数和浮点数据类型值作为返回类型返回。为了找出给定数组函数中的最大和最小数字，使用大小整数数据类型声明'ls'。

初始化数组以保存整数值。然后处理该数组，并读取数组中的每个值并比较其先前的值。当值小于前一个值时，它存储在'small'参数中，否则它存储在'large'参数中，并通过调用函数返回值。

func ls(array: [Int]) -> (large: Int, small: Int) {
   var lar = array[0]
   var sma = array[0]
   for i in array[1..<array.count] {
      if i < sma {
         sma = i
      } else if i > lar {
         lar = i
      }
   }
   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

没有返回值的函数

某些函数可能在函数内声明了参数而没有任何返回值。以下程序将a和b声明为sum（）函数的参数。在函数本身内部，通过调用函数调用sum（）来传递参数a和b的值，并打印其值，从而消除返回值。

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 4引入了“可选”功能，通过引入安全措施来消除问题。例如，我们将函数值返回类型声明为整数，但是当函数返回字符串值或nil值时会发生什么。在这种情况下，编译器将返回错误值。引入'可选'来摆脱这些问题。

可选函数将采用两种形式'value'和'nil'。我们会提到'Optionals'和关键保留字符'？' 检查元组是返回值还是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)
}
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

''Optionals'用于检查'nil'或垃圾值，从而在调试时耗费大量时间，并使代码对用户有效且可读。

功能本地Vs外部参数名称

本地参数名称

仅在函数内部访问本地参数名称。

func sample(number: Int) {
   print(number)
}

这里， func样本参数号被声明为内部变量，因为它是由函数sample（）在内部访问的。这里'number'被声明为局部变量，但是变量的引用是在函数外部使用以下语句 -

func sample(number: Int) {
   print(number)
}
sample(number: 1)
sample(number: 2)
sample(number: 3)

当我们使用游乐场运行上述程序时，我们得到以下结果 -

1
2
3

外部参数名称

外部参数名称允许我们命名函数参数以使其目的更清晰。例如，您可以在下面命名两个函数参数，然后按如下方式调用该函数 -

func pow(firstArg a: Int, secondArg b: Int) -> Int {
   var res = a
   for _ in 1..<b {
      res = res * a
   }
   print(res)
   return res
}
pow(firstArg:5, secondArg:3)

当我们使用游乐场运行上述程序时，我们得到以下结果 -

变量参数

当我们想要定义具有多个参数的函数时，我们可以将成员声明为'variadic'参数。可以在参数名称后面的（···）将参数指定为可变参数。

func vari<N>(members: N...){
   for i in members {
      print(i)
   }
}
vari(members: 4,3,5)
vari(members: 4.5, 3.1, 5.6)
vari(members: "Swift 4", "Enumerations", "Closures")

当我们使用游乐场运行上述程序时，我们得到以下结果 -

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

常量，变量和I/O参数

默认情况下，函数将参数视为“常量”，而用户也可以将函数的参数声明为变量。我们已经讨论过'let'关键字用于声明常量参数，变量参数用'var'关键字定义。

Swift 4中的I/O参数提供了保留参数值的功能，即使在函数调用后修改了它的值。在函数参数定义的开头，声明'inout'关键字保留成员值。

它派生关键字'inout'，因为它的值被'in'传递给函数，并且它的值由其函数体访问和修改，并且它返回'out'返回函数以修改原始参数。

变量仅作为输入输出参数的参数传递，因为它的值仅在函数内外被修改。因此，无需将字符串和文字声明为输入输出参数。变量名前的'＆'表示我们将参数传递给in-out参数。

func temp(a1: inout Int, b1: inout Int) {
   let t = a1
   a1 = b1
   b1 = t
}
var no = 2
var co = 10
temp(a1: &no, b1: &co)
print("Swapped values are \(no), \(co)")

当我们使用游乐场运行上述程序时，我们得到以下结果 -

Swapped values are 10, 2

功能类型及其用法

通过考虑输入参数并输出所需结果，每个功能都遵循特定功能。

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

以下是一个例子 -

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

当我们使用游乐场运行上述程序时，我们得到以下结果 -

2
6

这里函数初始化为两个参数no1和no2作为整数数据类型，其返回类型也声明为'int'

Func inputstr(name: String) -> String {
   return name
}

这里函数声明为string数据类型。

函数也可能具有void数据类型，并且此类函数不会返回任何内容。

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

当我们使用游乐场运行上述程序时，我们得到以下结果 -

Swift 4 Functions
Types and its Usage

上述函数声明为void函数，没有参数且没有返回值。

使用函数类型

函数首先使用整数，浮点或字符串类型参数传递，然后将其作为常量或变量传递给函数，如下所述。

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

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

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")

当我们使用游乐场运行上述程序时，我们得到以下结果 -

Result: 129

函数类型作为参数类型和返回类型

我们还可以将函数本身作为参数类型传递给另一个函数。

func sum(a: Int, b: Int) -> Int {
   return a + b
}
var addition: (Int, Int) -> Int = sum
print("Result: \(addition(40, 89))")
func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
   print("Result: \(addition(a, b))")
}
another(sum, 10, 20)

当我们使用游乐场运行上述程序时，我们得到以下结果 -

Result: 129
Result: 30

嵌套函数

嵌套函数提供了通过调用inside函数来调用外部函数的工具。

func calcDecrement(forDecrement total: Int) -> () -> Int {
   var overallDecrement = 0
   func decrementer() -> Int {
      overallDecrement -= total
      return overallDecrement
   }
   return decrementer
}
let decrem = calcDecrement(forDecrement: 30)
print(decrem())

当我们使用游乐场运行上述程序时，我们得到以下结果 -

-30