Quels sont les avantages d'utiliser une boucle while
sur une boucle for
? Lorsque j'itère à travers des tableaux, j'utilise toujours une boucle for
donc je me suis demandé si je manquais quelque chose ici.
Je n'ai jamais eu de situation où une boucle for
ne fait pas le travail, mais je crains de ne pas prendre de mauvaises habitudes ici. Mon utilisation des boucles a été en ce qui concerne les éléments sur les pages Web, les trucs dans les animations, etc.
Ce sont les raisons pour lesquelles je choisirais l'un plutôt que l'autre:
Syntaxe de la boucle For:
for( int i = 0; i > 10; i++)
{
//Some code here
}
J'utiliserais une boucle for pour la raison que je pourrais SAVOIR le NOMBRE D'ITÉRATIONS que je dois faire et j'ai une variable INCREMENTING qui peut être pratique parfois.
Syntaxe de la boucle while:
while(!done)
{
//Some code goes here
}
J'utiliserais cette boucle lorsque je ne suis pas sûr du nombre d'itérations que je pourrais avoir besoin d'effectuer. Exemples: Attendre que l'utilisateur saisisse les valeurs d'entrée correctes et continuer à boucler jusqu'à ce qu'il saisisse la valeur appropriée.
Syntaxe de la boucle Do-While:
do
{
//Some code here
}
while(!done);
Cette boucle est presque la même qu'une boucle while mais je préférerais cela quand j'ai besoin de quelque chose de fait ATLEAST ONCE avant de commencer à vérifier quoi que ce soit qui me donnerait envie de boucler et de refaire ce code. Exemple: demandez à un utilisateur une entrée pour la première fois, puis validez-la. Si une mauvaise entrée est donnée, faites une boucle et demandez à nouveau une entrée
Fonctionnellement, l'un peut se substituer à l'autre dans toutes les conditions. Est-ce que l'un est meilleur que l'autre? Pas en javascript (que vous avez tagué) car ce n'est pas un langage compilé.
Mais dans des langages comme C++, une boucle for donne généralement au compilateur un nombre statique de boucles que le compilateur peut utiliser pour optimiser le binaire. Il devrait donc fonctionner plus rapidement (sur de très grands nombres de boucles).
Cela ne devrait pas être un problème à l'heure actuelle où vous ne remarquerez même pas l'augmentation des performances sur une boucle exécutée pour 10000 itérations sur un processeur quad core 2,5 GHz.
Cependant, personnellement, l'esthétique compte beaucoup pour moi (et cela devrait vous intéresser si vous êtes sérieux dans l'art du codage). Par exemple, lorsque vous avez affaire à une condition externe (la variable que vous vérifiez est définie en dehors de la boucle), optez pour une boucle while. C'est juste sémantiquement tellement beau. Aussi, alors que la boucle devrait être le choix de facto pour une boucle infinie (je ne vois pas pourquoi vous auriez une boucle infinie en javascript, cependant).
En bref, suivez la syntaxe. Vérifiez-vous simplement une condition? Allez avec une boucle while. Êtes-vous en train d'initialiser et d'incrémenter/décrémenter quelque chose avec dans le contexte d'une boucle avec la vérification d'une condition? Ensuite, allez avec la boucle for.
Vous pouvez toujours utiliser soit des boucles. Mais, l'utilisation la plus courante des boucles for
est lorsque le nombre d'itérations est conn, et la boucle while
ayant nombre d'itérations incertain = ou dépendrait d'une condition particulière. Par exemple:
var arr = ["a", "b", "c"];
for (let i=0; i<arr.length; i++) { // will loop 3 times (length of arr = 3)
// do something
}
var x = "Hello";
while (x != "World") {
// do something
if (some_condition) {
// do something
}
else x = "World";
}