Portée

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

Les variables et 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 fonctions locales plus rapidement qu'aux globales. Pour donner une portée locale à une variable ou une fonction, mettez le mot-clé local avant son nom lors de sa déclaration.

Les scripts ne peuvent pas accéder aux variables ou fonctions globales et locales dans d'autres scripts. Si vous souhaitez partager des valeurs et des fonctions entre des 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 fonctions locales dans les blocs A et B.
• Le bloc A ne peut pas accéder aux variables et 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, tout bloc de code dans le même script peut y accéder. Les variables et fonctions ont une portée globale à moins que vous ne les déclariez avec le mot-clé local.

Dans le code suivant, testVar a une portée globale au sein de la fonction locale testFunc(). Lorsque Luau appelle testFunc(), il assigne à testVar la valeur 64. La testVar a une portée globale, donc la fonction print() en dehors de testFunc() peut y accéder et imprimer 64.

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

testFunc()

print(testVar) -- 64

Dans le code suivant, la variable globale x commence à 0, s'incrémente de 1 à chaque itération de la boucle for, et s'imprime à nouveau après 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 :
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 fonctions globales ont les inconvénients suivants par rapport aux locales :

• Luau accède aux variables et fonctions globales avec une recherche par hachage, ce qui est coûteux en termes de performance. Utiliser une variable globale dans une boucle critique en temps peut la rendre plus de 10 % plus lente que l'utilisation d'une variable locale dans la même boucle.
• Luau dispose des variables locales après la fin de leur portée, réduisant l'utilisation de la mémoire.
• Vous pouvez accéder aux variables et fonctions globales au sein du même script, mais pas entre plusieurs scripts. Par conséquent, une variable ou une fonction globale n'offre aucun avantage par rapport à un équivalent local dans la portée, un upvalue, ou un shadow.

Portée locale

Luau ne peut accéder à une variable ou une fonction locale que dans le bloc de code où vous la déclarez. Créer une variable avec une portée locale vous donne un meilleur contrôle 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 testFunc() peut accéder à la variable testVar. La variable testVar n'a pas de valeur en dehors de testFunc(), donc appeler print(testVar) à l'intérieur de testFunc() imprime la valeur de testVar, mais appeler print(testVar) en dehors 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. Alors que Luau itère à travers la boucle for, une autre variable locale x a la valeur 1. Ensuite, Luau imprime la variable initiale x avec une valeur inchangée de 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 :
Loop 'x' = 1
Loop 'x' = 1
Loop 'x' = 1
Loop 'x' = 1
Initial 'x' = 0
]]

Les variables et fonctions const suivent les mêmes règles de portée que celles des local. Vous pouvez les déclarer dans n'importe quel bloc, y compris à l'intérieur d'une autre fonction. Pour plus d'informations sur const, voir Variables const.

Capture

Après avoir déclaré et assigné une variable locale, vous pouvez la lire dans son niveau de portée et dans les fonctions dont la portée est englobée par la même portée 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 x dans f() est un upvalue.

local x = 5

local function f()
	print(x)
end

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

Shadow

Après avoir déclaré et assigné une variable locale, vous pouvez la lire dans son niveau de portée et dans les niveaux de portée descendants. Si vous redéclarez et réassignez la variable dans un niveau de portée descendant, vous créez alors une nouvelle variable locale avec le même nom mais une valeur différente de la dernière assignation. La nouvelle variable locale n'affecte pas la variable locale de la précédente assignation. Cette technique, connue sous le nom de shadowing, 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 shadow.

local x = 5

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

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

Vous pouvez également redéclarer une variable locale sans lui assigner de valeur afin de pouvoir réassigner la variable à la fois dans son niveau de portée et dans les niveaux de portée descendants. Redéclarer une variable locale sans lui assigner de valeur définit sa valeur à nil.

Dans le code suivant, Luau ombre la variable locale fruitName dans la fonction getFruitByColor(). La fonction redéclare fruitName comme une nouvelle variable shadow et définit sa valeur à nil. La fonction a un niveau de portée descendant, une boucle for, qui assigne une valeur à fruitName. Après la boucle for, la fonction retourne la variable shadow fruitName. Tout au long de 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) -- Lemon
print(fruit .. ", not " .. fruitName) -- Lemon, not Chocolate