Elixir - Fonctions

Une fonction est un ensemble d'instructions organisées ensemble pour effectuer une tâche spécifique. Les fonctions de programmation fonctionnent principalement comme des fonctions en mathématiques. Vous donnez une entrée aux fonctions, elles génèrent une sortie basée sur l'entrée fournie.

Il existe 2 types de fonctions dans Elixir -

Fonction anonyme

Fonctions définies à l'aide du fn..end constructsont des fonctions anonymes. Ces fonctions sont parfois également appelées lambdas. Ils sont utilisés en les affectant à des noms de variables.

Fonction nommée

Fonctions définies à l'aide du def keywordsont des fonctions nommées. Ce sont des fonctions natives fournies dans Elixir.

Fonctions anonymes

Tout comme son nom l'indique, une fonction anonyme n'a pas de nom. Celles-ci sont fréquemment transmises à d'autres fonctions. Pour définir une fonction anonyme dans Elixir, nous avons besoin dufn et endmots clés. Dans ceux-ci, nous pouvons définir n'importe quel nombre de paramètres et de corps de fonction séparés par->. Par exemple,

sum = fn (a, b) -> a + b end
IO.puts(sum.(1, 5))

Lors de l'exécution du programme ci-dessus, est exécuté, il génère le résultat suivant -

6

Notez que ces fonctions ne sont pas appelées comme les fonctions nommées. Nous avons un '.'entre le nom de la fonction et ses arguments.

Utilisation de l'opérateur de capture

Nous pouvons également définir ces fonctions à l'aide de l'opérateur de capture. C'est une méthode plus simple pour créer des fonctions. Nous allons maintenant définir la fonction somme ci-dessus à l'aide de l'opérateur de capture,

sum = &(&1 + &2) 
IO.puts(sum.(1, 2))

Lorsque le programme ci-dessus est exécuté, il génère le résultat suivant -

3

Dans la version abrégée, nos paramètres ne sont pas nommés mais nous sont disponibles sous les noms & 1, & 2, & 3, etc.

Fonctions de correspondance de modèles

La correspondance de modèles n'est pas seulement limitée aux variables et aux structures de données. Nous pouvons utiliser la correspondance de motifs pour rendre nos fonctions polymorphes. Par exemple, nous allons déclarer une fonction qui peut prendre 1 ou 2 entrées (dans un tuple) et les imprimer sur la console,

handle_result = fn
   {var1} -> IO.puts("#{var1} found in a tuple!")
   {var_2, var_3} -> IO.puts("#{var_2} and #{var_3} found!")
end
handle_result.({"Hey people"})
handle_result.({"Hello", "World"})

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

Hey people found in a tuple!
Hello and World found!

Fonctions nommées

Nous pouvons définir des fonctions avec des noms afin que nous puissions facilement nous y référer ultérieurement. Les fonctions nommées sont définies dans un module à l'aide du mot-clé def. Les fonctions nommées sont toujours définies dans un module. Pour appeler des fonctions nommées, nous devons les référencer en utilisant leur nom de module.

Voici la syntaxe des fonctions nommées -

def function_name(argument_1, argument_2) do
   #code to be executed when function is called
end

Définissons maintenant notre fonction nommée somme dans le module Math.

defmodule Math do
   def sum(a, b) do
      a + b
   end
end

IO.puts(Math.sum(5, 6))

Lors de l'exécution du programme ci-dessus, il produit le résultat suivant -

11

Pour les fonctions à 1 ligne, il existe une notation abrégée pour définir ces fonctions, en utilisant do:. Par exemple -

defmodule Math do
   def sum(a, b), do: a + b
end
IO.puts(Math.sum(5, 6))

Lors de l'exécution du programme ci-dessus, il produit le résultat suivant -

11

Fonctions privées

Elixir nous offre la possibilité de définir des fonctions privées accessibles depuis le module dans lequel elles sont définies. Pour définir une fonction privée, utilisezdefp au lieu de def. Par exemple,

defmodule Greeter do
   def hello(name), do: phrase <> name
   defp phrase, do: "Hello "
end

Greeter.hello("world")

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

Hello world

Mais si nous essayons simplement d'appeler explicitement la fonction de phrase, en utilisant le Greeter.phrase() fonction, cela provoquera une erreur.

Arguments par défaut

Si nous voulons une valeur par défaut pour un argument, nous utilisons la argument \\ value syntaxe -

defmodule Greeter do
   def hello(name, country \\ "en") do
      phrase(country) <> name
   end

   defp phrase("en"), do: "Hello, "
   defp phrase("es"), do: "Hola, "
end

Greeter.hello("Ayush", "en")
Greeter.hello("Ayush")
Greeter.hello("Ayush", "es")

Lorsque le programme ci-dessus est exécuté, il produit le résultat suivant -

Hello, Ayush
Hello, Ayush
Hola, Ayush