Structures de contrôle

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

• Une si alors autrement déclaration exécute du code seulement si une condition spécifiée est true. L'exécution du code ne se répète pas.
• Une while loop exécute du code uniquement si une condition spécifiée est true , et répète l'exécution du code pendant que la condition reste true .
• Un répéter le boucle exécute du code et répète l'exécution si la condition est true .
• Un pour boucle exécute du code un certain nombre de fois en fonction des entrées spécifiées.

La condition pour les if déclarations, while boucles et repeat boucles peut être n'importe quelle expression Luau ou valeur. Si une valeur n'est pas 2> false2> ou 5> nil5>, alors Luau l'évalue

Si les déclarations

La déclaration 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 déclaration elseif pour tester pour 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 1> if1>

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

if 2 + 2 == 5 then
	print("Two plus two is five") -- Impossible de imprimer 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") -- Impossible de imprimer car la condition précédente est vraie
end

Pendant que boucles

Un while — do boucle d'évaluation de si une condition spécifiée est vraie ou fausse. Si la condition est false ou 1> nil1>, alors la boucle se termine, et Luau passe le code dans la boucle. Si la condition est 4> true4>, alors Luau exécute le code dans la boucle et répète

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 un while — do boucle pour écrire des boucles de jeu infinies en définissant true comme la condition.

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

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

Répéter les boucles

Le repeat — until le bloc de code se répète jusqu'à ce qu'une condition soit vraie. Le test conditionnel évalue après que le bloc de code s'exécute, afin que le bloc de code s'exécute au moins une fois. Contrairement à d'autres langues, le 2>scope2> d'une variable locale déclarée à l'intérieur d'un 5>

local currentGoblinCount = 18

-- Générez 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

A pour exécuter du code un certain nombre de fois, soit en fonction d'un compteur numérique ou du nombre d'éléments dans une collection.

Forcles numériques

Un for — do — increment optionnel détermine le nombre de fois d'exécution du boucle en utilisant un contrer. Le boucle est déclaré avec une valeur de départ, une valeur de fin et un augmentation optionnelle.

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

L'augmentation facultative par défaut est 1 . Il 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 boucles

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

Pour les boucles, vous avez besoin d'une fonction ou d'un tableau pour itérer sur différents types de collections. Le tableau global ipairs() renvoie un tableau pour les tableaux, et le tableau global pairs() renvoie un tableau pour les dictionnaires. La bibliothèque string fournit 2>Library.chaîne.gmatch()2> pour itérer sur les chaî

Iteration générale

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

La généralisation de l'itération vous permet également d'utiliser la métodologie __iter pour créer une fonction d'itérateur personnalisée. Ce cas d'exemple contourne l'itération d'un tableau dans l'ordre inversé, à partir 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
]]

tableaux

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

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
]]

Mots de contrôle

Casser les boucles

Pour forcer un boucle à terminer, utilisez le mot-clé break. Le code suivant montre comment briser un boucle infinie while — do boucle.

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!
]]

Boucles continues

Pour forcer un boucle à se répéter et à redémarrer, utilisez le mot-clé continue. Un boucle for boucle l'contrer; while et 1> peat1> — 4> jusqu'à ce que 4> vérifiera

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

	return children
end