const a = ["a", "b", "c"];
for (const val of a) { // You can use `let` instead of `const` if you like
    console.log(val);
}
// a
// b
// c

Antwoord 2, autoriteit 7%

Opmerking: dit antwoord is hopeloos verouderd. Bekijk voor een modernere aanpak de methoden die beschikbaar zijn op een reeks. Interessante methoden kunnen zijn:

• voor elk
• kaart
• filter
• zip
• verminderen
• elke
• sommige

De standaardmanier om een ​​array in JavaScript te herhalen, is een vanille for-loop:

var length = arr.length,
    element = null;
for (var i = 0; i < length; i++) {
  element = arr[i];
  // Do something with element
}

Houd er echter rekening mee dat deze benadering alleen goed is als je een dichte array hebt en elke index wordt ingenomen door een element. Als de array schaars is, kun je met deze aanpak prestatieproblemen tegenkomen, omdat je veel indices zult herhalen die echt niet in de array voorkomen. In dit geval is een for .. in-loop misschien een beter idee. Echter moet u de juiste voorzorgsmaatregelen gebruiken om ervoor te zorgen dat alleen de gewenste eigenschappen van de array (dat wil zeggen, de array-elementen) worden toegepast, aangezien de for..in -loop wordt ook geteld in oudere browsers, of als de extra eigenschappen zijn gedefinieerd als enumerable.

In ECMAScript 5 zal er een forEach-methode zijn op het array-prototype, maar het wordt niet ondersteund in oudere browsers. Dus om het consistent te kunnen gebruiken, moet je een omgeving hebben die het ondersteunt (bijvoorbeeld Node. js voor server-side JavaScript), of gebruik een “Polyfill”. De Polyfill voor deze functionaliteit is echter triviaal en omdat het de code gemakkelijker leesbaar maakt, is het een goede polyfill om op te nemen.

Antwoord 3, autoriteit 3%

Als je de bibliotheek jQuery gebruikt, kun je jQuery.each:

$.each(yourArray, function(index, value) {
  // do your stuff here
});

BEWERKEN:

Volgens de vraag wil de gebruiker code in javascript in plaats van jQuery, dus de bewerking is

var length = yourArray.length;   
for (var i = 0; i < length; i++) {
  // Do something with yourArray[i].
}

Antwoord 4, autoriteit 2%

Loop achteruit

Ik denk dat de reverse for-lus hier een vermelding verdient:

for (var i = array.length; i--; ) {
     // process array[i]
}

Voordelen:

• Je hoeft geen tijdelijke len-variabele te declareren, of te vergelijken met array.length bij elke iteratie, die een van beide een minuutje optimalisatie kan zijn.
• Het verwijderen van broers en zussen uit de DOM in omgekeerde volgorde is meestal efficiënter. (De browser hoeft minder elementen in zijn interne arrays te verplaatsen.)
• Als u de array wijzigt tijdens het herhalen, op of na index i (u verwijdert bijvoorbeeld een item of voegt een item toe aan array[i]), dan zou een voorwaartse lus het item dat naar links is verschoven naar positie i overslaan, of het ide item dat naar rechts is verschoven opnieuw verwerken. In een traditionele for-lus zou i kunnen worden bijgewerkt om te verwijzen naar het volgende item dat moet worden verwerkt – 1, maar het eenvoudigweg omkeren van de iteratierichting is vaak een eenvoudiger en elegantere oplossing .
• Bij het aanpassen of verwijderen van geneste DOM-elementen kan omgekeerde verwerking fouten omzeilen. Overweeg bijvoorbeeld om de innerHTML van een bovenliggend knooppunt te wijzigen voordat u de onderliggende knooppunten afhandelt. Tegen de tijd dat de onderliggende node wordt bereikt, wordt deze losgekoppeld van de DOM en vervangen door een nieuw gemaakt kind toen de innerHTML van de ouder werd geschreven.
• Het is korter om te typen en lezen dan sommige andere beschikbare opties. Hoewel het verliest van forEach() en van ES6’s for ... of.

Nadelen:

