Swift 函数|极客教程

Swift 函数

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

函数声明 - 告诉编译器函数的名称、返回类型和参数。
函数定义 - 提供函数的实际体。

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

函数定义

在Swift 4中，使用”func”关键字来定义函数。当一个函数被新定义时，它可以接受一个或多个值作为输入参数，并在主体中处理函数，并将值作为输出（返回类型）传递回函数。

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

函数的参数必须与函数的参数列表的顺序相同，并且返回值之后是 →。

语法

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

当我们在playground上运行上述程序时，我们得到以下结果-

First Program
About Functions

调用函数

假设我们定义了一个名为’display’的函数。例如，我们定义了一个函数来显示数字，函数名为’display’，首先用参数’no1’来初始化，’no1’是整数数据类型。然后将参数’no1’赋值给参数’a’，从此以后，’a’将指向相同的整数数据类型。现在将参数’a’返回给函数。在每次调用函数时，’display()’函数将保持整数值并返回整数值。

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

print(display(no1: 100))
print(display(no1: 200))

当我们在playground上运行上面的程序时，我们得到以下结果−

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

当我们在playground上运行上面的程序时，我们得到以下结果−。

40
45
120

没有参数的函数

我们也可以创建没有任何参数的函数。

语法

func funcname() -> datatype {
   return datatype
}

以下是一个没有参数的函数的示例：

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

当我们在playground中运行上面的程序，我们得到以下的输出：

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

当我们使用playground运行上述程序时，我们得到以下结果 −

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)

将上面的程序在playground上运行，我们得到以下结果−

30 20
50 40
30 24

具有可选返回类型的函数

Swift 4引入了“可选”功能，通过引入安全措施来解决问题。例如，我们声明函数返回类型为整数，但当函数返回字符串值或空值时会发生什么情况。在这种情况下，编译器将返回一个错误值。引入“可选”是为了解决这些问题。

可选函数将采用“值”和“空值”两种形式。我们将使用保留字符“？”来表示“可选项”，以检查元组是否返回一个值或一个空值。

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

当我们在playground上运行上述程序时，我们得到以下结果-

min is -6 and max is 109

“可选项”用于检查“nil”或垃圾值，从而在调试中消耗大量时间，并使代码对用户来说更高效且可读。

函数的本地参数名与外部参数名

本地参数名

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

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

在这里， func 参数的示例被声明为内部变量，因为它在函数sample()内部访问。在这里，’number’被声明为局部变量，但是在函数外部使用以下语句引用该变量-

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

sample(number: 1)
sample(number: 2)
sample(number: 3)

当我们在playground上运行上述程序时，我们得到以下结果 –

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)

当我们使用Playground运行上面的程序时，我们会得到以下结果：

可变参数

当我们想定义一个具有多个参数的函数时，我们可以将成员声明为“可变”参数。参数可以在参数名称后面用(···)来指定为可变参数。

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

当我们在playground上运行上述程序时，我们会得到以下结果 –

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参数。变量名称前的’&’表示我们正在将参数传递给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)")

当我们在 playground 上运行上面的程序时，我们得到以下结果：

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

当我们使用playground运行上述程序时，我们得到以下结果 –

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

当我们在playground上运行上述程序时，我们会得到以下结果 –

Swift 4 Functions
Types and its Usage

上述函数被声明为无参数、无返回值的void函数。

使用函数类型

函数首先通过整数、浮点数或字符串类型的参数传递，然后作为常量或变量传递给函数，如下所述。

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

在这里，sum是一个函数名，具有’ a ‘和’ b ‘整数变量，现在将其声明为函数名addition的变量。在此之后，addition和sum函数都有相同数量的参数声明为整数数据类型，还以引用形式返回整数值。

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

在使用playground运行上述程序时，我们得到以下结果：

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)

当我们使用playground运行上述程序时，我们得到以下结果−

Result: 129
Result: 30

嵌套函数

嵌套函数提供了通过调用内部函数来调用外部函数的功能。

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

当我们使用playground运行上述程序时，我们得到以下结果 –