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 :

-30
Autres extensions