• Het verwerkt de items in omgekeerde volgorde. Als u een nieuwe array aan het bouwen was op basis van de resultaten, of dingen op het scherm afdrukte, zal de uitvoer natuurlijk worden omgekeerd ten opzichte van de oorspronkelijke volgorde.
• Het herhaaldelijk invoegen van broers en zussen in de DOM als eerste kind om hun volgorde te behouden is minder efficiënt. (De browser zou dingen steeds weer naar rechts moeten verplaatsen.) Om DOM-knooppunten efficiënt en in de juiste volgorde te maken, loop je gewoon vooruit en voeg je zoals normaal toe (en gebruik je ook een “documentfragment”).
• De omgekeerde lus is verwarrend voor junior ontwikkelaars. (U kunt dat als een voordeel beschouwen, afhankelijk van uw vooruitzichten.)

Moet ik het altijd gebruiken?

Sommige ontwikkelaars gebruiken standaard de reverse for loop, tenzij er een goede reden is om forwards te loopen.

Hoewel de prestatieverbeteringen meestal onbeduidend zijn, schreeuwt het een beetje:

“Doe dit gewoon met elk item in de lijst, de bestelling maakt me niet uit!”

In de praktijk is dat echter geen eigenlijk een betrouwbare indicatie van intentie, aangezien het niet te onderscheiden is van die momenten waarop u wel geeft om de volgorde, en echt nodig om in omgekeerde volgorde te herhalen. Er zou dus in feite een andere constructie nodig zijn om de “don’t care”-intentie nauwkeurig uit te drukken, iets dat momenteel niet beschikbaar is in de meeste talen, waaronder ECMAScript, maar dat bijvoorbeeld forEachUnordered() zou kunnen heten.

Als volgorde er niet toe doet, en efficiëntie een punt van zorg is (in de binnenste lus van een game of animatie-engine), dan kan het acceptabel zijn om de omgekeerde for-lus te gebruiken als uw doel- te patroon. Onthoud dat het zien van een omgekeerde for-lus in bestaande code niet noodzakelijkerwijs betekent dat de volgorde niet relevant is!

Het was beter om forEach()

. te gebruiken

Over het algemeen heb ik voor code op een hoger niveau waar duidelijkheid en veiligheid grotere zorgen zijn, eerder aanbevolen Array::forEach als uw standaardpatroon voor looping (hoewel ik tegenwoordig liever for..of). Redenen om forEach te verkiezen boven een omgekeerde lus zijn:

• Het is duidelijker om te lezen.
• Het geeft aan dat i niet binnen het blok zal worden verschoven (wat altijd een mogelijke verrassing is die zich verstopt in lange for en while lussen).
• Het geeft je een vrije ruimte voor sluitingen.
• Het vermindert het lekken van lokale variabelen en onbedoelde botsingen met (en mutatie van) externe variabelen.

Als je dan de omgekeerde for-lus in je code ziet, is dat een hint dat het om een ​​goede reden is omgekeerd (misschien een van de hierboven beschreven redenen). En het zien van een traditionele forward for loop kan erop wijzen dat er kan worden verschoven.

(Als de discussie over intentie voor jou geen zin heeft, kunnen jij en je code baat hebben bij het bekijken van de lezing van Crockford op Programmeerstijl en je hersenen.)

Het is nu nog beter te gebruiken for..of!

Er is discussie over de vraag of for..of of forEach() de voorkeur heeft:

• Voor maximale browserondersteuning, for..of vereist een polyfill voor iterators, waardoor uw app iets langzamer wordt uitgevoerd en iets groter om te downloaden.

• Daarom (en om het gebruik van map en filter aan te moedigen), sommige front-end stijlgidsen verbieden for..of volledig!

• Maar de bovenstaande zorgen zijn niet van toepassing op Node.js-applicaties, waar for..of nu goed wordt ondersteund.

• En verder await werkt niet binnen forEach(). Het gebruik van for..of is het duidelijkste patroon in dit geval.

Persoonlijk heb ik de neiging om alles te gebruiken wat het gemakkelijkst te lezen lijkt, tenzij prestatie of verkleining een belangrijk punt van zorg is geworden. Dus tegenwoordig gebruik ik liever for..of in plaats van forEach(), maar ik zal altijd map of filter of find of some indien van toepassing.
(In het belang van mijn collega’s gebruik ik zelden reduce.)

Hoe werkt het?

for (var i = 0; i < array.length; i++) { ... }   // Forwards
for (var i = array.length; i--; )    { ... }   // Reverse

