Swift - Fonctions

Une fonction est un ensemble d'instructions organisées ensemble pour effectuer une tâche spécifique. Une fonction Swift 4 peut être aussi simple qu'une simple fonction C à aussi complexe qu'une fonction de langage Objective C. Cela nous permet de passer des valeurs de paramètres locaux et globaux dans les appels de fonction.

Function Declaration - informe le compilateur du nom, du type de retour et des paramètres d'une fonction.
Function Definition - Il fournit le corps réel de la fonction.

Les fonctions Swift 4 contiennent le type de paramètre et ses types de retour.

Définition de fonction

Dans Swift 4, une fonction est définie par le mot clé "func". Lorsqu'une fonction est nouvellement définie, elle peut prendre une ou plusieurs valeurs comme «paramètres» d'entrée de la fonction et elle traitera les fonctions dans le corps principal et retournera les valeurs aux fonctions en tant que «types de retour» de sortie.

Chaque fonction a un nom de fonction, qui décrit la tâche exécutée par la fonction. Pour utiliser une fonction, vous «appelez» cette fonction avec son nom et passez des valeurs d'entrée (appelées arguments) qui correspondent aux types de paramètres de la fonction. Les paramètres de fonction sont également appelés «tuples».

Les arguments d'une fonction doivent toujours être fournis dans le même ordre que la liste des paramètres de la fonction et les valeurs de retour sont suivies de →.

Syntaxe

func funcname(Parameters) -> returntype {
   Statement1
   Statement2
   ---
   Statement N
   return parameters
}

Jetez un œil au code suivant. Le nom de l'étudiant est déclaré en tant que type de données chaîne déclaré à l'intérieur de la fonction 'étudiant' et lorsque la fonction est appelée, elle renvoie le nom de l'étudiant.

func student(name: String) -> String {
   return name
}

print(student(name: "First Program"))
print(student(name: "About Functions"))

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

First Program
About Functions

Appeler une fonction

Supposons que nous ayons défini une fonction appelée 'affichage' à Considérer par exemple pour afficher les nombres une fonction avec le nom de fonction 'affichage' est initialisée en premier avec l'argument 'no1' qui contient un type de données entier. Ensuite, l'argument 'no1' est affecté à l'argument 'a' qui ci-après pointera vers le même entier de type de données. Maintenant, l'argument «a» est renvoyé à la fonction. Ici, la fonction display () contiendra la valeur entière et retournera les valeurs entières à chaque fois que la fonction est appelée.

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

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

Lorsque nous exécutons le programme ci-dessus en utilisant le terrain de jeu, nous obtenons le résultat suivant -

100
200

Paramètres et valeurs de retour

Swift 4 fournit des paramètres de fonction flexibles et ses valeurs de retour allant des valeurs simples aux valeurs complexes. Semblables à celles de C et d'Objective C, les fonctions de Swift 4 peuvent également prendre plusieurs formes.

Fonctions avec paramètres

Une fonction est accessible en passant ses valeurs de paramètre au corps de la fonction. Nous pouvons passer une à plusieurs valeurs de paramètres sous forme de tuples à l'intérieur de la fonction.

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

Lorsque nous exécutons le programme ci-dessus en utilisant le terrain de jeu, nous obtenons le résultat suivant -

40
45
120

Fonctions sans paramètres

Nous pouvons également avoir des fonctions sans aucun paramètre.

Syntaxe

func funcname() -> datatype {
   return datatype
}

Voici un exemple ayant une fonction sans paramètre -

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Alice

Fonctions avec valeurs de retour

Les fonctions sont également utilisées pour renvoyer des valeurs de type de données chaîne, entier et flottant comme types de retour. Pour trouver le plus grand et le plus petit nombre dans un tableau donné, la fonction «ls» est déclarée avec des types de données entiers grands et petits.

Un tableau est initialisé pour contenir des valeurs entières. Ensuite, le tableau est traité et chaque valeur du tableau est lue et comparée pour sa valeur précédente. Lorsque la valeur est inférieure à la précédente, elle est stockée dans un 'petit' argument, sinon elle est stockée dans un 'grand' argument et les valeurs sont renvoyées en appelant la fonction.

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Largest number is: 98 and smallest number is: -5

Fonctions sans valeurs de retour

Certaines fonctions peuvent avoir des arguments déclarés à l'intérieur de la fonction sans aucune valeur de retour. Le programme suivant déclarea et bcomme arguments de la fonction sum (). à l'intérieur de la fonction elle-même les valeurs des argumentsa et b sont passés en appelant la fonction appel sum () et ses valeurs sont imprimées, éliminant ainsi les valeurs de retour.

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)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

30 20
50 40
30 24

Fonctions avec types de retour facultatifs

Swift 4 introduit une fonction «optionnelle» pour se débarrasser des problèmes en introduisant une mesure de sécurité. Considérez par exemple que nous déclarons le type de retour des valeurs de fonction sous forme d'entier, mais que se passera-t-il lorsque la fonction renvoie une valeur de chaîne ou une valeur nulle. Dans ce cas, le compilateur renverra une valeur d'erreur. «facultatifs» sont introduits pour se débarrasser de ces problèmes.

