Structures de contrôle

Les structures de contrôle sont des instructions qui gèrent le flux d'exécution du code Luau. Il existe quatre types principaux de structures de contrôle :

• Une instruction if then else exécute du code uniquement si une condition spécifiée est true. L'exécution du code ne se répète pas.
• Une boucle while exécute du code uniquement si une condition spécifiée est true, et répète l'exécution tant que la condition reste true.
• Une boucle repeat exécute du code et répète l'exécution si la condition est true.
• Une boucle for exécute du code un nombre défini de fois en fonction d'entrées spécifiées.

La condition pour les instructions if, les boucles while et les boucles repeat peut être n'importe quelle expression ou valeur Luau. Si une valeur n'est ni false ni nil, alors Luau l'évalue comme true dans les instructions conditionnelles. Contrairement à d'autres langages de script, Luau considère à la fois zéro et la chaîne vide comme true.

Instructions If

L'instruction de base if teste sa condition. Si la condition est vraie, alors Luau exécute le code entre then et end.

Vous pouvez utiliser une instruction elseif pour tester des conditions supplémentaires si la condition if est fausse. Vous pouvez utiliser une instruction else pour exécuter du code si toutes les conditions if et elseif échouent. Les parties elseif et else sont toutes deux optionnelles, mais vous ne pouvez pas utiliser l'une ou l'autre sans une instruction if initiale.

Dans une chaîne de conditions if, elseif et else, Luau teste les conditions de haut en bas, s'arrête à la première condition true et exécute le code qui suit.

if 2 + 2 == 5 then
	print("Deux plus deux égale cinq") -- Ne s'imprime pas car la condition est fausse
elseif 2 + 3 == 5 then
	print("Deux plus trois égale cinq") -- Deux plus trois égale cinq
else
	print("Toutes les conditions ont échoué") -- Ne s'imprime pas car la condition précédente est vraie
end

Boucles While

Une boucle while—do évalue si une condition spécifiée est vraie ou fausse. Si la condition est false ou nil, alors la boucle se termine et Luau saute le code dans la boucle. Si la condition est true, alors Luau exécute le code dans la boucle et répète le processus.

local timeRemaining = 10

while timeRemaining > 0 do
	print("Secondes restantes : " .. timeRemaining)
	task.wait(1)
	timeRemaining -= 1
end

print("Le minuteur a atteint zéro !")
--[[ Sortie résultante :
Secondes restantes : 10
Secondes restantes : 9
Secondes restantes : 8
Secondes restantes : 7
Secondes restantes : 6
Secondes restantes : 5
Secondes restantes : 4
Secondes restantes : 3
Secondes restantes : 2
Secondes restantes : 1
Le minuteur a atteint zéro !
]]

Boucles infinies

Vous pouvez utiliser une boucle while—do pour écrire des boucles de jeu infinies en définissant true comme condition.

while true do
	print("En boucle...")
	task.wait(0.5)
end

--[[ Sortie résultante :
En boucle...
En boucle...
En boucle...
En boucle...
...
]]

Boucles Repeat

La boucle repeat—until se répète jusqu'à ce qu'une condition soit vraie. Le test conditionnel s'évalue après l'exécution du bloc de code, donc le bloc de code s'exécute toujours au moins une fois. Contrairement à d'autres langages, la portée d'une variable locale déclarée à l'intérieur d'une boucle repeat—until inclut la condition.

local currentGoblinCount = 18

-- Faire apparaître des gobelins jusqu'à un maximum de 25 dans le jeu
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Nombre actuel de gobelins : " .. currentGoblinCount)
until currentGoblinCount == 25

print("Les gobelins se sont reproduits !")

--[[ Sortie résultante :
Nombre actuel de gobelins : 19
Nombre actuel de gobelins : 20
Nombre actuel de gobelins : 21
Nombre actuel de gobelins : 22
Nombre actuel de gobelins : 23
Nombre actuel de gobelins : 24
Nombre actuel de gobelins : 25
Les gobelins se sont reproduits !
]]

Boucles For

Une boucle for exécute du code un nombre défini de fois, soit en fonction d'un compteur numérique, soit en fonction du nombre d'éléments dans une collection.

Boucles for numériques

Une boucle for—do détermine le nombre de fois à exécuter la boucle en utilisant un compteur. La boucle est déclarée avec une valeur de départ, une valeur de fin et un incrément optionnel.

