JavaScript Loops - Un guide pour les débutants absolus
Tous les langages de programmation de haut niveau fournissent plusieurs types de boucles différents. La syntaxe de ces boucles peut être différente mais elles sont utilisées pour effectuer les mêmes tâches. Ces boucles sont interchangeables mais certaines sont spécifiquement conçues pour être utilisées dans certaines conditions spécifiques.
Les boucles les plus populaires présentes dans la plupart des langages de programmation sont pour et alors que boucles; Ici, nous en discuterons avec leurs extensions qui sont présentes en JavaScript:
Comment utiliser la boucle pour JavaScript
La boucle la plus simple et la plus couramment utilisée en JavaScript est la pour boucle; pour Les boucles sont préférées aux autres boucles lorsque le programmeur connaît le nombre défini de fois que la boucle va fonctionner.
Jetons un coup d'œil à la syntaxe du pour boucle pour comprendre pourquoi:
pour (initialisation; condition; modification variable)// Instructions de code à exécuter
Le pour La boucle prend trois arguments, l'initialisation, l'état et la modification variable:
- Le premier argument je.e. initialisation Exécute une seule fois avant l'exécution de la boucle; Il initialise une variable qui est utilisée dans la condition pour la boucle.
- Le deuxième argument I.e. condition est évalué avant chaque itération; La boucle se termine lorsque cette condition est satisfaite.
- Le troisième et le dernier argument modification variable est utilisé pour modifier la valeur de la variable utilisée en condition après chaque itération de la boucle.
Les arguments du pour Des boucles spécifient le nombre défini d'itérations qu'il va fonctionner. Ils spécifient le point de départ (initialisation) et le point de fin (condition) de la boucle. Bien que tous les arguments soient facultatifs (le pour Loop s'exécutera même si vous ne spécifiez pas la condition) mais il n'est pas recommandé de laisser l'argument de la condition vide car il créera une boucle infinie qui peut écraser votre navigateur.
Essayons maintenant un exemple pour mieux comprendre pour boucle:
Note: La console du navigateur est utilisée pour la démonstration d'exemples dans cet article.
Dans cet exemple, nous compterons de 10 à 1 en utilisant un pour boucle:
pour (let index = 10; index> = 1; index--)console.log (index);
Dans l'exemple ci-dessus:
- Indice est initialisé à 10
- Alors la condition est vérifiée, car le indice est supérieur ou égal à 1 condition est vraie la boucle est exécutée et la valeur de l'index est imprimée à la console
- Après la première itération, le indice la variable est décrémentée d'un. Le - l'opérateur réduit la valeur du indice par un.
- Ensuite, la condition est à nouveau vérifiée; Comme la condition est toujours vraie, la boucle est à nouveau exécutée.
Ce processus reste récurrent tant que la condition pour la boucle reste vraie. Lorsque la valeur du indice Rechée 0, la condition supérieure ou égale à 1 n'est plus vraie et la boucle se termine.
Nous pouvons effectuer n'importe quelle opération sur la variable dans le dernier argument du pour Énoncé de la boucle:
pour (let index = 2; index < 500; index*=2)console.log (index);
Comment utiliser pendant la boucle en javascript
Alors que Les boucles ne prennent qu'un argument qui est la condition pour la boucle:
Ils sont principalement utilisés lorsque le code doit exécuter un nombre inconnu de fois jusqu'à ce que la condition soit satisfaite:
while (condition)// déclarations
Jetons un coup d'œil à un exemple où nous générerons un numéro aléatoire en utilisant le Mathématiques.aléatoire() Méthode à l'intérieur de la boucle; La boucle continuera à fonctionner jusqu'à Mathématiques.aléatoire() La méthode produit un nombre impair:
runloopagain = true;while (runloopagain)
num = mathématiques.aléatoire().tofixé (1) * 10;
if (num% 2 != 0)
runloopagain = false;
console.log (num);
Dans l'exemple ci-dessus, nous avons d'abord déclaré un booléen nommé runloopagain et lui a attribué une valeur I.E VRAI. La boucle while évalue la condition avant l'exécution de la boucle; Comme la variable runloopagain est la condition de la boucle et est vraie la boucle while est exécutée. À l'intérieur du corps du alors que boucle nous avons utilisé le aléatoire Méthode de la Mathématiques objet avec le .tofixé Méthode pour obtenir un nombre aléatoire entre zéro et neuf. Ensuite, nous avons utilisé une instruction conditionnelle pour vérifier si le nombre est divisible par deux (pour vérifier s'il est uniforme ou impair). Si le nombre est impair, le runloopagain La variable deviendra fausse et la boucle se terminera sinon la variable / condition restera vraie et la boucle continuera de fonctionner.
Les tâches que nous avons effectuées dans les exemples ci-dessus en utilisant le pour une boucle peut également être effectuée avec alors que boucle:
Soit i = 10;while (i> = 1)
console.journal (i);
je--;
Soit i = 2;
alors que je < 500)
console.journal (i);
i * = 2;
Comment utiliser l'instruction BREAK dans la boucle
Les instructions de rupture peuvent être utilisées à l'intérieur du corps de la boucle pour terminer la boucle. Regardons un exemple:
Soit i = 2;alors que je < 20)
if (i% 5 == 0)
casser;
console.journal (i);
i + = 2;
Dans cet exemple, j'ai utilisé un alors que Boucle pour imprimer chaque nombre uniforme qui est inférieur à 21, mais je n'obtiens que des nombres même moins de 9; pourquoi donc? En effet. Nous pouvons utiliser l'énoncé de rupture pour avoir des conditions différentes pour la fin d'un alors que Boucle à l'intérieur du corps de la boucle:
Comment utiliser l'instruction Continuer dans la boucle
L'instruction CONSTANT est utilisée pour sauter une itération et passer au prochain alors que boucle. Par exemple, si nous souhaitons ignorer le nombre qui est un multiple de 5 au lieu de simplement terminer la boucle dans l'exemple ci-dessus, nous utiliserons l'instruction Continuer:
Soit i = 2;alors que je < 21)
if (i% 5 == 0)
i + = 2;
continuer;
console.journal (i);
i + = 2;
Comme vous pouvez le voir 5, dix et 20 sont manquants parce qu'ils sont des multiples de 5 ainsi que des nombres égaux.
Comment utiliser la boucle DO pendant JavaScript
La boucle DO WHIC est construite sur le dessus de la boucle while, ce qui signifie qu'il s'agit d'une extension de la boucle while.
Dans la boucle pendant que la condition est évaluée avant l'exécution du corps de la boucle tandis que la boucle DO pendant le contraire et la vérifie après l'exécution du corps de la boucle.
runloopagain = true;while (runloopagain)
num = mathématiques.aléatoire().tofixé (1) * 10;
if (num% 2 != 0)
runloopagain = false;
console.log (num);
Dans cet exemple donné ci-dessus, nous avons dû déclarer et initialiser le runloopagain variable avant le corps de la boucle car le alors que LOOP évalue la condition avant l'itération.
Le faire pendant Loop vérifie la condition après chaque itération, donc si nous sommes sûrs que nous voulons exécuter le code présent à l'intérieur de la boucle au moins une fois, nous utilisons le faire pendant boucle. Comme nous sommes sûrs dans cet exemple que nous devons au moins générer un numéro aléatoire avant de vérifier s'il est même ou étrange, une meilleure façon de l'écrire serait:
fairenum = mathématiques.aléatoire().tofixé (1) * 10;
console.log (num);
while (num% 2 == 0);
Comment utiliser le pour en, pour et foreach boucles en javascript
Le en, pour et pour chaque Les boucles en javascript sont une extension du pour boucle. Ici, nous nous discuterons tous; Le en la boucle est utilisée pour itérer sur les propriétés d'un objet. Chaque itération du en Loop renvoie une clé qui peut être utilisée pour accéder à la valeur de la clé:
Var Employee = FirstName: "Mary", LastName: "Jane", âge: 33, ID: 092, Département: "Education";pour (laissez P dans l'employé)
console.journal (p);
console.journal (employé [p]);
Si la boucle FOR IN est appliquée à un tableau, il renvoie l'index de chaque élément. Si nous voulons obtenir la valeur présente à chaque index, nous pouvons utiliser le pour boucle.
var num = [5, 6, 7, 8, 9];pour (soit d de num)
console.journal (d);
Le pour la boucle est utilisée pour boucler à travers des objets itérables tels que des tableaux, des cartes, des cordes, etc. Si nous utilisons le pour Boucle sur une chaîne puis il renvoie un caractère de la chaîne chaque itération:
var salut = "Bienvenue à Linux!"pour (laissez c de saluer)
console.journal (c);
Le .pour chaque() La boucle est utilisée pour effectuer une action spécifique sur chaque élément du tableau; Il boucle à travers les éléments du tableau et appelle une fonction une fois pour chaque élément.
Le .pour chaque() Loop prend une fonction de rappel comme un argument qui prend en outre trois arguments, dont deux facultatifs; Le seul argument requis est la valeur de l'élément actuel. L'indice de l'élément et de l'ensemble du tableau lui-même peuvent également être donnés comme arguments à la fonction de rappel. Maintenant, nous allons examiner un exemple où nous avons utilisé le .pour chaque() Boucle pour multiplier chaque élément du tableau par deux et l'imprimer à la console:
nombres var = [99, 85, 788, 2, 255, 598];Nombres.foreach (fonction (valeur)
console.log (valeur + "* 2 =" + valeur * 2);
)
Conclusion
Les boucles sont des instructions de flux de contrôle qui sont utilisées pour réduire l'inefficacité du code et écrire du code plus concis. Ils sont l'un des plus fondamentaux de tout grand langage de programmation de haut niveau. Dans cet article, nous avons tout appris sur les boucles en JavaScript; Nous avons utilisé la syntaxe JavaScript pour en savoir plus sur pour et alors que boucles avec leurs extensions. De plus, la déclaration de pause et de poursuite pour alors que Des boucles ont également été discutées.