Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

passageparametres [21.05.2015 11:18] (Version actuelle)
Steven Piccand créée
Ligne 1: Ligne 1:
 +====== LUA Passage de paramètres ======
 +
 +__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) : 
 +  * <fc #​4682b4>​référence</​fc>​ : la fonction reçoit l'​adresse mémoire du paramètre. Un changement de valeur affectera TOUT le script
 +  * <fc #​dda0dd>​valeur</​fc>​ : 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
 +
 +<​code>​
 +function maFonction(var)
 +  print(var)
 +end
 +maFonction("​Coucou"​)
 +</​code>​
 +
 +j'​envoi à ma fonction la valeur, soit une copie de "​Coucou"​. Si à 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
 +<​code>​
 +local coucou = "​Coucou"​
 +function maFonction()
 +   ​print(coucou)
 +end
 +</​code>​
 +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.
 +<​code>​
 +local coucou = "​Coucou"​
 +function maFonction(variable)
 +   ​print(coucou)
 +   ​print(variable)
 +end
 +maFonction("​Coucou"​)
 +</​code>​
 +Plus compliqué car la référence coucou est envoyée en paramètre et devient donc une copie de valeur.
 +<​code>​
 +local coucou = "​Coucou"​
 +function maFonction(variable1,​ variable2)
 +   ​print(variable1)
 +   ​print(variable2)
 +end
 +maFonction("​Coucou",​ coucou)
 +</​code>​
 +
 +Allez un bon script vaut mieux qu'un long discours :
 +
 +<code lua>
 +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])
 +</​code>​
 +<code lua>
 +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à
 +</​code>​