|
Documentation language LUA |
Les fonctions en LUA |
Définir des fonctions
Déclarations
de fonction
Arguments
Fonctions anonymes
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 une langue 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 comment nous n'avons pas la
complication du type déclarations de fonction ou ne
devons pas le dire à Lua 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 de l'objet affecté à lui.
> 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 des erreurs explicite comme dans des language typé statiquement Cependant, cette fonctionnalité est très utile et nous permet d'écrire le code très flexible 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", que nous pouvons voir a le type
"function" :
> function foo()
>>
print("foo!")
>> end
>
> foo()
foo!
> = type(foo) -- what type is foo?
function
Puisqu' 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 par 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, ou devez vous inquiéter de la façon dont des arguments seront passés. C'est parce que Lua est un language typé dynamiquement où une variable peut pointer sur 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 |
|