|
Programmation en language LUA | |
Les fonctions en LUA |
Des fonctions peuvent être définies en utilisant le mot-clé function .
Il y
a deux variations dans la manière de déclarer des fonctions :
function function_name (argument) corps end
est le même que :
function_name = function( arguments )
corps end
Ce qui suit est un exemple d'une fonction simple pour doubler un nombre :
> function foo(n) return n*2 end
> = foo(7)
14
Nous définissons une fonction appelée "foo" qui prend un argument simple et renvoie deux fois sa valeur. La fonction ci-dessus pourrait également avoir été écrite :
> foo = function(n) return n*2 end
>
= foo(4)
8
Quand nous définissons une fonction, vous pourriez dire que nous assignons un corps de fonction à une variable. Cette capacité à traiter des fonctions comme nous traiterions tout autre objet que nous pouvons affecter à une variable , implique que les fonctions soient des valeurs de première classe. La variable à laquelle est affectée une fonction a le type fonction. Nous n'avons pas à indiquer un type complexe de fonction à la variable, comme par exemple en utilisant les pointeurs de fonction en C qui contiennent l'argument et le type de l'information de retour.
Dans Lua vous n'avez pas besoin de déclarer des types pour des valeurs retournées par des fonctions ou pour des arguments passés aux fonctions !
Lua est un langage avec un typage dynamique avec les objets de première classe. Ceci signifie que nous découvrons seulement si quelque chose est une fonction quand nous essayons de l'exécuter. Les languages typés statiquement (comme C) doivent connaître les types des variables lors de la compilation.
> x = "onion"
> x()
stdin:1: attempt to call global `x' (a string value)
stack traceback:
stdin:1: in main chunk
[C]: ?
Nous ne pourrions pas appeler l'objet x parce que c'est
une chaîne de caractères. Quand nous assignons la fonction foo à la
variable x,
nous pouvons l'appeler
(comme dans l'exemple précédent).
Remarquez ci-dessous la simplicité de la déclarations de la fonction ou ne devons pas dire à Lua que foo est une fonction.
> x = foo
>
= x(77)
154
Nous
n'avons aucun problème affecter des
fonctions de différents types à la variable x puisque x n'a
aucune notion du type de l'objet qu'il lui est affecté.
> x = function(a,b) return a+b end
>
= x(5,6)
11
>
function x(a,b) return a..b end
>
= x('a','b')
ab
Naturellement nous devons faire attention à ne pas appeler accidentellement des variables de la même manière, car nous n'aurions pas d'erreurs explicites comme dans des languages typés statiquement Cependant, cette fonctionnalité est très utile et nous permet d'écrire du code très flexible et très simplement.
Puisque Lua n'a aucune déclaration de fonction il doit traiter des arguments de fonction et des valeurs de retour d'une façon flexible. Lua supporte des arguments multiples, des liste d'arguments variables et des valeurs de retour multiples. Ceci est couvert en plus détail dans Appel de Fonctions.
Il est parfois utile de définir des fonctions pour exécuter une tâche sans leur donner un nom en les assignant à une variable.
Nous insérerons une définition de
fonction dans une modification de l'exemple ci-dessus. Nous
définirons une fonction pour passer table.foreach() à ce qui pour
la
liste variable d'argument montre chaque clef, sa valeur et le type de
l'objet de valeur :
> function foo(...)
>>
table.foreach(arg, function(key,value)
>>
print(key,value,type(value))
>>
end)
>>
end -- foo
>
foo("apple",2,"banana",3.1415927,foo)
1 apple string
2 2 number
3 banana string
4 3.1415927 number
5 function: 004419E8 function
n 5 number
Remarquez que la fonction n'a aucun nom :
function(key,value)
print(key,value,type(value))
end
Ceci s'appelle une fonction
anonyme. La fonction est définie et au lieu
d'être affecté à une variable, une référence est passée
comme argument table.foreach.
Dans l'exemple suivant nous créons une fonction
appelée "foo", qui comme nous pouvons voir a le type
"function" :
> function foo()
>>
print("foo!")
>> end
>
> foo()
foo!
> = type(foo) -- what type is foo?
function
Puisque foo est juste une référence à
un corps de fonction nous pouvons affecter d'autres variables pour
avoir la même valeur. Nous pouvons également supprimer la
référence à foo pour lui affecter la valeur nil .
Ceci supprime efficacement la variable foo .
> bar = foo -- copy foo's reference to another variable
> foo = nil -- delete the reference to the function body
> = foo
nil
> foo() -- try to invoke the function
stdin:1: attempt to call global `foo' (a nil value)
stack traceback:
stdin:1: in main chunk
[C]: ?
Remarque, si la variable pointe sur le corps de fonction
que nous l'avons défini elle sera inaccessible, et sera supprimée (voir Garbage
Collection).
Dans ce cas nous avons affecté le corps de fonction à la
variable bar, ainsi d'une manière nous avons renommé la
fonction. Mais quand nous plaçons la variable bar à nil,
il n'y a aucune autre variable pointant sur le corps de fonction, et
il
sera
supprimé quand le
garbage collector sera appelé.
> bar() -- bar still points to the same function that foo did
foo!
> bar = nil -- now nothing points to the function so it can be garbage collected
Remarquez que nous n'avons pas dû indiquer les types de fonction, ni nous inquiéter de la façon dont les arguments seront passés. C'est parce que Lua est un language typé dynamiquement où une variable peut pointer sur un objet de n'importe quel type. La variable est juste une référence à un objet et le type vient de l'objet référencé.
 www.loriotpro.com |
|