Paramètres et valeurs de retour des fonctions Swift

Dans cet article, vous allez apprendre différents types de fonctions définies par l'utilisateur, qui recevront différents types d'inputs et renverront des outputs par exemple.

Dans l'article précédentFonction Swift，nous avons appris les fonctions. Maintenant, nous allons explorer différentes manières et types de création de fonctions en Swift, à savoir la gestion des entrées et sorties dans les fonctions.

Fonction sans paramètres ni valeur de retour

Ces types de fonctions n'acceptent aucun entrée et valeur de retour.

func funcname() {
　　　　//Instructions
}
ou
func funcname()　-> () {
　　　　//Instructions
}
ou
func funcname()　-> Void {
　　　　//Instructions
}

Toutes les syntaxes ci-dessus sont valides pour créer des fonctions sans paramètres ni valeur de retour.

La syntaxe func funcname()->() est équivalent à func funcname()->void, car void est un alias de type pour () . Vous pouvez accéderAlias de type Swiftpour en savoir plus.

Exemple1：pas de paramètres passés, ni valeur de retour

func greetUser() {
　　　　print("Good Morning!")
}
greetUser()

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

Good Morning!

Fonction sans paramètres mais avec valeur de retour

Ces types de fonctions n'acceptent aucun paramètre d'entrée, mais renvoient une valeur. Pour ajouter un type de retour, vous devez ajouter une flèche (-）et le type de retour.

func funcname()　-> ReturnType {
　　　　//Instructions
　　　　return value
}

Exemple2：pas de paramètres passés mais valeur de retour

func greetUser()　-> String {
　　　　return "Good Morning!"
}
let msg = greetUser()
print(msg)

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

Good Morning!

Dans le programme ci-dessus, vous avez défini le type de retour comme String. Maintenant, cette instruction doit renvoyer une chaîne de caractères à partir de l'instruction interne de la fonction, sinon vous obtiendrez une erreur.

Le mot-clé return transfère le contrôle du programme du corps de la fonction à l'appel de la fonction. Si vous devez renvoyer une valeur de la fonction, ajoutez la valeur à renvoyer après le mot-clé return.

La phrase return "Good Morning!" renvoie une valeur de type String. Notez que le type et la valeur de la valeur de retour doivent correspondre.

Vous pouvez également affecter la valeur de retour à une variable ou une constante. let msg = affecte la valeur de retour à la constante msg. Par conséquent, l'instruction print(msg ) affiche"Good Morning!"。

Si vous souhaitez ignorer cette valeur, utilisez simplement le trait de soulignement _ , c'est-à-dire let _ = .

Fonction avec paramètres mais sans valeur de retour

参数用于在函数中输入。参数包含参数名称和类型，后跟冒号（:）。这些类型的函数采用输入参数，但不返回值。

func funcname(parameterName: Type) {
　　　　//Instructions
}

Exemple3：参数传递但没有返回值

func greetUser(msg: String) {
　　　　print(msg)
}
greetUser(msg: "Good Morning!")

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

Good Morning!

在上述程序中，该函数接受字符串类型的单个参数。该参数只能在函数内部使用。msg是参数的名称。

您可以通过向函数传递参数名称为 msg 的字符串值来调用函数 greetUser(msg: "Good Morning!")。该参数名称只在 greetUser() 函数内部可见。

因此，print(msg)语句输出 "Good Morning!"。

具有参数和返回值的函数

这些类型的函数使用参数并返回值。

func funcname(parameterName: Type)　-> ReturnType {
　　　　//Instructions
}

Exemple4：传递参数并返回值

func greetUser(name: String)　-> String {
　　　　return "Good Morning! "　+　name
}
let msg = greetUser(name: "Jack")
print(msg)

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

Good Morning! Jack

在上面的程序中，该函数接受String类型的单个参数，并且还返回String类型的值“Good Morning! Jack”。

具有多个参数和多个返回值的函数

这些类型的函数采用以逗号分隔的多个参数，并且还返回多个值。您可以使用元组在Swift中返回多个值。

func funcname(parameterName: Type, parameterName2: Type ...,)　-> (ReturnType, ReturnType...) {
　　　　//Instructions
}

Exemple5：传递了多个参数和多个返回值

func greetUser(name: String, age: Int)　-> (String, Int) {
　　　　
　　　　let msg = "Good Morning!"　+　name
　　　　var userage = age
　　　　if age < 0 {
　　　　　　　　　　　　userage = 0
　　　　}
　　　　return (msg, userage)
}
let msg = greetUser(name: "Jack", age:　-2)
print(msg.0)
print("Vous avez \(msg.1) pieces de monnaie en reserve"

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

Good Morning!Jack
Vous avez 0 pieces de monnaie en reserve

Dans le programme ci-dessus, la fonction greetUser() accepte plusieurs paramètres de type String et Int. La fonction retourne également plusieurs valeurs, de type String et Int.

Pour accéder à chaque valeur de retour, nous utilisons l'index 0,1, … ici, nous utilisons msg.0 pour accéder à "Good Morning!Jack" et msg.1 Accéder à "0".

L'utilisation de positions d'index peut parfois être peu intuitive et difficile à lire. Nous pouvons résoudre ce problème de manière élégante en nommant les valeurs de retour. Le programme suivant peut également être réécrit de la manière suivante.

Exemple6: valeurs de retour multiples avec un nom

func greetUser(name: String, coins: Int)　-> (name: String, coins: Int) {
　　　　
　　　　let msg = "Good Morning!"　+　name
　　　　var userCoins = coins
　　　　if coins < 0 {
　　　　　　　　userCoins = 0
　　　　}
　　　　return (msg, userCoins)
}
let msg = greetUser(name: "Jack", coins:　-2)
print(msg.name)
print("Vous avez \(msg.coins) pieces de monnaie en reserve")

Dans ce programme, le type de retour est un tuple contenant des noms de variables de ce type. La principale avantage de cela est que vous pouvez utiliser les noms de variables msg.name et msg.coins au lieu de msg.0 et msg.1 pour accéder aux résultats.

Fonction avec étiquette de paramètre

Lors de la définition d'une fonction qui accepte des entrées, il est possible de définir le nom d'entrée avec l'aide du nom de paramètre. Mais il existe également un autre nom qui peut être utilisé avec le nom de paramètre, appelé étiquette de paramètre.

L'utilisation de l'étiquette de variable permet d'appeler une fonction de manière expressive, de manière similaire à une phrase, tout en fournissant un corps de fonction lisible et clair d'intention.

Chaque paramètre de fonction a une étiquette de paramètre et un nom de paramètre. Par défaut, le paramètre utilise son nom de paramètre comme étiquette de paramètre. Mais si vous définissez explicitement le nom du paramètre, l'étiquette de paramètre sera utilisée lors de l'appel de la fonction.

La syntaxe des fonctions avec étiquette de paramètre est

func funcname(argumentLabel parameterName: Type)-> Type de retour {
　　　　//Instructions
}

Voyons cela dans l'exemple suivant.

Exemple7: fonction sans étiquette de paramètre

func sum(a: Int, b: Int)　-> Int {
　　　　
　　　　return a　+　b
}
let result = sum(a:　2, b:　3)
print("La somme est \(result)")

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

La somme est　5

Dans l'exemple ci-dessus, nous n'avons pas spécifié les étiquettes de paramètre, donc lors de l'appel de la fonction, elle utilisera les noms de paramètres par défaut a et b comme étiquettes de paramètre.

Lorsque vous appelez une fonction, vous pourriez remarquer que l'appel de la fonction n'est pas exprimé/phrase. Si vous pouvez configurer l'appel de la fonction :

let result = sum(of:　2, and:　3)

Maintenant, changeons la fonction :

Exemple8: fonction avec un appel de fonction meilleur mais pas comme nom de paramètre

func sum(of: Int, and: Int)　-> Int {
　　　　return of　+　et
}
let result = sum(of:　2, and:　3)
print("La somme est \(result)")

Maintenant, l'appel de méthode est exprimé. Cependant, maintenant nous devons utiliser les noms de paramètres of et and, return of + et and pour trouver la somme de deux nombres. Cela rend le corps de la fonction moins lisible. Utiliser a et b à la place de of et and dans le corps de la fonction est plus significatif.

Pour cela, nous devons définir explicitement les étiquettes de paramètre :

Exemple9: fonction avec étiquette de paramètre

func sum(of a: Int, and b: Int)　-> Int {
　　　　return a　+　b
}
let result = sum(of:　2, and:　3)
print("La somme est \(result)")

Dans le programme ci-dessus, la fonction accepte deux paramètres de type Int. L'appel de la fonction utilise les étiquettes de paramètre of et and, ce qui est plus significatif lors de l'appel de la fonction sum(of: 2, et : 3) plutôt que sum(a: 2, b: 3)。

De plus, le corps de la fonction utilise les noms de paramètres a et b, plutôt que of et and, ce qui est plus significatif lors de l'application des opérations.

Vous pouvez également omettre les étiquettes de paramètre en écrivant un trait de soulignement _ devant le nom du paramètre.

func sum(_ a: Int, _ b: Int)　-> Int {
　　　　return a　+　b
}
let result = sum(2,　3)
print("La somme est \(result)")

Fonction avec valeur par défaut du paramètre

Vous pouvez fournir une valeur par défaut pour tout paramètre de la fonction, en assignant une valeur à ce paramètre après son type. L'assignation de valeurs par défaut vous permet d'ignorer un paramètre lors de l'appel de la fonction.

Si vous ne passez pas de valeur à un paramètre lors de l'appel de la fonction, elle utilise sa valeur par défaut. Cependant, si vous passez explicitement une valeur à un paramètre lors de l'appel, elle utilise la valeur spécifiée.

func funcname(parameterName: Type = value)　-> Type de retour {
　　　　//Instructions
}

Exemple10: fonction avec valeur par défaut du paramètre

func sum(of a: Int =　7, and b: Int =　8)　-> Int {
　　　　return a　+　b
}
let result1　= sum(of:　2, and:　3)
print("La somme est \(result"1))
let result2　= sum(of:　2)
print("La somme est \(result"2))
let result3　= sum(and:　2)
print("La somme est \(result"3))
let result4　= sum()
print("La somme est \(result"4))

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

