Analyse complète des méthodes de boucle en javascript foreach, for-in, pour

JavaScript est un langage de script littéral, qui est un langage dynamique, faible et basé sur un prototype avec des types de support intégrés. Son interprète est appelé le moteur JavaScript. Il fait partie du navigateur et est largement utilisé dans le langage de script client. Il a d'abord été utilisé sur les pages Web HTML (une application sous le langage de balisage universel standard) pour ajouter des fonctions dynamiques aux pages Web HTML.

JavaScript est né depuis plus de 20 ans, et la méthode que nous utilisons pour faire boucle un tableau est la suivante:

 pour (var index = 0; index <myArray.length; index ++) {console.log (MyArray [index]);}

Depuis JavaScript5, nous avons commencé à utiliser la méthode FOREACH intégrée:

 MyArray.ForEach (fonction (valeur) {console.log (valeur);});

La méthode d'écriture est beaucoup plus simple, mais elle a également ses lacunes: vous ne pouvez pas interrompre la boucle (en utilisant des instructions ou en utilisant des instructions.

Il existe également une méthode de boucle dans JavaScript:.

La boucle for-in est en fait conçue pour en boucle des objets "énumérables":

 var obj = {a: 1, b: 2, c: 3}; for (var prop dans obj) {console.log ("obj." + prop + "=" + obj [prop]);} // output: // "obj.a = 1" // "obj.b = 2" // "obj.c = 3"

Vous pouvez également l'utiliser pour boucler un tableau:

 pour (var index dans myArray) {// cette console.log (MyArray [index]);}

Il n'est pas recommandé d'utiliser For-in pour faire boucle un tableau, car contrairement aux objets, l'index d'un tableau est différent des propriétés d'objets ordinaires et est un indicateur de séquence numérique important.

En bref, car est une méthode utilisée pour faire un peu de boucle à travers des objets avec des touches de chaîne.

For-Of Loop

JavaScript6 introduit une nouvelle méthode de boucle, qui est la boucle FOR-OF, qui est plus simple que la boucle traditionnelle pour la boucle, et en même temps compense les lacunes de Forach et de boucles pour les intestins.

Jetons un coup d'œil à sa syntaxe pour la syntaxe:

 pour (valeur var de MyArray) {console.log (valeur);}

La syntaxe de For-Of-Of est très similaire à For-in, mais elle a des fonctions beaucoup plus riches et peut boucler beaucoup de choses.

Exemple pour l'utilisation de la boucle:

 Soit iTable = [10, 20, 30]; pour (Soit la valeur de itéable) {console.log (valeur);} // 10 // 20 // 30

Nous pouvons l'utiliser à la place, il devient donc une variable statique non modifiée dans la boucle.

 Soit iTable = [10, 20, 30]; pour (const de constant de itéable) {console.log (valeur);} // 10 // 20 // 30

Boucle une chaîne:

 Soit iTableable = "boo"; pour (la valeur de la valeur d'Itable) {console.log (valeur);} // "b" // "o" // "o" LET iTable = new uint8Array ([0x00, 0xff]); pour (LET VALUE OF ITERAT 2], ["c", 3]]); pour (le laisser [key, valeur] d'Itable) {console.log (valeur);} // 1 // 2 // 3For (Soit l'entrée d'Itable) {console.log (entrée);} // [a, 1] // [b, 2] // [c, 3] Soit Itreal itéable) {console.log (valeur);} // 1 // 2 // 3

Faire boucle une collection DOM

Boucler une collection DOM, comme Nodelist. Nous avons déjà discuté de la façon de faire bouclez un nodeliste. Maintenant, il est pratique, vous pouvez utiliser directement la boucle FOR-OF:

 // Remarque: cela ne fonctionnera que sur des plates-formes qui ont // implémentées nodelist.prototype [symbol.iterator] let articleParagraphs = document.QuerySelectorAll ("Article> p"); pour (let paragraphe de l'articleParagraphs) {paragraph.classList.add ("read");};

Faire boucle un objet avec un attribut énumérable

La boucle Forof ne peut pas être utilisée directement sur des objets ordinaires, mais si nous boucles en fonction des propriétés de l'objet, nous pouvons utiliser la méthode objet intégré. keys ():

 for (var key of object.keys (someObject)) {console.log (key + ":" + someObject [key]);}

Faire boucle un générateur

Nous pouvons parcourir un générateur:

 Fonction * fibonacci () {// a un fonctiont de générateur [prev, curr] = [0, 1]; while (true) {[prev, curr] = [curr, prev + curr]; rendement curr;}} pour (laisser n de fibonacci ()) {console.log (n); // tronque la séquence à 1000if (n> = 1000) {casque;}}