Luau fixe le compteur égal à la valeur de départ, exécute le bloc de code dans la boucle for, puis ajoute l'incrément au compteur. Si l'incrément est positif, alors le processus se répète jusqu'à ce que le compteur soit égal ou supérieur à la valeur de fin. Si l'incrément est négatif, alors le processus se répète jusqu'à ce que le compteur soit égal ou inférieur à la valeur de fin.

L'incrément optionnel est par défaut 1. Il n'a pas besoin d'être un nombre entier.

for counter = 1, 3 do
	print(counter)
end

--[[ Sortie résultante :
1
2
3
]]

for counter = 1, 6, 2 do
	print(counter)
end

--[[ Sortie résultante :
1
3
5
]]

for counter = 2, 0, -0.5 do
	print(counter)
end

--[[ Sortie résultante :
2
1.5
1
0.5
0
]]

Boucles for générales

La boucle for générale itère sur les éléments d'une collection plutôt que sur une séquence de nombres. Avec des boucles for générales, vous pouvez exécuter du code pour chaque élément de la collection et pouvez facilement utiliser chaque élément dans le code.

Les boucles for ont besoin d'une fonction, ou d'un itérateur, pour itérer sur différents types de collections. La fonction globale ipairs() retourne un itérateur pour les tableaux, et la fonction globale pairs() retourne un itérateur pour les dictionnaires. La bibliothèque string fournit string.gmatch() pour itérer sur les chaînes.

Itération généralisée

Dans Luau, vous pouvez itérer sur une table en utilisant le mot-clé in directement sur la table, au lieu d'utiliser une fonction d'itérateur telle que ipairs() :

for i, v in {1, 2, 3, 4, 5} do
	print(i, v)
end

L'itération généralisée vous permet également d'utiliser le métaméthode __iter pour créer une fonction itératrice personnalisée. Cet exemple artificiel itère sur un tableau dans l'ordre inverse, de son dernier élément à son premier :

local myTable = {1, 2, 3, 4, 5}

myMetatable = {
	__iter = function(t)
		local i = #t + 1

		return function()
			i -= 1

			if i > 0 then
				return i, t[i]
			end
		end
	end,
}

setmetatable(myTable, myMetatable)

for i, v in myTable do
	print(i, v)
end

--[[ Sortie résultante :
5 5
4 4
3 3
2 2
1 1
]]

Tableaux

La fonction ipairs() retourne un itérateur qui itère à travers les indices numériques dans une table et retourne un index et une value pour chaque élément. Cela la rend appropriée pour les tableaux, où tous les indices sont numériques.

local array = {"a", "b", "c", "d", "e"}
for index, value in ipairs(array) do
	print(index, value)
end

--[[ Sortie résultante :
1 a
2 b
3 c
4 d
5 e
]]

Dictionnaires

La fonction pairs() retourne un itérateur qui itère à travers tous les indices (y compris les indices numériques) dans une table et retourne une key et une value pour chaque entrée dans le dictionnaire. L'ordre de parcours des éléments dans une table de dictionnaire est arbitraire. Cela la rend appropriée pour l'itération sur les dictionnaires, où les éléments sont stockés hors ordre avec des indices non numériques.

local dictionary = {
	[1] = "a",
	["Hello"] = "b",
	[5] = "c",
	[true] = "d",
	["World"] = "f",
	[false] = "e"
}
for key, value in pairs(dictionary) do
	print(key, value)
end

--[[ Sortie résultante :
Hello b
true d
false e
World f
5 c
1 a
]]

Boucles Break

Pour forcer une boucle à se terminer, utilisez le mot-clé break. L'exemple de code suivant montre comment briser une boucle while—do infinie.

local secondsElapsed = 0
local timeout = 5

while true do
	task.wait(1)
	secondsElapsed += 1
	print("Secondes écoulées :", secondsElapsed)

	if secondsElapsed == timeout then
		break
	end
end

print("Cinq secondes se sont écoulées. Il est temps de passer à autre chose !")

--[[ Sortie résultante :
1
2
3
4
5
Cinq secondes se sont écoulées. Il est temps de passer à autre chose !
]]

Boucles Continue

Pour forcer une boucle à itérer et recommencer, utilisez le mot-clé continue. Une boucle for itérera le compteur ; while et repeat—until vérifieront la condition de la boucle avant de continuer. L'exemple de code suivant obtient tous les enfants d'un Instance d'un ClassName spécifique.

local function GetChildrenOfClass(parent: Instance, className: string): {Instance}
	local children = {}
	for _, child in parent:GetChildren() do
		if child.ClassName ~= className then continue end  -- Itère la boucle
		table.insert(children, child)
	end

	return children
end