La somme est　5
La somme est　10
La somme est　9
La somme est　15

Dans le programme ci-dessus, la fonction sum(of a :Int =}} 7 , et b:Int = 8) -> Int accepte deux paramètres de type Int et spécifie les paramètres a=7et b=8valeur par défaut.

Si vous passez la valeur value en tant que paramètre lors de l'appel de la fonction, sum(of: 2, et : 3) est utilisé2et3remplace la valeur par défaut du paramètre.

Mais si vous ne passez pas la valeur du paramètre en tant que sum(), alors la valeur par défaut7et8comme valeur de paramètre.

Fonction avec paramètres variables

Les paramètres variables peuvent accepter zéro ou plusieurs valeurs spécifiques de types. Vous pouvez spécifier un paramètre variable en insérant trois points de suspension (...) après le nom du type du paramètre.

Lorsque vous devez transmettre divers nombres de valeurs d'entrée à un paramètre lors de l'appel de la fonction, il est généralement utilisé des paramètres variables. Par exemple, une liste de nombres, une liste de lettres, etc.

La syntaxe de la fonction avec des paramètres variables est :

func funcname(parameterName: Type...)　-> Type de retour {
　　　　//Instructions
}

Exemple11：fonction avec paramètres variables

func sum(of numbers: Int...) {
　　　　var result = 0
　　　　for num in numbers {
　　　　　　　　result　+= num
　　　　}
　　　　print("La somme des nombres est \(result)")
}
sum(of:　1,　2,　3,　4,　5,　6,　7,　8)