Je zult merken dat i-- de middelste clausule is (waar we meestal een vergelijking zien) en de laatste clausule leeg is (waar we meestal i++ zien). Dat betekent dat i-- ook wordt gebruikt als de voorwaarde voor voortzetting. Cruciaal is dat het vóór elke iteratie wordt uitgevoerd en gecontroleerd.

• Hoe kan het beginnen op array.length zonder te exploderen?

  Omdat i-- vóór elke iteratie wordt uitgevoerd, hebben we bij de eerste iteratie daadwerkelijk toegang tot het item op array.length - 1 wat problemen met Array-out-of-bounds undefined items voorkomt.

• Waarom stopt het niet met herhalen vóór index 0?

  De lus stopt met herhalen wanneer de voorwaarde i-- evalueert tot een falsey-waarde (wanneer deze 0 oplevert).

  De truc is dat, in tegenstelling tot --i, de afsluitende operator i-- i verlaagt, maar de waarde vóór de verlaging. Uw console kan dit aantonen:

  > var i = 5; [i, i--, i];

  [5, 5, 4]

  Dus bij de laatste iteratie was i eerder 1 en de uitdrukking i-- verandert deze in 0 maar levert in feite 1 (waarheid) op, en dus verstrijkt de voorwaarde. Bij de volgende iteratie verandert i-- i in -1 maar levert 0 (falsey) op, waardoor de uitvoering vallen onmiddellijk uit de onderkant van de lus.

  In de traditionele forwards for loop zijn i++ en ++i onderling uitwisselbaar (zoals Douglas Crockford aangeeft). Maar in de omgekeerde for-lus, omdat onze afname ook onze voorwaarde-uitdrukking is, moeten we i-- gebruiken als we het item op index 0 willen verwerken.

Trivia

Sommige mensen tekenen graag een pijltje in de omgekeerde for-lus en eindigen met een knipoog:

