JavaScript
Boucles

Syntaxe

• pour ( initialisation ; condition ; expression_finale ) {}
• pour ( clé dans l' objet ) {}
• pour ( variable d' itérable ) {}
• while ( condition ) {}
• do {} while ( condition )
• pour chaque variable (dans l' objet ) {} // ECMAScript pour XML

Remarques

console.log("a message");
console.log("a message");
console.log("a message");
console.log("a message");
console.log("a message");

for(var i = 0; i < 5; i++){
    console.log("a message");
}

Standard "pour" les boucles

Utilisation standard

for (var i = 0; i < 100; i++) {
    console.log(i);
}

Production attendue:

0
1
...
99

Déclarations multiples

Généralement utilisé pour mettre en cache la longueur d'un tableau.

var array = ['a', 'b', 'c'];
for (var i = 0; i < array.length; i++) {
    console.log(array[i]);
}

Production attendue:

'une'
'b'
'c'

Changer l'incrément

for (var i = 0; i < 100; i += 2 /* Can also be: i = i + 2 */) {
    console.log(i);
}

Production attendue:

0
2
4
...
98

Boucle décrémentée

for (var i = 100; i >=0; i--) {
    console.log(i);
}

Production attendue:

100
99
98
...
0

"while" Boucles

Boucle Standard Alors

Une boucle while standard s'exécutera jusqu'à ce que la condition donnée soit fausse:

var i = 0;
while (i < 100) {
    console.log(i);
    i++;
}

Production attendue:

0
1
...
99

Boucle décrémentée

var i = 100;
while (i > 0) {
    console.log(i);
    i--; /* equivalent to i=i-1 */
}

Production attendue:

100
99
98
...
1

Do ... tandis que la boucle

Une boucle do ... while sera toujours exécutée au moins une fois, que la condition soit vraie ou fausse:

var i = 101;
do {
    console.log(i);
} while (i < 100);

Production attendue:

101

"Pause" en boucle

Sortir d'une boucle

var i = 0;
while(true) {
    i++;
    if(i === 42) {
        break;
    }
}
console.log(i);

Production attendue:

42

Sortir d'une boucle

var i;
for(i = 0; i < 100; i++) {
    if(i === 42) {
        break;
    }
}
console.log(i);

Production attendue:

42

"continuer" une boucle

Continuer une boucle "for"

Lorsque vous placez le mot-clé continue dans une boucle for, l'exécution passe à l'expression de mise à jour ( i++ dans l'exemple):

for (var i = 0; i < 3; i++) {
    if (i === 1) {
        continue;
    }
    console.log(i);
}

Production attendue:

0
2

Continuer une boucle while

Lorsque vous continue dans une boucle while, l'exécution passe à la condition ( i < 3 dans l'exemple):

var i = 0;
while (i < 3) {
    if (i === 1) {
        i = 2;
        continue;
    }
    console.log(i);
    i++;
}

Production attendue:

0
2

boucle "do ... while"

var availableName;
do {
    availableName = getRandomName();
} while (isNameUsed(name));

Une boucle do while while est garantie au moins une fois car sa condition n'est vérifiée qu'à la fin d'une itération. Une boucle while traditionnelle peut être exécutée zéro ou plusieurs fois car sa condition est vérifiée au début d'une itération.

Casser des boucles imbriquées spécifiques

Nous pouvons nommer nos boucles et en casser une spécifique si nécessaire.

outerloop:
for (var i = 0;i<3;i++){
    innerloup:
    for (var j = 0;j <3; j++){
        console.log(i);
        console.log(j);
        if (j == 1){
            break outerloop;    
        }
    }
}

Sortie:

0
0
0
1

Briser et continuer les étiquettes

Les instructions break and continue peuvent être suivies d'une étiquette facultative qui fonctionne comme une sorte d'instruction goto, reprend l'exécution à partir de la position référencée de l'étiquette

for(var i = 0; i < 5; i++){
  nextLoop2Iteration:
  for(var j = 0; j < 5; j++){
    if(i == j) break nextLoop2Iteration;
    console.log(i, j);
  }
}

i = 0 j = 0 saute le reste des valeurs j
dix
i = 1 j = 1 saute le reste des valeurs j
2 0
2 1 i = 2 j = 2 saute le reste des valeurs j
3 0
3 1
3 2
i = 3 j = 3 saute le reste des valeurs j
4 0
4 1
4 2
4 3
i = 4 j = 4 ne se connecte pas et les boucles sont faites

"pour ... de" boucle

const iterable = [0, 1, 2];
for (let i of iterable) {
    console.log(i);
}

const string = "abc";
for (let chr of string) {
  console.log(chr);
}

const names = ['bob', 'alejandro', 'zandra', 'anna', 'bob'];

const uniqueNames = new Set(names);

for (let name of uniqueNames) {
  console.log(name);
}

const map = new Map()
  .set('abc', 1)
  .set('def', 2)

for (const iteration of map) {
  console.log(iteration) //will log ['abc', 1] and then ['def', 2]
}

const map = new Map()
  .set('abc', 1)
  .set('def', 2)

for (const [key, value] of map) {
  console.log(key + ' is mapped to ' + value)
}
/*Logs:
  abc is mapped to 1
  def is mapped to 2
*/

const someObject = { name: 'Mike' };

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

Boucle "pour ... dans"

Attention
for ... in est destiné à itérer sur des clés d'objet, pas sur des index de tableau. Son utilisation pour parcourir un tableau est généralement déconseillée . Il inclut également les propriétés du prototype, il peut donc être nécessaire de vérifier si la clé se trouve dans l'objet à l'aide de hasOwnProperty . Si des attributs de l'objet sont définis par la méthode defineProperty/defineProperties et définissent le paramètre enumerable: false , ces attributs seront inaccessibles.

var object = {"a":"foo", "b":"bar", "c":"baz"};
// `a` is inaccessible
Object.defineProperty(object , 'a', {
        enumerable: false,
});
for (var key in object) {
    if (object.hasOwnProperty(key)) {
      console.log('object.' + key + ', ' + object[key]);
    }
}

Production attendue:

object.b, bar
object.c, baz