C'est un complément à ceci :
Précis Sur Les Variables Locales/globales
Je remercie STEVEN de me laisser le choix des couleurs pour ses tutos
Pour la variable avec une portée globale et les passages de paramètres, voici une explication et un petit script pour bien comprendre son fonctionnement.
Notion de base sur le passage de paramètre :
Les paramètres d'une fonction peuvent être de 2 manières différentes (par référence ou par valeur) :
- référence : la fonction reçoit l'adresse mémoire du paramètre. Un changement de valeur affectera TOUT le script
- valeur : on reçoit la valeur du paramètre Ce dernier est copié dans une nouvelle référence propre à la fonction. Un changement de valeur n'affectera que la fonction.
en LUA, chaque passage de paramètre ce fait en "valeur" SAUF pour les tables (c'est comme en français, il y a toujours une exception).
Donc si je fais :
function maFonction(var)
print(var)
end
maFonction("Coucou")
J'envoi à ma fonction la valeur, soit une copie de "Coucou".
Si a l'intérieur de maFonction je modifie la valeur, cela n'aura un impact QU'AU sein de maFonction.
maFonction va donc créer une nouvelle variable "var" dans laquelle il va copier la valeur "Coucou"
Si je fais :
local coucou = "Coucou"
function maFonction()
print(coucou)
end
et que dans maFonction je modifie coucou,
alors coucou va être modifié pour tout le script puisque la modification aura eu lieu sur sa référence.
En bref,
Si on est au sein d'un script ou d'une fonction, nous travaillons sur les références.
Si nous passons les informations en tant que paramètre, nous travaillons sur une valeur.
local coucou = "Coucou"
function maFonction(variable)
print(coucou)
print(variable)
end
maFonction("Coucou")
Plus compliqué car la référence coucou est envoyée en paramètre et devient donc une copie de valeur.
local coucou = "Coucou"
function maFonction(variable1, variable2)
print(variable1)
print(variable2)
end
maFonction("Coucou", coucou
Allez un bon script vaut mieux qu'un long discours :
function scope1()
-- la variable var n'existe pas
print(var) --- nil (variable inexistante)
end
function scope2(var)
-- la variable est passée en paramètres donc visible
-- bien que déclarée après
-- En sortant de cette méthode, var aura repris ça valeur
-- initial car elle a été passée en paramètre soit par
-- valeur
print(var .. " dans scope2()") -- ______
var = "Scope2"
print(var) -- Scope2
end
local var = "-=init=-"
function scope3()
-- la variable est connue car déclarée avant. Elle est assignable
-- par contre, si on déclare une variable du même nom au sein
-- de cette même function, en sortant la variable aura repris sa valeur "Scope3"
print(var .. " dans scope3()")
var = "Scope3"
print(var)
local var = "Byebye"
print(var)
end
function exception(unTableau)
-- Les tableaux sont toujours traité comme une référence
unTableau[1] = "Et voilà "
end
print(var .. " avant tout")
scope1()
print(var .. " après scope1()")
scope2(var)
print(var .. " après scope2()")
scope3()
print(var .. " après scope3()")
-- Exception avec les table qui sont toujours envoyé en tant que référence.
local table = {[1]="Humm"}
print(table[1])
exception(table)
print(table[1])
Debug :
[DEBUG] 11:39:22: -=init=- avant tout
[DEBUG] 11:39:22: nil
[DEBUG] 11:39:22: --init=- après scope1()
[DEBUG] 11:39:22: --init=- dans scope2()
[DEBUG] 11:39:22: Scope2
[DEBUG] 11:39:22: -=init=- après scope2()
[DEBUG] 11:39:22: -=init=- dans scope3()
[DEBUG] 11:39:22: Scope3
[DEBUG] 11:39:22: Byebye
[DEBUG] 11:39:22: Scope3 après scope3()
[DEBUG] 11:39:22: Humm
[DEBUG] 11:39:22: Et voilà