for (var i = array.length; i --> 0 ;) {

De credits gaan naar WYL voor het tonen van de voordelen en gruwelen van de reverse for loop.

Antwoord 5

Sommige C-achtige talen gebruiken forEach opsommingen te doorlopen. In JavaScript wordt dit gedaan met de for..in lusstructuur:

var index,
    value;
for (index in obj) {
    value = obj[index];
}

Er is een addertje onder het gras. for..in doorloopt elk van de opsombare leden van het object en de leden op het prototype. Om te voorkomen dat u waarden leest die via het prototype van het object zijn overgenomen, hoeft u alleen maar te controleren of de eigenschap bij het object hoort:

for (i in obj) {
    if (obj.hasOwnProperty(i)) {
        //do stuff
    }
}

Bovendien heeft ECMAScript 5 een forEach methode om Array.prototype die kan worden gebruikt om een ​​array op te sommen met behulp van een calback (de polyfill staat in de documenten, dus je kunt het nog steeds gebruiken voor oudere browsers):

arr.forEach(function (val, index, theArray) {
    //do stuff
});

Het is belangrijk op te merken dat Array.prototype.forEach niet kapot gaat wanneer de callback false retourneert. jQuery en Underscore.js bieden hun eigen variaties op each om lussen te bieden die kunnen worden kortgesloten.

Antwoord 6

Als je een array wilt doorlopen, gebruik dan de standaard driedelige for-lus.

for (var i = 0; i < myArray.length; i++) {
    var arrayItem = myArray[i];
}

Je kunt prestatie-optimalisaties krijgen door myArray.length in de cache te plaatsen of er achteruit te herhalen.

Antwoord 7

Als je het niet erg vindt om de array leeg te maken:

var x;
while(x = y.pop()){ 
    alert(x); //do something 
}

x zal de laatste waarde van y bevatten en zal uit de array worden verwijderd. Je kunt ook shift() gebruiken, waarmee het eerste item van y wordt gegeven en verwijderd.

Antwoord 8

Ik weet dat dit een oud bericht is en er zijn al zoveel goede antwoorden. Voor een beetje meer volledigheid dacht ik dat ik er nog een zou toevoegen met behulp van AngularJS. Dit is natuurlijk alleen van toepassing als je Angular gebruikt, natuurlijk, maar toch zou ik het toch willen zeggen.

angular.forEach heeft 2 argumenten en een optioneel derde argument. Het eerste argument is het object (array) waarover moet worden herhaald, het tweede argument is de iteratorfunctie en het optionele derde argument is de objectcontext (in de lus in feite ‘dit’ genoemd.

Er zijn verschillende manieren om de forEach-lus van angular te gebruiken. De eenvoudigste en waarschijnlijk meest gebruikte is

var temp = [1, 2, 3];
angular.forEach(temp, function(item) {
    //item will be each element in the array
    //do something
});

Een andere manier die handig is om items van de ene array naar de andere te kopiëren, is

var temp = [1, 2, 3];
var temp2 = [];
angular.forEach(temp, function(item) {
    this.push(item); //"this" refers to the array passed into the optional third parameter so, in this case, temp2.
}, temp2);

Hoewel u dat niet hoeft te doen, kunt u gewoon het volgende doen en dit is gelijk aan het vorige voorbeeld:

angular.forEach(temp, function(item) {
    temp2.push(item);
});

Er zijn nu voor- en nadelen aan het gebruik van de functie angular.forEach in tegenstelling tot de ingebouwde for-lus met vanillesmaak.

Pluspunten

• Gemakkelijke leesbaarheid
• Eenvoudige beschrijfbaarheid
• Indien beschikbaar, zal angular.forEach de ES5 forEach-lus gebruiken. Nu zal ik tot efficiëntie komen in de cons-sectie, omdat de forEach-lussen veel langzamer zijn dan de for-lussen. Ik vermeld dit als een professional omdat het fijn is om consistent en gestandaardiseerd te zijn.

Beschouw de volgende 2 geneste lussen, die precies hetzelfde doen. Laten we zeggen dat we 2 arrays van objecten hebben en elk object bevat een array van resultaten, die elk een Value eigenschap hebben die een string is (of wat dan ook). En laten we zeggen dat we elk van de resultaten moeten herhalen en als ze gelijk zijn, voer dan een actie uit:

angular.forEach(obj1.results, function(result1) {
    angular.forEach(obj2.results, function(result2) {
        if (result1.Value === result2.Value) {
            //do something
        }
    });
});
//exact same with a for loop
for (var i = 0; i < obj1.results.length; i++) {
    for (var j = 0; j < obj2.results.length; j++) {
        if (obj1.results[i].Value === obj2.results[j].Value) {
            //do something
        }
    }
}

Toegegeven, dit is een heel eenvoudig hypothetisch voorbeeld, maar ik heb triple embedded for-loops geschreven met de tweede benadering en het was erg moeilijk te lezen en te schrijven wat dat betreft.

Nadelen

• Efficiëntie. angular.forEach en de native forEach zijn trouwens beide zo veel langzamer dan de normale for loop….ongeveer 90% langzamer. Dus voor grote datasets kun je het beste vasthouden aan de native for-lus.
• Geen ondersteuning voor pauzeren, doorgaan of retourneren. continue wordt feitelijk ondersteund door “ongeluk“, om ga verder in een angular.forEach je plaatst eenvoudig een return; statement in de functie zoals angular.forEach(array, function(item) { if (someConditionIsTrue) return; }); waardoor het uit de functie voor die iteratie blijft. Dit is ook te wijten aan het feit dat de native forEach ook geen pauze of doorgaan ondersteunt.

Ik weet zeker dat er ook verschillende andere voor- en nadelen zijn, en voel je vrij om alles toe te voegen dat je nodig hebt. Ik ben van mening dat, als je efficiëntie nodig hebt, alleen de native for-lus voor je looping-behoeften moet blijven. Maar als je datasets kleiner zijn en een beetje efficiëntie oké is om op te geven in ruil voor leesbaarheid en beschrijfbaarheid, gooi dan zeker een angular.forEach in die stoute jongen.

Antwoord 9

Een forEach implementatie (zie in jsFiddle):

function forEach(list,callback) {
  var length = list.length;
  for (var n = 0; n < length; n++) {
    callback.call(list[n]);
  }
}
var myArray = ['hello','world'];
forEach(
  myArray,
  function(){
    alert(this); // do something
  }
);

Antwoord 10

Vanaf ECMAScript 6:

list = [0, 1, 2, 3]
for (let obj of list) {
    console.log(obj)
}

var array = new Array();
array[1] = "Hello";
array[7] = "World";
array[11] = "!";

for(var i in array){
    var el = array[i];
    //If you want 'i' to be INT just put parseInt(i)
    //Do something with el
}

function foreach(array, call){
    for(var i in array){
        call(array[i]);
    }
}

function foreach(array, call){
    for(var i in array){
        if(call(array[i]) == false){
            break;
        }
    }
}

foreach(array, function(el){
    if(el != "!"){
        console.log(el);
    } else {
        console.log(el+"!!");
    }
});

//Hello
//World
//!!!

var a = [3,2];
$(a).each(function(){console.log(this.valueOf())}); //Method 1
$.each(a, function(){console.log(this.valueOf())}); //Method 2
$.each($(a), function(){console.log(this.valueOf())}); //Method 3

var arr = ["elemA", "elemB", "elemC"];
_.each(arr, function(elem, index, ar)
{
...
});

for (var instance in objects) {
   ...
}

var instance;
for (var i=0; i < objects.length; i++) {
    var instance = objects[i];
    ...
}

function each( fn, data ) {
    if(typeof fn == 'string')
        eval('fn = function(data, i){' + fn + '}');
    for(var i=0, L=this.length; i < L; i++) 
        fn.call( this[i], data, i );   
    return this;
}
Array.prototype.each = each;  

var arr = [];
[1, 2, 3].each( function(a){ a.push( this * this}, arr);
arr = [1, 4, 9]

each.call(document.getElementsByTagName('p'), "this.className = data;",'blue');

each.call(document.getElementsByTagName('p'), 
    "if( i % 2 == 0) this.className = data;",
    'red'
);

each.call(document.querySelectorAll('p.blue'), 
    function(newClass, i) {
        if( i < 20 )
            this.className = newClass;
    }, 'green'
);

var languages = ["Java", "JavaScript", "C#", "Python"];
var i, len, text;
for (i = 0, len = languages.length, text = ""; i < len; i++) {
    text += languages[i] + "<br>";
}
document.getElementById("example").innerHTML = text;

<p id="example"></p>

['C', 'D', 'E'].forEach(function(element, index) {
  console.log(element + " is #" + (index+1) + " in the musical scale");
});
// Output
// C is the #1 in musical scale
// D is the #2 in musical scale
// E is the #3 in musical scale

// Let's upper case the items in the array
['bob', 'joe', 'jen'].map(function(elem) {
  return elem.toUpperCase();
});
// Output: ['BOB', 'JOE', 'JEN']

[1,2,3,4].reduce(function(previous, current) {
  return previous + current;
});
// Output: 10
// 1st iteration: previous=1, current=2 => result=3
// 2nd iteration: previous=3, current=3 => result=6
// 3rd iteration: previous=6, current=4 => result=10

// Check if everybody has 18 years old of more.
var ages = [30, 43, 18, 5];
ages.every(function(elem) {
  return elem >= 18;
});
// Output: false

// Finding the even numbers
[1,2,3,4,5,6].filter(function(elem){
  return (elem % 2 == 0)
});
// Output: [2,4,6]

[1,2,3].some(function(number) {
    return number === 1;
});

var foo = [object,object,object];
for (var i = foo.length, item; item = foo[--i];) {
    console.log(item);
}

var data = [1, 2, 3, 4, 5, 6, 7];
var newData = $.map(data, function(element) {
    if (element % 2 == 0) {
        return element;
    }
});
// newData = [2, 4, 6];

let arrSimple = ['a', 'b', 'c'];
for (let letter of arrSimple) {
  console.log(letter);
}

myArray.forEach(
  (item) => {
    // Do something
    console.log(item);
  }
);

var myArray = [1, 2, 3];
myArray = myArray.map(
  (item) => {
    return item + 1;
  }
);
console.log(myArray); // [2, 3, 4]

let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
//let arr = Array.from(Array(1000000), (x, i) => i%10);
function Aa(a, s=0) {
  for(let i=0; i<a.length; i++) {
    s += a[i];
  }
  console.log('Aa=', s);
}
function Ab(a, s=0) {
  let n = a.length;
  for(let i=0; i<n; i++) {
    s += a[i];
  }
  console.log('Ab=', s);
}
function Ac(a, s=0) {
  for(let i=a.length; i--;) {
    s += a[i];
  }
  console.log('Ac=', s);
}
function Ad(a, s=0) {
  for(let x of a) {
    s += x;
  }
  console.log('Ad=', s);
}
function Ae(a, s=0) {
  for(let i in a) if (a.hasOwnProperty(i)) {
    s += a[i];
  }
  console.log('Ae=', s);
}
function Ba(a, s=0) {
  let i = -1;
  while(++i < a.length) {
    s+= a[i];
  }
  console.log('Ba=', s);
}
function Bb(a, s=0) {
  let i = -1;
  let n = a.length;
  while(++i < n) {
    s+= a[i];
  }
  console.log('Bb=', s);
}
function Bc(a, s=0) {
  let i = a.length;
  while(i--) {
    s += a[i];
  }
  console.log('Bc=', s);
}
function Bd(a, s=0) {
  let i = 0;
  do {
    s+= a[i]
  } while (++i < a.length);
  console.log('Bd=', s);
}
function Be(a, s=0) {
  let i = 0;
  let n = a.length;
  do {
    s += a[i]
  } while (++i < n);
  console.log('Be=', s);
}
function Bf(a, s=0) {
  const it = a.values(); 
  let e;
  while (!(e = it.next()).done) { 
    s+= e.value; 
  }
  console.log('Bf=', s);
}
function Ca(a, s=0) {
  a.map(x => { s+=x });
  console.log('Ca=', s);
}
function Cb(a, s=0) {
  a.forEach(x => { s+=x });
  console.log('Cb=', s);
}
function Cc(a, s=0) {
  a.every(x => (s += x, 1));
  console.log('Cc=', s);
}
function Cd(a, s=0) {
  a.filter(x => { s+=x });
  console.log('Cd=',s);
}
function Ce(a, s=0) {
  a.reduce((z, c) => { s+=c }, 0);
  console.log('Ce=', s);
}
function Cf(a, s=0) {
  a.reduceRight((z, c) => { s += c }, 0);
  console.log('Cf=', s);
}
function Cg(a, s=0) {
  a.some(x => { s += x } );
  console.log('Cg=', s);
}
function Ch(a, s=0) {
  Array.from(a, x=> s += x);
  console.log('Cc=', s);
}
Aa(arr);
Ab(arr);
Ac(arr);
Ad(arr);
Ae(arr);
Ba(arr);
Bb(arr);
Bc(arr);
Bd(arr);
Be(arr);
Bf(arr);
Ca(arr);
Cb(arr);
Cc(arr);
Cd(arr);
Ce(arr);
Cf(arr);
Cg(arr);
Ch(arr);

<p style="color: red">This snippets only PRESENTS code used for benchmark - it not perform test itself</p>

[].forEach.call(arrayName,function(value,index){
    console.log("value of the looped element" + value);
    console.log("index of the looped element" + index);
});

$("#ul>li").each(function(**index, value**){
    console.log("value of the looped element" + value);
    console.log("index of the looped element" + index);
});

let theArray= [1,3,2];
theArray.forEach((element) => {
  // Use the element of the array
  console.log(element)
}

1
3
2

for (let i=0; i<theArray.length; i++) {
  console.log(i); // i will have the value of each index
}

theArray.forEach ( element => {
    console.log(element);
});

for(let idx = 0; idx < theArray.length; idx++){
    let element = theArray[idx];
    console.log(element);
}

let arr = [{name:'john', age:50}, {name:'clark', age:19}, {name:'mohan', age:26}];
arr.forEach((person)=>{
  console.log('I am ' + person.name + ' and I am ' + person.age + ' old');
})

for(var i = 0; i < 5; i++){
  console.log(i);
}
// Output: 0,1,2,3,4

let obj = {"a":1, "b":2}
for(let k in obj){
  console.log(k)
}
// Output: a,b

let array = [1,2,3,4]
array.forEach((x) => {
  console.log(x);
})
// Output: 1,2,3,4

let array = [1,2,3,4]
for(let x of array){
  console.log(x);
}
// Output: 1,2,3,4

let x = 0
while(x < 5){
  console.log(x)
  x++
}
// Output: 1,2,3,4

let x = 0
do{
  console.log(x)
  x++
}while(x < 5)
// Output: 1,2,3,4

let arr = [1, 2, 3, 4, 5];
let newArr = arr.map((element, index, array) => {
  return element * 2;
})
console.log(arr);
console.log(newArr);

    const myArr = [2,3,4]
let it = myArr.values();
console.log(it.next());
console.log(it.next());
console.log(it.next());
console.log(it.next());