📅 最后修改于: 2020-12-25 04:31:00 🧑 作者: Mango
函数是一起组织以执行特定任务的一组语句。 Swift 4函数可以像简单的C函数一样简单，也可以像目标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"))
当我们使用游乐场运行上述程序时，我们得到以下结果-
First Program
About Functions
让我们假设我们定义了一个名为“显示”函数，例如，考虑到具有显示函数的名称“显示”函数首先用参数“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
我们可能还具有不带任何参数的函数。
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.. 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值时会发生什么。在这种情况下，编译器将返回错误值。引入了“可选”以消除这些问题。
可选函数将采用两种形式：“值”和“零”。我们会提到“自选”与键保留字符“?”检查元组是返回值还是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.. 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
“可选”用于检查“ nil”或垃圾值，从而在调试中消耗大量时间，并使代码对用户有效且可读。
局部参数名称只能在函数内部访问。
func sample(number: Int) {
print(number)
}
在这里， func示例参数号被声明为内部变量，因为它是由函数sample()在内部访问的。在这里，“数字”被声明为局部变量，但是使用以下语句在函数外部进行了对该变量的引用：
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..当我们使用游乐场运行上述程序时，我们得到以下结果-
125
当我们要使用多个参数定义函数时，可以将成员声明为“可变”参数。参数名称后面的(···)可以将参数指定为可变参数。
func vari(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
默认情况下，函数将参数视为“常量”，而用户也可以将函数的参数声明为变量。我们已经讨论过使用“ let”关键字声明常量参数，并使用“ var”关键字定义变量参数。
Swift 4中的I / O参数提供了保留参数值的功能，即使在函数调用后对其值进行了修改。在函数参数定义的开头，声明了“ inout”关键字以保留成员值。
它派生关键字“ inout”，因为其值被“传入”到函数，并且其值被其函数主体访问和修改，并且被返回“ out”出函数以修改原始参数。
变量仅作为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)")
当我们使用游乐场运行上述程序时，我们得到以下结果-
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
}
在这里，该函数被声明为字符串数据类型。
函数也可能具有无效的数据类型，此类函数不会返回任何内容。
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
这里总和是具有“a”和“B”整数其现在声明为变量的函数名添加变量的函数名。此后，加法和求和函数都具有相同数量的参数，声明为整数数据类型，并且还返回整数值作为引用。
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
嵌套函数提供了通过调用内部函数来调用外部函数的便利。
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