Les fonctions optionnelles prendront deux formes «valeur» et «nil». Nous mentionnerons 'Optionals' avec le caractère clé réservé '?' pour vérifier si le tuple renvoie une valeur ou une valeur nulle.

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

Lorsque nous exécutons le programme ci-dessus en utilisant le terrain de jeu, nous obtenons le résultat suivant -

min is -6 and max is 109

«Les options» sont utilisées pour vérifier les valeurs «nil» ou inutiles, ce qui prend beaucoup de temps dans le débogage et rend le code efficace et lisible pour l'utilisateur.

Fonctions Noms des paramètres locaux et externes

Noms des paramètres locaux

Les noms de paramètres locaux sont accessibles uniquement à l'intérieur de la fonction.

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

Ici le funcsample argument number est déclaré comme variable interne car il est accédé en interne par la fonction sample (). Ici, le 'nombre' est déclaré comme variable locale mais la référence à la variable est faite en dehors de la fonction avec l'instruction suivante -

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

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

1
2
3

Noms des paramètres externes

Les noms de paramètres externes nous permettent de nommer des paramètres de fonction pour rendre leur objectif plus clair. Par exemple ci-dessous, vous pouvez nommer deux paramètres de fonction, puis appeler cette fonction comme suit -

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)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Paramètres variadiques

Lorsque nous voulons définir une fonction avec plusieurs nombres d'arguments, nous pouvons déclarer les membres en tant que paramètres «variadiques». Les paramètres peuvent être spécifiés comme variadiques par (···) après le nom du paramètre.

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

4
3
5
4.5
3.1
5.6
Swift 4
Enumerations
Closures

Paramètres constants, variables et E / S

Les fonctions par défaut considèrent les paramètres comme «constants», tandis que l'utilisateur peut également déclarer les arguments des fonctions comme des variables. Nous avons déjà discuté du fait que le mot clé 'let' est utilisé pour déclarer des paramètres constants et que les paramètres variables sont définis avec le mot clé 'var'.

Les paramètres d'E / S dans Swift 4 fournissent des fonctionnalités pour conserver les valeurs de paramètre même si ses valeurs sont modifiées après l'appel de la fonction. Au début de la définition du paramètre de fonction, le mot-clé 'inout' est déclaré pour conserver les valeurs de membre.

Il dérive le mot-clé 'inout' puisque ses valeurs sont passées 'in' à la fonction et ses valeurs sont accédées et modifiées par son corps de fonction et il est renvoyé 'out' de la fonction pour modifier l'argument d'origine.

Les variables ne sont transmises qu'en tant qu'argument pour le paramètre in-out puisque ses valeurs seules sont modifiées à l'intérieur et à l'extérieur de la fonction. Il n'est donc pas nécessaire de déclarer des chaînes et des littéraux en tant que paramètres d'entrée-sortie. «&» avant un nom de variable fait référence au fait que nous transmettons l'argument au paramètre 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)")

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Swapped values are 10, 2

Types de fonction et son utilisation

Chaque fonction suit la fonction spécifique en considérant les paramètres d'entrée et sort le résultat souhaité.

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

Voici un exemple -

func inputs(no1: Int, no2: Int) -> Int {
   return no1/no2
}

print(inputs(no1: 20, no2: 10))
print(inputs(no1: 36, no2: 6))

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

2
6

Ici la fonction est initialisée avec deux arguments no1 et no2 en tant que types de données entiers et son type de retour est également déclaré comme 'int'

Func inputstr(name: String) -> String {
   return name
}

Ici, la fonction est déclarée comme string Type de données.

Les fonctions peuvent également avoir void les types de données et ces fonctions ne renverront rien.

func inputstr() {
   print("Swift 4 Functions")
   print("Types and its Usage")
}
inputstr()

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Swift 4 Functions
Types and its Usage

La fonction ci-dessus est déclarée comme une fonction void sans arguments ni valeurs de retour.

Utilisation des types de fonction

Les fonctions sont d'abord passées avec des arguments de type entier, flottant ou chaîne, puis elles sont passées sous forme de constantes ou de variables à la fonction comme indiqué ci-dessous.

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

Ici, sum est un nom de fonction ayant des variables entières 'a' et 'b' qui est maintenant déclarée comme une variable à l'ajout de nom de fonction. Par la suite, les fonctions d'addition et de somme ont toutes deux le même nombre d'arguments déclarés comme type de données entier et renvoient également des valeurs entières comme références.

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Result: 129

Types de fonction en tant que types de paramètres et types de retour

Nous pouvons également passer la fonction elle-même en tant que types de paramètres à une autre fonction.

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)

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

Result: 129
Result: 30

Fonctions imbriquées

Une fonction imbriquée offre la possibilité d'appeler la fonction externe en invoquant la fonction interne.

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

Lorsque nous exécutons le programme ci-dessus en utilisant aire de jeux, nous obtenons le résultat suivant -

-30