Tutoriel Lua: Les fonctions - Les variables non-globales.

Les fonctions: Les variables non-globales.

Une conséquence évidente des fonctions LUA, est de pouvoir être stockées non seulement dans les variables globales, mais aussi dans le champs des tables et dans les variables locales.

La plupart des bibliothèques LUA utilisent ce mécanisme de fonctions contenues dans des tables. (io.read, math.sin ...)

Pour créer de telles fonctions dans Lua, vous devez utiliser la syntaxe habituelle pour les fonctions et les tables.

	Librairie = {}
	Librairie.f1 = function (x, y) return x + y end
	Librairie.f2 = function (x, y) return x - y end
	
	-- ou de la façon suivante
	
	Librairie = {
	f1 = function (x, y) return x + y end,
	f2 = function (x, y) return x - y end
			}

Lorsque vous enregistrez une fonction dans une variable locale, vous obtenez une fonction locale.

Une fonction local est limitée au domaine du bloc qui la contient.

Ces définitions sont particulièrement utiles pour les packages (paquets).

Lua gère chaque bloc comme une fonction et un bloc peut déclarer des fonctions locales, qui ne seront visibles qu'à l'intérieur du bloc.

La portée lexicale veille à ce que d'autres fonctions dans le package puissent utiliser ces fonctions locales.

	local f = function (...)
	  ...
	end
						  
	local g = function (...)
	  ...
	f() -- local "f" est visible ici
	  ...
	end

Un point subtil se pose dans la définition des fonctions locales récursives.

	local fact = function (n
	  if n == 0 then return 1
	  else return n * fact(n-1) -- BUG
	  end
	end

Lorsque Lua compile fact(n-1), dans le corps de la fonction, la variable locale fact n'est pas encore définie.
Par conséquent, cette expression appelle une variable globale, et non locale.
Pour résoudre ce problème, vous devrez d'abord définir la variable locale et ensuite définir la fonction.

	local fact = nil				
	fact = function (n)
	  if n == 0 then return 1
	  else return n * fact(n-1)
	  end
	end

Maintenant, fact est à l'intérieur de la fonction qui fait bien référence à la variable locale.

Sa valeur, lorsque la fonction est définie n'a aucune importance, au moment où la fonction s'exécute, fact a déjà la bonne valeur.

D'ou l'importance de définir d'abord la variable " f " (local f = nil), puis de lui affecter la fonction. (f = function() ... end.)

	local function fact (n)
	  if n == 0 then return 1
	  else return n * fact(n-1)
	  end
	end

Bien entendu, l'exemple précédent ne fonctionne pas, puisque vous utilisez une fonction récursive indirecte.

Dans de tels cas, vous devez utiliser l'équivalent d'une déclaration anticipée explicite.

	local f, g    -- déclaration anticipée			    
	function g ()
	  ...  f() ...
	end
							 
	function f ()
	  ...  g() ...
	end