Différences

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

@@ 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>