Structures de contrôle

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

Une déclaration si ensuite exécute du code seulement si une condition spécifiée est true . L'exécution du code ne se répète pas.
Un cycle while exécute du code seulement si une condition spécifiée est , et répète l'exécution tant que la condition reste .
Un cycle de répétition répète le code et répète l'exécution si la condition est true.
Un pour boucle exécute du code un nombre défini de fois en fonction des entrées spécifiées.

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

Si les déclarations

La déclaration de base if teste sa condition. Si la condition est vraie, Luau exécute le code entre then et end .

Vous pouvez utiliser une déclaration elseif pour tester des conditions supplémentaires si la condition if est fausse.Vous pouvez utiliser une déclaration 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 sans une déclaration initiale if.

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


if 2 + 2 == 5 then
	print("Two plus two is five") -- Ne s'imprime pas car la condition est fausse
elseif 2 + 3 == 5 then
	print("Two plus three is five") -- Deux plus trois est cinq
else
	print("All conditions failed") -- Ne s'imprime pas car la condition précédente est vraie
end

Pendant les boucles

Un cycle 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("Seconds remaining: " .. timeRemaining)
	task.wait(1)
	timeRemaining -= 1
end

print("Timer reached zero!")
--[[ Résultat de sortie :
Seconds remaining: 10
Seconds remaining: 9
Seconds remaining: 8
Seconds remaining: 7
Seconds remaining: 6
Seconds remaining: 5
Seconds remaining: 4
Seconds remaining: 3
Seconds remaining: 2
Seconds remaining: 1
Timer reached zero!
]]

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("Looping...")
	task.wait(0.5)
end

--[[ Résultat de sortie :
Looping...
Looping...
Looping...
Looping...
...
]]

Incluez toujours un délai tel que task.wait() dans une boucle infinie. Son omission gèle l'expérience et bloque Studio.

Répéter les boucles

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


local currentGoblinCount = 18

-- Générer des gobelins jusqu'à un maximum de 25 dans le jeu
repeat
	spawnGoblin()
	currentGoblinCount += 1
	print("Current goblin count: " .. currentGoblinCount)
until currentGoblinCount == 25

print("Goblins repopulated!")

--[[ Résultat de sortie :
Current goblin count: 19
Current goblin count: 20
Current goblin count: 21
Current goblin count: 22
Current goblin count: 23
Current goblin count: 24
Current goblin count: 25
Goblins repopulated!
]]

Pour les boucles

Un cycle A exécute du code un nombre défini de fois, soit sur la base d'un compteur numérique ou du nombre d'éléments dans une collection .

Numérique pour les boucles

Une boucle for — do détermine le nombre de fois pour exécuter la boucle en utilisant un contrer.La boucle est déclarée avec une valeur de départ, une valeur de fin et une augmentation facultative.

Luau définit le compteur égal à la valeur de départ, exécute le bloc de code dans la boucle for puis ajoute l'augmentation au contrer.Si l'augmentation est positive, le processus se répète jusqu'à ce que le compteur soit égal ou supérieur à la valeur finale.Si l'augmentation est négative, le processus se répète jusqu'à ce que le compteur soit égal ou inférieur à la valeur finale.

L'augmentation facultative se définit par défaut à 1. Elle n'a pas besoin d'être un nombre entier.


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

--[[ Résultat de sortie :
1
2
3
]]

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

--[[ Résultat de sortie :
1
3
5
]]

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

--[[ Résultat de sortie :
2
1.5
1
0.5
0
]]

Générique pour les cycles

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

Pour les boucles, il est nécessaire qu'une fonction ou un itérateur itère sur différents types de collections.Le global ipairs() renvoie un itérateur pour les tableaux, et le global pairs() renvoie un itérateur pour les dictionnaires.La bibliothèque string fournit string.gmatch() pour itérer sur les chaînes.

Iteration 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ération 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 la méthode __iter métaméthode pour créer une fonction d'iterator personnalisée.Cet exemple contourné itère sur une chaîne 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

--[[ Résultat de sortie :
5 5
4 4
3 3
2 2
1 1
]]

Tables d'arrêt

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


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

--[[ Résultat de sortie :
1 a
2 b
3 c
4 d
5 e
]]

Dictionnaires

La fonction pairs() retourne un itérateur qui itère à travers tous les index (y compris les index numériques) dans une table et renvoie un key et value pour chaque entrée dans le dictionnaire.L'ordre de traversée des éléments dans une table de dictionnaire est arbitraire.Cela le rend approprié pour itérer sur les dictionnaires, où les éléments sont stockés hors ordre avec des index 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

--[[ Résultat de sortie :
Hello b
true d
false e
World f
5 c
1 a
]]

Rompre les boucles

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


local secondsElapsed = 0
local timeout = 5

while true do
	task.wait(1)
	secondsElapsed += 1
	print("Seconds elapsed:", secondsElapsed)

	if secondsElapsed == timeout then
		break
	end
end

print("Five seconds elapsed. Time to move on!")

--[[ Résultat de sortie :
1
2
3
4
5
Five seconds elapsed. Time to move on!
]]

Continuer les boucles

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


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

Sur cette page