Fonctions Swift
Les fonctions Swift sont des blocs de code autonomes qui effectuent des tâches spécifiques.
Swift utilise une syntaxe unifiée pour représenter des fonctions allant de simples fonctions de style C à des méthodes complexes de style Objective-C.
Déclaration de fonction : indique au compilateur le nom de la fonction, son type de retour et ses paramètres.
Définition de fonction : fournit le corps de la fonction.
Les fonctions Swift incluent des types de paramètres et des types de valeur de retour :
Définition de fonction
Swift définit des fonctions à l'aide du mot-cléfunc。
Lors de la définition d'une fonction, vous pouvez spécifier un ou plusieurs paramètres d'entrée et un type de retour.
Chaque fonction a un nom de fonction qui décrit sa fonction. Vous appelez cette fonction par son nom et des valeurs de paramètres des types correspondants. L'ordre dans lequel les arguments de la fonction sont passés doit correspondre à la liste des paramètres.
L'ordre dans lequel les arguments réels de la fonction sont passés doit être le même que celui de la liste des paramètres formels,->Définissez ensuite le type de retour de la fonction.
Syntaxe
func funcname(形参) -> returntype
{
Statement1
Statement2
……
Statement N
return parameters
}
Exemple
Ci-dessous, nous définissons une fonction nommée example, avec un paramètre formel de type String et une valeur de retour de type String :
import Cocoa
func example(site: String) -> String {
return (site)
}
print(example(site: "www.example.com"))
La sortie de l'exécution du programme ci-dessus est :
www.example.com
Appel de fonction
Nous pouvons appeler une fonction par son nom et des valeurs de paramètres des types correspondants. L'ordre dans lequel les arguments de la fonction sont passés doit correspondre à la liste des paramètres.
Ci-dessous, nous définissons une fonction nommée example avec un paramètre formel site de type String. Lorsque nous appelons la fonction, l'argument réel passé doit également être de type String. Après que l'argument a été passé dans le corps de la fonction, il est renvoyé directement, et le type de données renvoyé est String.
import Cocoa
func example(site: String) -> String {
return (site)
}
print(example(site: "www.example.com"))
La sortie de l'exécution du programme ci-dessus est :
www.example.com
Paramètres de fonction
Une fonction peut accepter un ou plusieurs paramètres. Ces paramètres sont contenus entre les parenthèses de la fonction et séparés par des virgules.
L'exemple suivant transmet le nom de site name et l'adresse de site site à la fonction example :
import Cocoa
func example(name: String, site: String) -> String {
return name + site
}
print(example(name: "Example:", site: "www.example.com"))
print(example(name: "Google:", site: "www.google.com"))
La sortie de l'exécution du programme ci-dessus est :
Example:www.example.com Google:www.google.com
Fonctions sans paramètres
Nous pouvons créer des fonctions sans paramètres.
Syntaxe :
func funcname() -> datatype {
return datatype
}
Exemple
import Cocoa
func sitename() -> String {
return "Example"
}
print(sitename())
La sortie de l'exécution du programme ci-dessus est :
Rookie Tutorial
Tuple en tant que valeur de retour d'une fonction
Les types de valeur de retour d’une fonction peuvent être des chaînes de caractères, des entiers, des types à virgule flottante, etc.
Les tuples sont similaires aux tableaux, sauf que les éléments d’un tuple peuvent être de n’importe quel type et sont placés entre parenthèses.
Vous pouvez utiliser un type tuple pour renvoyer plusieurs valeurs sous la forme d’une seule valeur composée à partir d’une fonction.
Dans l’exemple suivant, une fonction nommée minMax(_:) est définie pour trouver les valeurs minimale et maximale dans un tableau de type Int.
import Cocoa
func minMax(array: [Int]) -> (min: Int, max: Int) {
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)
}
let bounds = minMax(array: [8, -6, 2, 109, 3, 71])
print("最小值为 \(bounds.min) ,最大值为 \(bounds.max)")
La fonction minMax(_:) renvoie un tuple contenant deux valeurs Int, qui sont étiquetées min et max, afin qu’elles puissent être accessibles par leur nom lors de la consultation de la valeur de retour de la fonction.
La sortie de l'exécution du programme ci-dessus est :
最小值为 -6 ,最大值为 109
Si vous n’êtes pas sûr que le tuple renvoyé ne soit pas nil, vous pouvez renvoyer un type tuple optionnel.
Vous pouvez définir un tuple optionnel en plaçant un point d’interrogation après la parenthèse fermante du type tuple, par exemple (Int, Int)? ou (String, Int, Bool)?
Remarque
Les types de tuples optionnels tels que(Int, Int)?et les tuples contenant des types optionnels tels que(Int?, Int?)sont différents. Pour un type tuple optionnel, le tuple entier est optionnel, et non pas seulement chaque valeur d’élément du tuple.
La précédenteminMax(_:)fonction renvoie un tuple contenant deuxIntvaleurs. Toutefois, la fonction n'effectue aucune vérification de sécurité sur le tableau transmis. Si learrayparamètre est un tableau vide, la fonction définie ci-dessusminMax(_:)lorsqu'elle essaie d'accéder àarray[0]déclenchera une erreur d'exécution.
Pour gérer en toute sécurité ce problème de « tableau vide », modifiez laminMax(_:)fonction pour qu'elle utilise un type de retour de tuple optionnel, et lorsque le tableau est vide, retourneznil:
import Cocoa
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("最小值为 \(bounds.min),最大值为 \(bounds.max)")
}
La sortie de l'exécution du programme ci-dessus est :
最小值为 -6,最大值为 109
Fonctions sans valeur de retour
Voici une autre version de la fonction example(_:). Cette fonction prend en paramètre l'URL du site officiel Example, ne spécifie pas de type de retour et affiche directement une valeur String au lieu de la renvoyer :
import Cocoa
func example(site: String) {
print("Example官网:\(site)")
}
example(site: "http://www.example.com")
La sortie de l'exécution du programme ci-dessus est :
Example官网:http://www.example.com
Noms des paramètres de fonction
Les paramètres de fonction ont à la fois un nom de paramètre externe et un nom de paramètre local.
Noms des paramètres locaux
Les noms de paramètres locaux sont utilisés dans l'implémentation de la fonction.
func sample(number: Int) {
println(number)
}
Dans l'exemple ci-dessus, number est un nom de paramètre local et ne peut être utilisé qu'à l'intérieur du corps de la fonction.
import Cocoa
func sample(number: Int) {
print(number)
}
sample(number: 1)
sample(number: 2)
sample(number: 3)
La sortie de l'exécution du programme ci-dessus est :
1 2 3
Noms de paramètres externes
Vous pouvez spécifier un nom de paramètre externe avant le nom de paramètre local, séparé par un espace. Le nom de paramètre externe est utilisé lors de l'appel de la fonction pour transmettre l'argument à la fonction.
Comme suit, vous pouvez définir les deux noms de paramètres de fonction suivants et l'appeler :
import Cocoa
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)
La sortie de l'exécution du programme ci-dessus est :
125
Remarque
Si vous fournissez un nom de paramètre externe, la fonction doit utiliser le nom de paramètre externe lorsqu'elle est appelée.
Paramètres variadiques
Les paramètres variadiques peuvent accepter zéro ou plusieurs valeurs. Lors de l'appel d'une fonction, vous pouvez utiliser un paramètre variadique pour spécifier des paramètres de fonction, et le nombre est indéterminé.
Les paramètres variadiques sont définis en ajoutant (...) après le nom du type de variable.
import Cocoa
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: "Google", "Baidu", "Example")
La sortie de l'exécution du programme ci-dessus est :
4 3 5 4.5 3.1 5.6 Google Baidu Example
Constantes, variables et paramètres d'E/S
En général, les paramètres définis dans une fonction sont des paramètres constants par défaut, ce qui signifie que vous pouvez uniquement interroger et utiliser ce paramètre, mais que vous ne pouvez pas modifier sa valeur.
Si vous souhaitez déclarer un paramètre variable, vous pouvez ajouter le mot-clé inout avant la définition du paramètre, afin que la valeur de ce paramètre puisse être modifiée.
Par exemple :
func getName(_ name: inout String).........
À ce stade, la valeur de name peut être modifiée à l'intérieur de la fonction.
De manière générale, le passage de paramètres par défaut se fait par valeur, et non par référence. Ainsi, si le paramètre transmis est modifié à l'intérieur de la fonction, cela n'affecte pas le paramètre d'origine. Ce qui est transmis n'est qu'une copie de ce paramètre.
Lorsqu'un paramètre transmis est utilisé comme paramètre d'entrée-sortie, vous devez ajouter un symbole & avant le nom du paramètre pour indiquer que cette valeur peut être modifiée par la fonction.
Exemple
import Cocoa
func swapTwoInts(_ a: inout Int, _ b: inout Int) {
let temporaryA = a
a = b
b = temporaryA
}
var x = 1
var y = 5
swapTwoInts(&x, &y)
print("x 现在的值 \(x), y 现在的值 \(y)")
La fonction swapTwoInts(_:_:) échange simplement les valeurs de a et b. La fonction stocke d'abord la valeur de a dans une constante temporaire temporaryA, puis assigne la valeur de b à a, et enfin assigne temporaryA à b.
Il convient de noter que someInt et anotherInt sont tous deux précédés du symbole & avant d'être transmis à la fonction swapTwoInts(_:_:).
La sortie de l'exécution du programme ci-dessus est :
x 现在的值 5, y 现在的值 1
Types de fonctions et utilisation
Chaque fonction possède un type de fonction spécifique, constitué des types des paramètres de la fonction et de son type de retour.
func inputs(no1: Int, no2: Int) -> Int {
return no1/no2
}
Le type de fonction inputs possède deux paramètres Int (no1, no2) et renvoie une valeur Int.
Exemple :
import Cocoa
func inputs(no1: Int, no2: Int) -> Int {
return no1/no2
}
print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))
La sortie de l'exécution du programme ci-dessus est :
2 6
La fonction ci-dessus définit deux types de paramètres Int, et la valeur de retour est également de type Int.
Ensuite, examinons la fonction suivante. La fonction définit un paramètre de type String et une valeur de retour de type String.
func inputstr(name: String) -> String {
return name
}
Une fonction peut également être définie sans paramètres ni valeur de retour, comme indiqué ci-dessous :
import Cocoa
func inputstr() {
print("Example")
print("www.example.com")
}
inputstr()
La sortie de l'exécution du programme ci-dessus est :
Example www.example.com
Utilisation des types de fonctions
En Swift, utiliser des types de fonctions revient à utiliser n'importe quel autre type. Par exemple, vous pouvez définir une constante ou une variable dont le type est une fonction, et lui assigner une fonction appropriée :
var addition: (Int, Int) -> Int = sum
Explication :
Définissez une variable appeléeadditiondont les types de paramètre et de valeur de retour sont tous deuxInt, et faites pointer cette nouvelle variable vers lasumfonction.
sumetadditionIls ont le même type, donc l'opération ci-dessus est légale.
Maintenant, vous pouvez utiliser addition pour appeler la fonction assignée :
import Cocoa
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")
La sortie de l'exécution du programme ci-dessus est :
输出结果: 129
Types de fonction comme types de paramètres, types de fonction comme types de retour
Nous pouvons passer une fonction comme paramètre à une autre fonction :
import Cocoa
func sum(a: Int, b: Int) -> Int {
return a + b
}
var addition: (Int, Int) -> Int = sum
print("输出结果: \(addition(40, 89))")
func another(addition: (Int, Int) -> Int, a: Int, b: Int) {
print("输出结果: \(addition(a, b))")
}
another(addition: sum, a: 10, b: 20)
La sortie de l'exécution du programme ci-dessus est :
输出结果: 129 输出结果: 30
Fonctions imbriquées
L'imbrication de fonctions consiste à définir une nouvelle fonction à l'intérieur d'une fonction ; la fonction externe peut appeler la fonction définie à l'intérieur.
Un exemple est le suivant :
import Cocoa
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())
La sortie de l'exécution du programme ci-dessus est :
-30Autres extensions