let arr = ['el1', 'el2', 'el3'];
arr.addedProp = 'arrProp';
// elKey are the property keys
for (let elKey in arr) {
  console.log(elKey);
}
// elValue are the property values
for (let elValue of arr) {
  console.log(elValue)
}

Antwoord 4, autoriteit 9%

Voor…in lus

De voor…in lus verbetert de zwakheden van de for-lus door de tellogica en exit-voorwaarde te elimineren.

Voorbeeld:

const digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for (const index in digits) {
  console.log(digits[index]);
}

Maar je hebt nog steeds te maken met het probleem van het gebruik van een index om toegang te krijgen tot de waarden van de array, en dat stinkt; het maakt het bijna verwarrender dan voorheen.

Ook kan de for…in-lus je in grote problemen brengen als je een extra methode aan een array (of een ander object) moet toevoegen. Omdat for…in lussen een lus vormen over alle opsombare eigenschappen, betekent dit dat als u extra eigenschappen toevoegt aan het prototype van de array, deze eigenschappen ook in de lus verschijnen.

Array.prototype.decimalfy = function() {
  for (let i = 0; i < this.length; i++) {
    this[i] = this[i].toFixed(2);
  }
};
const digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for (const index in digits) {
  console.log(digits[index]);
}

Afdrukken:

0

1

2

3

4

5

6

7

8

9

functie() {
for (laat i = 0; i < deze.lengte; i++) {
dit[i] = dit[i].toFixed(2);
}
}

Dit is de reden waarom for…in-lussen worden afgeraden bij het doorlopen van arrays.

OPMERKING: de forEach-lusis een ander type for-lus in JavaScript.
Echter, forEach()is eigenlijk een array-methode, dus het kan alleen worden gebruikt
uitsluitend met arrays. Er is ook geen manier om te stoppen of te breken a
voorElke lus. Als je dat soort gedrag in je loop nodig hebt, zul je
moet een basis-for-lus gebruiken.

Voor…van lus

De voor…van loop wordt gebruikt om elk type data te herhalen dat itereerbaar is.

Voorbeeld:

const digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for (const digit of digits) {
  console.log(digit);
}

Afdrukken:

0

1

2

3

4

5

6

7

8

9

Dit maakt de for…of-lus de meest beknopte versie van alle for-lussen.

Maar wacht, er is meer! De for…of-lus heeft ook enkele extra voordelen die de zwakke punten van de for en for…in-lussen oplossen.

Je kunt een for…of-lus op elk moment stoppen of breken.

const digits = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
for (const digit of digits) {
  if (digit % 2 === 0) {
    continue;
  }
  console.log(digit);
}

Afdrukken:

1

3

5

7

9

En u hoeft zich geen zorgen te maken over het toevoegen van nieuwe eigenschappen aan objecten. De for…of-lus loopt alleen over de waarden in het object.

Antwoord 5, autoriteit 4%

Hier is een handig geheugensteuntje om het verschil tussen for...inLoop en for...ofLoop te onthouden.

“index in, object van”

for...in Loop=> herhaalt de index inde array.

for...of Loop=> herhaalt het object vanobjecten.

Antwoord 6, autoriteit 2%

De for... inVerklaring herhaalt u over de tellere eigenschappen van een object, in een willekeurige volgorde.
Slabyable eigenschappen zijn die eigenschappen waarvan de interne [[traaglijke]] vlag op true is ingesteld, dus als er een traaglijke eigenschap in de prototype keten is, zal de for... inlus ook op die eveneens optreden .

De for... ofVerklaring herhaalt over gegevens die het toneelobject definieert om geërteerd te worden.

Voorbeeld:

Object.prototype.objCustom = function() {}; 
Array.prototype.arrCustom = function() {};
let iterable = [3, 5, 7];
for (let i in iterable) {
  console.log(i); // logs: 0, 1, 2, "arrCustom", "objCustom"
}
for (let i in iterable) {
  if (iterable.hasOwnProperty(i)) {
    console.log(i); // logs: 0, 1, 2,
  }
}
for (let i of iterable) {
  console.log(i); // logs: 3, 5, 7
}

Zoals eerder, kunt u het toevoegen van hasOwnPropertyin for... ofLoops.

Antwoord 7, autoriteit 2%

Het for-in statement herhaalt de opsombare eigenschappen van een object, in willekeurige volgorde.

De lus herhaalt alle opsombare eigenschappen van het object zelf en de eigenschappen die het object erft van het prototype van de constructor

Je kunt het zien als “voor in” dat in feite herhaalt en alle sleutels opsomt.

var str = 'abc';
var arrForOf = [];
var arrForIn = [];
for(value of str){
  arrForOf.push(value);
}
for(value in str){
  arrForIn.push(value);
}
console.log(arrForOf); 
// ["a", "b", "c"]
console.log(arrForIn); 
// ["0", "1", "2", "formatUnicorn", "truncate", "splitOnLast", "contains"]

Antwoord 8, autoriteit 2%

Er zijn enkele reeds gedefinieerde gegevenstypen waarmee we ze gemakkelijk kunnen herhalen, bijvoorbeeld Array, Map, String Objects

Normaal for inherhaalt de iterator en geeft ons als reactie de sleutels die in de volgorde van invoeging staan, zoals weergegeven in het onderstaande voorbeeld.

 const numbers = [1,2,3,4,5];
   for(let number in number) {
     console.log(number);
   }
   // result: 0, 1, 2, 3, 4

Als we nu hetzelfde proberen met for of, dan geeft het ons als reactie de waarden en niet de sleutels. bijv.

 const numbers = [1,2,3,4,5];
   for(let numbers of numbers) {
    console.log(number);
  }
  // result: 1, 2, 3, 4, 5

Dus als we naar beide iterators kijken, kunnen we gemakkelijk het verschil tussen beide onderscheiden.

Opmerking:- For ofwerkt alleen met de Symbol.iterator

Dus als we proberen het normale object te herhalen, geeft het ons een foutmelding, bijvoorbeeld-

const Room = {
   area: 1000,
   height: 7,
   floor: 2
 }
for(let prop in Room) {
 console.log(prop);
 } 
// Result area, height, floor
for(let prop of Room) {
  console.log(prop);
 } 

Kamer kan niet worden herhaald

Voor het herhalen moeten we een ES6 Symbol.iterator definiëren, bijvoorbeeld

 const Room= {
    area: 1000, height: 7, floor: 2,
   [Symbol.iterator]: function* (){
    yield this.area;
    yield this.height;
    yield this.floors;
  }
}
for(let prop of Room) {
  console.log(prop);
 } 
//Result 1000, 7, 2

Dit is het verschil tussen Voor inen Voor van. Hoop dat het het verschil kan verduidelijken.

Antwoord 9

De for-in-lus

for-inlus wordt gebruikt om door opsombare eigenschappen van een verzameling te lopen, in een willekeurige volgorde. Een collectie is een object van het containertype waarvan de items een index of een sleutel kunnen gebruiken.

var myObject = {a: 1, b: 2, c: 3};
var myArray = [1, 2, 3];
var myString = "123";
console.log( myObject[ 'a' ], myArray[ 1 ], myString[ 2 ] );

var arr = [3, 5, 7];
arr.foo = "hello";
for ( var [key, val] of Object.entries( arr ) ) {
   console.log( val );
}
/* Result:
3
5
7
hello
*/