Introduction aux boucles for | Documentation

Il existe différentes façons de faire fonctionner du code encore et encore. Si vous souhaitez que le code ne s'exécute qu'un certain nombre de fois, utilisez une boucle for. Cet article traitera de la logique derrière les boucles for et démontrera quelques exemples pratiques, comme la programmation d'un compte à rebours.

Comment fonctionnent les boucles for

Les boucles for utilisent trois valeurs pour contrôler combien de fois elles s'exécutent : une variable de contrôle, une valeur de fin et une valeur d'incrément. En partant de la valeur de la variable de contrôle, les boucles for compteront soit vers le haut, soit vers le bas chaque fois qu'elles exécutent du code à l'intérieur de la boucle jusqu'à ce qu'elles dépassent la valeur de fin. Les valeurs d'incrément positives comptent vers le haut, et les valeurs d'incrément négatives comptent vers le bas.

Différents langages de programmation peuvent utiliser d'autres terminologies avec les boucles for. Par exemple, en C# ou JavaScript, la valeur de fin peut être appelée condition.

Étapes d'une boucle for

Pour comprendre les boucles for, il est utile de voir un diagramme de flux montrant la logique de leur progression.

Tout d'abord, la boucle for compare la variable de contrôle avec la valeur de fin.

Après avoir exécuté le code, la valeur d'incrément est ajoutée à la variable de contrôle. La boucle vérifie ensuite la variable de contrôle et recommence.

Une fois que la variable de contrôle dépasse la valeur de fin, la boucle s'arrêtera. Par exemple, si une boucle a une valeur de fin de 10, une fois que la variable de contrôle a dépassé 10, la boucle for s'arrêtera.

Programmer un compte à rebours

Pour voir comment fonctionne une boucle for, suivez ces étapes pour coder une boucle for qui commence à 10 et compte à rebours vers 0, un nombre à la fois. Chaque fois que la boucle s'exécute, elle affichera la valeur actuelle à l'intérieur de la variable de contrôle.

Dans ServerScriptService, créez un nouveau script nommé PracticeLoop. Dans le script, commencez par taper le mot-clé for.
```
for
```
Créez une variable de contrôle nommée count et définissez une valeur de départ de 10.
```
for count = 10
```
Définissez la valeur de fin à 0, en tapant , 0. Assurez-vous d'inclure une virgule pour séparer les valeurs.
```
for count = 10, 0
```
Créez une valeur d'incrément de -1 en tapant , -1. Une fois que la boucle a terminé son action, elle ajoutera la valeur d'incrément à la variable de contrôle, count. Puisque l'incrément est négatif, il sera soustrait lorsqu'il sera ajouté à la variable de contrôle.
```
for count = 10, 0, -1
```
Une boucle for n'a pas explicitement besoin d'un incrément. Sans en spécifier un, la boucle ajoutera par défaut 1 après chaque itération.
for count = 10, 0
Pour terminer la boucle for, tapez do et appuyez sur Entrée pour ajouter end. Tout code tapé entre do et end s'exécutera chaque fois que la boucle se répète.
```
for count = 10, 0, -1 do

end
```

À l'intérieur de la boucle, créez un compte à rebours en affichant la valeur de la variable de contrôle, count, puis retardez le script avec une fonction d'attente.


for count = 10, 0, -1 do
	-- Affiche le nombre actuel sur lequel se trouve la boucle for
	print(count)
	-- Attendre 1 seconde
	task.wait(1)
end

Exécutez le projet et regardez la fenêtre de sortie pour voir la boucle for.

Remarquez que la boucle imprimera la valeur actuelle de count chaque fois qu'elle passe par une itération. Une itération est le processus complet de vérification de la valeur de contrôle, d'exécution du code et de mise à jour de la valeur d'incrément. Comme la variable de contrôle commence à 0 et doit dépasser 10, la boucle effectuera 11 itérations avant de s'arrêter.

Conseils de dépannage

À ce stade, si la boucle ne fonctionne pas comme prévu, essayez l'une des solutions suivantes.

Vérifiez que vous avez deux virgules séparant les nombres dans votre boucle for. Avoir des virgules en trop ou manquantes empêchera la boucle de démarrer.
Si la boucle for imprime tout en même temps, assurez-vous qu'il existe une fonction d'attente qui utilise au moins 1 seconde.

Différents exemples de boucles for

Modifier les trois valeurs d'une boucle for changera le fonctionnement de la boucle. Ci-dessous, des exemples de boucles for avec différentes valeurs de départ, de fin et d'incrément. Essayez de les mettre dans des scripts et voyez ce qui se passe.

Compter par un


for count = 0, 5, 1 do
	print(count)
	task.wait(1)
end

Compter par nombres pairs


for count = 0, 10, 2 do
	print(count)
	task.wait(1)
end

Si les boucles for ne s'exécutent pas du tout

Si la variable de contrôle commence au-delà de la valeur de fin, comme dans l'exemple ci-dessous, la boucle for ne s'exécutera pas du tout.


for count = 10, 0, 1 do
	print(count)
	task.wait(1)
end

Dans ce cas, la boucle for compte vers le haut et vérifie si count est supérieur à 0. Lorsque la boucle for effectue sa première vérification, elle constate que 10 est supérieur à 0, et elle arrêterait la boucle sans imprimer quoi que ce soit.

Résumé

Une boucle for est un type courant de boucle utilisé lorsque un ensemble d'instructions doit se répéter un nombre spécifique de fois. Pour créer une boucle for, utilisez trois variables avec la syntaxe ci-dessous :


for count = 0, 10, 1 do
	print(count)
end

Dans l'exemple ci-dessus, la boucle commencera à 0. Pour chaque boucle, elle affichera la variable count, ajoutera 1 à count, et enfin, terminera la boucle lorsque count sera égal à 10.