|
Programmation en language LUA | |
Portées des variables en LUA |
Les programmes sont morcelés en unités de code, comme pour les fonctions et les modules.
Dans ces unités nous pouvons créer des variables et leur affecter des valeurs de sorte que nous puissions traiter des données et faire que le programme exécute une tâche donnée. Pour un certain nombre de raisons (conflits de noms, information cahée, etc...) nous pouvons vouloir isoler des variables dans les unités. Nous pouvons également vouloir créer des variables provisoires pour une tâche qui peuvent être supprimées une fois celle-ci terminée.
Le terme "unité" est peu un vague. Nous employons le terme portée des variables pour décrire le jeu de code dans lequel un ensemble de variables sont disponible.
Les variables auxquels nous avons accès sont dites visibles. La portée d'une variable est le bloc contenant le code dans lequel elle est visible. Les portées sont créées et détruites pendant que le programme exécute ces blocs de code. Les variables contenues dans ces blocs sont créées et détruites selon les règles décrites ci-après. Quand nous écrivons un bloc et une nouvelle portée nous écrivons une portée locale. Les portées externes sont visibles des portées locale mais pas le contraire.
Dans Lua des blocs de code peuvent être définis en
utilisant des fonctions et les mots-clés do...end par
exemple,
> function foo() local x=1 end
> foo()
> do local y=1 end
L'exemple ci-dessus définit juste une fonction
appelée foo qui contient une portée. Nous créons la
variable x dans la portée locale de la fonction. Quand nous sortons
de la fonction, la portée est finie, la variable x est supprimée
et n'est plus visible. Le bloc do...end contient
la fonctionnalité semblable.
Les variables qui ne sont pas dans un bloc défini sont de portée globale. Tout ce qui est en portée globale est accessible par toutes les portées locales.
> g = "global"
>
print(g)
global
>
function foo() print(g) end
>
foo()
global
Dans l'exemple ci-dessus g est dans
la
portée globale, c.-à-d. aucun bloc enfermant n'est défini. La
fonction foo est également dans la portée globale.
Nous écrivons foo la portée de fonction quand foo() s'appelle.
Nous pouvons imprimer la valeur de g parce que nous pouvons voir
la portée externe de la
portée foo intérieure.
Nous employons le mot-clé local pour
définir toutes les variables qui nous voulons garder locales au bloc de code
dans
lequel elles sont définis.
Note: Toutes les variables déclarées dans Lua sont de portée globale à moins qu'elles n'aient été déclarées en locales. Ceci peut ne pas être le comportement auquel vous êtes habitué. Par exemple dans C et beaucoup d'autres languages, les variables définies dans des portées locales restent dans cette portée.
> a = 1 -- global scope
> function foo() -- start of foo scope
>> b = 2 -- no local keyword so global scope
>> local c = 3 -- local scope
>> end -- end of foo scope
> print(a,b,c) -- before we call foo
1 nil nil
> foo()
> print(a,b,c) -- after foo called
1 2 nil
Quand nous créons un bloc nous créons une portée dans laquelle les variables peuvent vivre par exemple.
> do local seven = 7 print(seven) end
7
>
print(seven)
nil
Dans l'exemple ci-dessus le bloc do et end enferme
la déclaration de la variable locale seven.
Vous constatez que nous pouvons afficher sa valeur, 7. Quand nous
sortons de la portée au mot-clé end nous perdons la visibilité des
variables locales dans cette portée. Quand nous affcihons la
valeur seven une fois en dehors de la portée nous
obtenons nil. Ceci signifie "variable non trouvée".
Le mot-clé local est placé avant variable que nous
voulons laisser visible seulement dans cette portée.
Dans l'exemple suivant x commence par la valeur
1. Nous créons un bloc avec les mots-clés do et end.
Nous employons le mot-clé local pour indiquer que nous voulons une
nouvelle variable également
appelée x, qui est
seulement visible dans ce bloc ou portée.
> x = 1
> print(x)
1
> do
>> local x
>> x = 2
>> print(x)
>> end
2
> print(x)
1
Vous pouvez voir qu'une fois que la
portée do...end est fini,
la deuxième affectation de x disparaît et nous retournons
de nouveau à la précédente affectation.
Le mot-clé local peut être employé dans toutes
les portée, portées non simplement locales et de fonction.
Ceci pourrait sembler unintuitive mais même la portée globale
dans Lua peut devenir une portée local si elle est employée
comme module.
En raison de l'exécution de Lua il est plus efficace
d'employer des variables local dans la mesure du possible.
La raison technique de ceci est que des variables locales sont
mises en référence par l'intermédiaire d'un "assigned number", tandis
que des variables globales sont stockées dans une table qui est
consultée avec une clef (le nom de variable). Les consultations de
Tableau sont très rapidet dans Lua, mais cependant pas aussi
rapide que des consultations locales de registre.
Si le code suivant est compilé nous pouvons regarder comment Lua génère les instructions virtuelles de sortie.
g = "global"
local l = "local"
print(g,l)
La ligne de commande outil luac (compilateur de Lua) peut être employée pour compiler
le code, qui donne :
main <a.lua:0> (8 instructions, 32 bytes at 00355578)
0 params, 4 stacks, 0 upvalues, 1 local, 4 constants, 0 functions
1 [2] LOADK 0 1 ; "global"
2 [2] SETGLOBAL 0 0 ; g
3 [4] LOADK 0 2 ; "local"
4 [6] GETGLOBAL 1 3 ; print
5 [6] GETGLOBAL 2 0 ; g
6 [6] MOVE 3 0 0
7 [6] CALL 1 3 1
8 [6] RETURN 0 1 0
Nous n'entrerons pas dans le détail de ce
sujet mais vous pouvez voir que les variables g et l sont
traité différemment, et que
l'accès aux variable de portée locale est plus efficace.
 www.loriotpro.com |
|