Portée

Dans scripting, un bloc de code est le corps d'une structure de contrôle ou d'une fonction >.La portée de une variable ou fonction est le bloc de code qui peut y accéder, et il peut être global ou local .Tous les blocs peuvent accéder aux variables et aux fonctions globales.Un bloc peut accéder aux variables et aux fonctions locales dans son bloc parent, mais pas dans l'un de ses blocs enfants.

Les variables et les fonctions ont une portée globale par défaut, mais il est presque toujours préférable de les déclarer avec une portée locale car Luau accède aux variables et aux fonctions locales plus rapidement que les globales.Pour donner un scope local à une variable ou à une fonction, mettez le mot-clé local devant son nom lorsque vous le déclarez.

Les scripts ne peuvent pas accéder aux variables et aux fonctions globales et locales dans d'autres scripts.Si vous voulez partager des valeurs et des fonctions entre les scripts, utilisez ModuleScripts .

local helloWorld = 'Hello World!'
local function printHelloWorld()
	print(helloWorld)
end
printHelloWorld() -- Hello World!

• Le bloc B peut accéder à la variable locale dans le bloc A.
• Le bloc C peut accéder aux variables et aux fonctions locales dans les blocs A et B. * Le bloc A ne peut pas accéder aux variables et aux fonctions locales dans les blocs B ou C.
• Le bloc B ne peut pas accéder à la variable locale dans le bloc C.

Portée globale

Après avoir déclaré une variable ou une fonction globale, n'importe quel bloc de code dans le même script peut y accéder.Les variables et les fonctions ont un domaine d'application global à moins que vous ne les déclariez avec la balise local.

Dans le code suivant, testVar a une portée globale dans la fonction locale testFunc().Lorsque Luau appelle le testFunc(), il attribue testVar la valeur 64 .Le testVar a une portée globale, donc la fonction print() à l'extérieur de testFunc() peut y accéder et imprimer 64 .

Example of global functions and variables
local function testFunc()  -- portée locale
	testVar = 64  -- portée globale
end

testFunc()

print(testVar) -- 64

Dans le code suivant, la variable globale commence à , augmente de à chaque itération de la boucle , et imprime à nouveau plus tard avec une valeur finale de 4.

x = 0  -- Variable globale "x"

for i = 1, 4 do
	x += 1
	print("Global 'x' = " .. x)
end

print("Global 'x' = " .. x)

--[[ Résultat de sortie :
Global 'x' = 1
Global 'x' = 2
Global 'x' = 3
Global 'x' = 4
Global 'x' = 4
]]

Il est plus facile de déclarer des variables et des fonctions globales car vous n'avez pas besoin de taper autant, mais les variables et les fonctions globales ont les inconvénients suivants par rapport aux locales :

• Luau accède aux variables et aux fonctions globales avec une recherche de hachage, ce qui est coûteux en termes de performance.L'utilisation d'une variable globale dans une boucle critique en temps peut la faire fonctionner plus lentement de plus de 10 % que l'utilisation d'une variable locale dans la même boucle.
• Luau se débarrasse des variables locales après la fin de leur portée, réduisant l'utilisation de la mémoire.
• Vous pouvez accéder à des variables et des fonctions globales dans le même script, mais pas entre plusieurs scripts.Par conséquent, une variable ou une fonction globale n'apporte aucun avantage par rapport à une équivalente locale dans le domaine, une valeur supérieure ou une ombre.

Portée locale

Luau ne peut accéder qu'à une variable ou une fonction locale dans le bloc de code où vous la déclarez.La création d'une variable avec un scope local vous donne un contrôle plus serré sur le moment et l'endroit où sa valeur change.

Dans le code suivant, la fonction testFunc() et la variable testVar ont une portée locale.Seul le code à l'intérieur de peut accéder à la variable ».La variable testVar n'a pas de valeur en dehors de testFunc(), donc l'appel de print(testVar) à l'intérieur de testFunc() imprime la valeur de testVar, mais l'appel de print(testVar) à l'extérieur de testFunc() imprime nil .

local function testFunc()  -- portée locale
	local testVar = 64  -- portée locale
	print(testVar) -- 64
end

testFunc()

print(testVar) -- nil

Dans le code suivant, la variable locale x a la valeur 0 à la ligne 1.Pendant que Luau itère à travers la boucle , une variable locale différente a une valeur .Ensuite, Luau imprime la variable initiale x avec une valeur non modifiée 0 .

local x = 0  -- Variable locale "x"

for i = 1, 4 do
	local x = 1  -- Variable différente "x", locale à cette boucle "for"
	print("Loop 'x' = " .. x)
end

print("Initial 'x' = " .. x)

--[[ Résultat de sortie :
Loop 'x' = 1
Loop 'x' = 1
Loop 'x' = 1
Loop 'x' = 1
Initial 'x' = 0
]]

Capture

Après avoir déclaré et attribué une variable locale, vous pouvez la lire dans son niveau de portée et ses fonctions dont la portée est incluse dans le même domaine contenant la variable locale.Cette technique est connue sous le nom de capture .

Dans le code suivant, la fonction f capture la variable locale x.La variable dans est une valeur supérieure .

local x = 5

local function f()
	print(x)
end

f() -- 5
print(x) -- 5

Ombre

Après avoir déclaré et attribué une variable locale, vous pouvez la lire dans son niveau de scope et les niveaux de scope descendants.Si vous redéclarez et réassigner la variable dans un niveau de scope descendant, vous créez une nouvelle variable locale avec le même nom mais une valeur différente de la dernière affectation.La nouvelle variable locale n'affecte pas la variable locale de la précédente affectation.Cette technique, appelée ombrage , vous aide à réutiliser le nom d'une variable sans réutiliser sa valeur.

Dans le code suivant, Luau ombre la variable x . La variable x dans f() est une variable ombre .

local x = 5

local function f()
	local x = 7
	print(x)
end

f() -- 7
print(x) -- 5

Vous pouvez également réassigner une variable locale sans lui attribuer de valeur afin que vous puissiez réassigner la variable à la fois au niveau de son domaine et aux niveaux de sous-domaine descendant.Déclarer à nouveau une variable locale sans lui attribuer une valeur la met à nil .

Dans le code suivant, Luau ombre la variable locale fruitName dans la fonction getFruitByColor() .La fonction redéclare fruitName comme nouvelle variable d'ombre et définit sa valeur à nil .La fonction a un niveau de portée descendant, une boucle , qui attribue une valeur à .Après la boucle for, la fonction renvoie la variable d'ombre fruitName.Pendant toute la fonction, fruitName est la même variable locale qui ne remplace pas la variable locale initiale fruitName.

local fruitName = "Chocolate"
local fruitTable = {
	Lemon = "Yellow",
	Apple = "Red",
	Orange = "Orange"
}

local function getFruitByColor(color)
	local fruitName
	for key, value in fruitTable do
		if value == color then
			fruitName = key
		end
	end
	return fruitName
end

local fruit = getFruitByColor("Yellow")
print(fruit) -- Le citron
print(fruit .. ", not " .. fruitName) -- Lemon, not Chocolate