Tutoriel Lua: Les fonctions - Le mot clé "return", la fausse variable et la fonction "unpack".

Les fonctions: Le mot clé return, la fausse variable et la fonction unpack.

Les fonctions écrites en LUA peuvent retourner plusieurs résultats les uns à la suite des autres.
Il suffit de tous les énumérer après le mot clé return.

Encore faut-il ne pas oublier de spécifier à la fonction, où elle doit retourner ce qu'on lui demande de retourner.

Généralement cela se passe de la façon suivante:

	function NomFonction(arg1, arg2)
	  -- Corps de la fonction qui calcul x et y
	  return x, y
	end
	
	local var1, var2 = 0, 0	-- Affectation multiple
	
	var1, var2 = NomFonction(param1, param2)	-- Appel de la fonction

Les variables var1 et var2 attendent chacune une valeur en retour de la fonction. Elle recevront respectivement x et y. ( var1 = x et var2 = y ).

1ère règle: LUA ajuste le nombre de résultats retournés, en fonction des circonstances de l'appel.

	function Fonction1() end	--> ne retourne rien			
	function Fonction2() return R1 end	--> retourne 1 résultat	
	function Fonction3() return R1, R2 end	--> retourne 2 résultats

2ème règle: La fonction produit autant de résultats que nécessaire afin de correspondre aux variables.

	local x, y, z = 0, 0, 0
	x, y = Fonction3()			--> x = R1 et y = R2		
	x = Fonction3()				--> x = R1 et R2 sera oublié		
	x, y, z = 10, Fonction3()	--> x = 10, y = R1 et z = R2

3ème règle: Une fonction qui n'a pas de résultat, retourne nil.

	local x, y, z = 0, 0, 0			
	x, y = Fonction1()    --> x = nil, y = nil (la fonction n'a pas de return)
	x, y = Fonction2()    --> x = R1, y = nil (la fonction a 1 seul return)
	x, y, z = Fonction3() --> x = R1, y = R2, z = nil (il n'y a pas de 3ème return)

4ème règle: Si le résultat retourné n'a pas de variable, il sera oublié.

	local x, y = 0, 0			
	x, y = Fonction2(), 20      --> x = R1, y = 20
	x, y = Fonction1(), 20, 30  --> x = nil, y = 20 et 30 est oublié

5ème règle: Quand une fonction appelée (Fonction..) est le dernier argument, (ou le seul argument) d'une autre fonction (print), tous les résultats de cette fonction appelée (Fonction..) seront considérés comme arguments.

	print(Fonction1())    		--> 
	print(Fonction2())			--> R1
	print(Fonction3())    		--> R1   R2

	print(Fonction3(), 1)		--> R1   1
	print(Fonction3(), .. "x")	--> R1x

Quand la fonction (ici Fonction3()) apparaît à l'intérieur d'une expression, (les 2 derniers exemples) Lua ajuste le nombre de résultat à 1.
Ainsi dans la dernière ligne, seul R1 sera utilisé pour la concaténation.

6ème règle: Un constructeur de table, peut lui aussi recevoir tous les résultats d'un appel à fonction sans aucun ajustement.

	tableA = {Fonction1()}    --> tableA = {} (tableau vide)
	tableA = {Fonction2()}    --> tableA = {R1}
	tableA = {Fonction3()}    --> tableA = {R1, R2}

Bien évidement, ce comportement ne se produit que lorsque l'appel est le dernier, sinon, tout appel produit un résultat.

	tableA = {Fonction1(), Fonction2(), 4}	
		--> tableA[1] = nil, tableA[2] = R1, tableA[3] = 4

7ème règle: Et pour terminer, la déclaration return f(), qui retourne toutes les valeurs fournies par "f".

	function Fonction(arg)
	  if arg == 0 then return Fonction1()
	  elseif arg == 1 then return Fonction2()
	  elseif arg == 2 then return Fonction3()
	  end
	end

	print(Fonction(1))     --> R1
	print(Fonction(2))     --> R1  R2
	print(Fonction(0))     -- (aucun résultat)
	print(Fonction(3))     -- (aucun résultat)

La fausse variable.

Lorsqu'une fonction retourne plusieurs valeurs et que vous ne souhaitez en conserver qu'un nombre particulier, la solution consiste à utiliser une "fausse" variable défini par "_":

	local _, x, _, _, y, z = NomDeVotreFonction()

Manifestement, cette fonction est prévue pour retourner 6 variables, mais vous ne souhaiter conserver que la 2ème, 5ème et 6ème.

La fonction unpack.

Cette fonction spéciale, écrite en C, reçoit un tableau et retourne comme résultat tous les éléments de ce tableau à partir de l'index de départ, l'index 1.

	print(unpack{10, 20, 30})  	--> 10 20 30
		
	a, b = unpack{10, 20, 30} 	--> a = 10, b = 20 et 30 sera oublié

La fonction unpack permet d'appeler n'importe quelle fonction avec n'importe quel argument.
Si vous voulez appeler la variable function nomFonction() avec comme argument, les éléments situés dans un tableau, il vous suffit de faire:
nomFonction( unpack(nomTableau) ).
L'appel à unpack retourne toutes les valeurs du tableau nomTableau, valeurs qui deviendront les arguments de nomFonction().

	local Recherche = nil
	Recherche = string.find
	tableA = {"hello", "ll"}
		
	print( Recherche(unpack(tableA)))	--> 3 et 4

Un dernier exemple, pour clore ce chapitre.

-- la fonction Calcul reçoit 2 arguments			
local function Calcul(x, y)
  local a = x * y
  local b = x + y
  local c = x - y
  local d = x / y
  
  return a, b, c, d
end  

-- Affectation multiple
 local param1, param2 = 25, 13
 local multi, add, sous, div = 0, 0, 0, 0
 
-- On appelle la fonction Calcul en lui passant 2 paramètres
-- Et on attend que la fonction retourne 4 résultats
 multi, add, sous, div = Calcul(param1, param2)
 
 print(multi, add, sous, div)

La fonction calcul, attend en retour les résultats "multi, add, sous et div"

Tout ce qui est à l'intérieure de Calcul() n'existe plus et l'on récupère grâce au return a, b, c, d nos variables locales précédement définies. ( multi, add, sous, div )