Définitions de fonctions
Sans doute un des concepts les plus intéressants : les définitions de fonctions.
Les fonctions que nous allons définir fonctionneront exactement comme les fonctions pré-définies de Neon, et la syntaxe pour les appeler sera donc la même.
Voyons donc comment en définir :
function maFonction(arg1,arg2) do # on met le nombre d'arguments que l'on veut
instructions
end
Cette fonction est une fonction qui ne renvoie rien, ce que l'on appelle une procédure.
arg1 et arg2 sont des variables crées lors de l'appel à la fonction et contiennent une copie des arguments envoyés par l'utilisateur.
Vous pouvez donc les utiliser, mais si vous les modifiez, cela n'aura pas d'impact en dehors de la fonction.
Le nombre d'arguments est bien sûr illimité.
Dans la fonction, vous pouvez faire ce que vous voulez. Il faut seulement savoir que toutes les variables que vous créerez à l'intérieur de la fonction seront supprimées juste après la fin de la fonction, vous ne pouvez donc pas les utiliser en dehors de la fonction.
Voyons maintenant comment retourner un résultat à la fin de la fonction : sinon, ce n'est pas très intéressant.
Pour ce faire, imaginons qu'à un moment de la fonction, vous avez terminé, et vous voulez quitter en renvoyant un résultat. Il vous suffit simplement d'écrire à cet endroit :
return (resultat)
Il faut savoir qu'une fonction a deux moyen de se terminer :
- Ou on arrive à la fin de des instructions de la fonction, donc elle quitte normalement et ne renvoie rien. C'est comme ça que termine l'exemple vu plus haut.
- Ou on rencontre un return lors de l'exécution.
Définissons ensemble une petite fonction très simple qui retourne un résultat :
function racine_carree(x) do
return (x**0.5)
end
En effet mathématiquement, la racine carrée d'un nombre est équivalente à la mise à la puissance 1/2.
Pour bien comprendre les fonctions, il faut également bien comprendre le concept de portée d'une variable.
En effet, quand on crée une variable, on peut l'utiliser partout ailleurs dans le programme sans problèmes. C'est ce qu'on appelle une variable locale. Mais dans les fonctions, on peut avoir besoin d'utiliser des variables locales.
Une variable locale à une fonction est une variable dont la valeur n'est définie que dans la fonction où vous la créez, et dans les fonctions que vous appellerez à l'intérieur. En réalité, on ne "crée" pas de variable locale, mais on transforme une variable globale en variable locale.
Ainsi, quand vous transformez une variable globale en locale, c'est comme si on créait une deuxième variable du même nom, qui devenait prioritaire par rapport à l'ancienne variable. A la fin de la fonction, cette deuxième variable est supprimée, et on accède de nouveau à l'ancienne variable.
Nous pouvons étendre cela à une infinité d'appels de fonction successifs. Dans une fonction peu import le nombre de variables locales du même nom, si plusieurs variables ont le même nom, on accèdera toujours à dernière la variable créée.
Pour rendre une variable locale, (à condition que cette variable existe déjà), il suffit d'écrire l'instruction suivante :
local(maVariable) # pour une variable
local(var1, var2, ...) # pour mettre les variables var1, var2, ... en locales
A chaque appel d'une fonction, tous les arguments de la fonction sont transformés en variables locales.
Ainsi, l'exécution de cette fonction :
a = 18
function (a) do
print(a)
end
f(5)
print(a)
Affiche :
5
18
Il est nécessaire à ce stade-là de bien saisir toute la puissance et toute l'utilité de local (). Pour cela, observez cet exemple :
function f(x) do
i = 2
return ( x * i )
end
i = 18
print(f(5) + i)
Que va-t-il se passer à votre avis ?
Tout d'abord, la variable i va prendre la valeur 18. Puis lors de l'appel à f(5), i va prendre la valeur 2, et le résultat final sera 10 + 2 et non pas 10 + 18.
Les variables non locales des fonctions peuvent interférer avec d'autres variables.
La bonne manière de programmer la fonction f est donc celle-ci :
function f(x) do
local(i)
i = 2
return ( x * i )
end
Ainsi, seulement le i de la fonction vaudra 2. La valeur précédente de i sera préservée et restaurée à la fin de la fonction.
Vous avez maintenant tout ce dont vous avez besoin pour définir des fonctions. Passons donc aux méthodes, qui en sont simplement une variante.
Comme je vous l'ai dit, dans une fonction, les arguments que l'on manipule sont en réalité des copies des arguments envoyés par l'utilisateur. On ne peut donc pas modifier directement les variables envoyées par l'utilisateur depuis une fonction, ce qui pourrait s'avérer utile.
C'est la raison pour laquelle les méthodes existent.
Définition d'une méthode :
method maMethode(objet, x, y) do
instructions
end
Comme pour les fonctions, vous pouvez bien sûr renvoyer une valeur quand vous voulez.
La particularité ici, est que toutes les modifications que vous apporterez à la variable objet modifieront également la variable envoyée à cette place par l'utilisateur.
Exemple :
x=7
method ajoute1(nombre) do
nombre ++
end
ajoute1(x)
print(x)
Ce programme affiche 8.
Vous vous doutez d'ailleurs bien qu'il est inutile de faire des méthodes à zéro arguments.
Pour les méthodes, vous disposez des variables locales, comme dans les fonctions.
La variable "méthode" est elle aussi passée en variable locale à chaque début de méthode.
Pour vérifier que vous avez bien compris, voici une méthode :
method list_create(list, number) do
if (number == 0) then
return (None)
else
append(list, [])
list_create(list[0], number-1)
end
end
l = []
list_create(l, 5)
print(l)
Étudiez cette méthode, et vous comprendrez pourquoi elle renvoie :
[[[[[]]]]]
D'une manière générale, dès que vous voulez créer une fonction qui manipule un potentiellement gros objet et que vous ne voulez pas de copie de cet objet, alors préférez utiliser une méthode.
Bravo, vous savez maintenant programmer en Neon ! La page suivante est là pour vous apporter des compléments si vous en voulez plus.