Dans le programme ci-dessus, la fonction sum(of numbers: Int...) accepte des arguments variables de type Int. Les arguments variables peuvent accepter plusieurs valeurs séparées par des virgules sum(of: 1, 2, 3, 4, 5, 6, 7, 8)。

comme valeur transmise en tant que paramètre variable1,2,3,4,5,6,7,8Dans le corps de la fonction, il peut être utilisé comme tableau de type Int. Par conséquent, nous pouvons utiliser for-in est appliqué en boucle for num in numbers.

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

La somme des nombres est　36

Remarque : La fonction intégrée print() de Swift accepte également des arguments variables de tout type.

Any représente tout type de données Swift, par exemple Int, Float, Double, String, etc.

Fonction avec paramètres d'entrée et de sortie

Lors de la définition des paramètres de la fonction, vous ne pouvez pas modifier les paramètres de la fonction à l'intérieur. Par conséquent, par défaut, ils sont des constantes. Regardons un exemple :

func process(name: String) {
　　　　if name == ""{
　　　　　　　　name = "guest"
　　　　}
}

Le programme ci-dessus entraînera une erreur à la compilation car vous ne pouvez pas modifier la valeur du paramètre.

Si vous souhaitez que la fonction modifie la valeur du paramètre, vous devez définir le paramètre en tant que in-paramètre de sortie. Vous pouvez écrire un paramètre en entrée et en sortie en plaçant la clé inout devant le type de paramètre./paramètre de sortie.

En arrière-plan, un-Le paramètre de sortie a une valeur, cette valeur est transmise à la fonction, modifiée par la fonction, puis transmise à nouveau à partir de la fonction pour remplacer la valeur originale. Par conséquent, la valeur transmise dans l'appel de la fonction ne peut pas être une constante. Vous devez la déclarer en tant que variable.

La syntaxe des fonctions avec paramètres inout est :

func funcname(parameterName: inout Type)　-> Type de retour {
　　　　//Instructions
}

Exemple12：Fonction avec paramètre inout

func process(name: inout String) {　
　　　　if name == ""{
　　　　　　　　name = "guest"
　　　　}
}
var userName = ""
process(name: &userName)
print(userName)

Lorsque vous exécutez le programme ci-dessus, la sortie sera :

guest

Dans le programme ci-dessus, nous avons déclaré une fonction acceptant un paramètre inout afin que nous puissions le modifier/Modifier le paramètre name.

Lorsque vous passez des paramètres à in-Lorsque vous passez un paramètre en tant que paramètre de sortie, vous devez utiliser directement le symbole & avant le nom de la variable, afin que la fonction puisse le modifier.