|
Programmation en language LUA | |
Appel de fonction |
Il est recommandé de lire préalablement le chapître Fonctions.
Puisque Lua est typé dynamiquement et n'a aucun besoin de déclaration de type pour les fonction, la vérification du nombre et des types d'arguments exigés pour une fonction semble quelque peu superflue.
Lua sait gérér avec élégance un nombre mal
adaptés d'arguments et les appels d'arguments formels.
Les
arguments formels de fonction reçoivent une valeur par défaut à nil s'ils
ne sont pas remplis. Là où trop d'arguments
sont passés ils sont simplement ignorés.
Aucun type n'est indiqué pour chaque argument car ils sont typés dynamiquement c.-à-d. que nous devont seulement connaître le type d'un objet quand nous l'employons, pas quand nous le mettons en référence. Nous emploierons la fonction suivante comme exemple :
> function foo(a,b,c) print(a,b,c) end
Voici ce qui se produit quand nous l'appelons sans arguments :
> foo()
nil nil nil
Notez que chacun des arguments
s'est assigné la valeur nil, ou aucune valeur,
et nous n'avons pas d'erreur. Voici ce qui se produit quand nous
passons trop
d'arguments :
> foo(1,2,3,4)
1 2 3
Aucune erreur de constatée et le dernier argument est simplement ignoré. Puisque Lua est typé dynamiquement nous pouvons passer n'importe quel type d'argument, nous pouvons passer par exemple aussi bien des chaînes de caractères que des nombres.
> foo("hello")
hello nil nil
>
foo("pi", 3.1415, { comment="this is a table" })
pi 3.1415 table: 002FDBE8
Il est souvent utile d'avoir un nombre variables
d'arguments pour une fonction, comme par exemple pour la
fonction
en C printf(format,...) . Lua fait ceci, dans les versions avant 5.1, en plaçant la liste
variable d'argument dans une rangée de table appelée arg,
utilisable par la fonction, par exemple:
> function foo(...) print(arg) end
>
foo("abc",3,77)
table: 002FD3B8
Dans cet exemple nous pouvons seulement voir que c'est une table.
Nous pouvons employer table.foreach(table,function) pour afficher
les valeurs de la table d'arguments, ainsi :
> function foo(...) table.foreach(arg,print) end
>
foo()
n 0
En regardant une liste vide de variable d'arguments, il est facile de voir
qu'une paire supplémentaire de table est ajoutée
pour fournir le nombre d'éléments dans la table arg.n. Dans ce
cas-ci le nombre d'arguments est zéro. Essayons de passer un nombre variable
d'arguments :
> foo(1,2,3)
1 1
2 2
3 3
n 3
>
foo("apple",2,"banana",99,3.1415927,foo)
1 apple
2 2
3 banana
4 99
5 3.1415927
6 function: 002FB5C8
n 6
Une fonction utile pour des arguments variables
est unpack(). Ceci prend une table et renvoie une liste de
variables, par exemple :
= unpack({1,2,3})
1 2 3
Ceci peut être employé avec les listes variables d'argument comme suit :
function listargs(...)
>> return unpack(arg)
>> end
> = listargs(1,2,3)
1 2 3
>
= listargs("hello", {1,2,3}, function (x) return x*x end)
hello table: 0035F0B8 function: 00357860
Lua peut retourner plus d'une valeur à une fonction. Ceci est fait par retour d'une liste séparée par des virgules :
function foo(angle)
>> return math.cos(angle), math.sin(angle)
>> end
>
> print( foo(1) ) -- returns 2 values...
0.54030230586814 0.8414709848079
>
> c,s = foo(3.142/3) -- assign the values to variables
> = math.atan(s/c)
1.0473333333333
> = c,s
0.49988240461137 0.86609328686923
>
> function many(x)
>> return x, x*x, x*x*x, x*x*x*x, x*x*x*x*x
>> end
> = many(5)
5 25 125 625 3125
> = many(0.9)
0.9 0.81 0.729 0.6561 0.59049
La fonction ci-dessus pourrait avoir un nombre
variable de valeurs de retour si nous construisons une table,
contenant les valeurs, et l'utilisation unpack. Par
exemple,
function many2(x,times)
>> local t = { [0]=1 }
>> for i=1,times do t[i] = x*t[i-1] end
>> return unpack(t)
>> end
> = many2(5,10)
5 25 125 625 3125 15625 78125 390625 1953125 9765625
> = many2(0.5,7)
0.5 0.25 0.125 0.0625 0.03125 0.015625 0.0078125
Nous pouvons également renvoyer les valeurs dans une table. Pour faire ceci nous ajoutons les parenthèses bouclées autour de l'appel de fonction, qui construira une table, c.-à-d. :
{ function_name ( args )}
Voici un exemple en utilisant l'exemple précédent de fonction :
= { foo(1.5) }
table: 0035E088
> t = { foo(1.5) }
> table.foreach(t,print)
1 0.070737201667703
2 0.99749498660405
Si une fonction renvoie des valeurs multiples, mais nous voulons seulement la première valeur, nous mettons une parenthèse autour de l'appel de fonction, c.-à-d..
( function_name ( args ))
Voici un exemple :
> = (foo(1.5))
0.070737201667703
> = foo(1.5)
0.070737201667703 0.99749498660405
La même chose pourrait être réalisé en renvoyant une table et en prenant le premier élément mais la syntaxe ci-dessus est plus efficace.
Par exemple:
>
= ({foo(1.5)}) [1]
0.070737201667703
 www.loriotpro.com |
|