node - w3schools javascript array foreach




Para cada um em uma matriz em JavaScript? (19)

Loop para trás

Eu acho que o reverso para loop merece uma menção aqui:

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

Vantagens:

  • Você não precisa declarar uma variável temporária len ou comparar com array.length em cada iteração, sendo que uma delas pode ser uma otimização por minuto.
  • Removendo irmãos do DOM na ordem inversa é geralmente mais eficiente . (O navegador precisa fazer menos mudanças de elementos em suas matrizes internas.)
  • Se você modificar a matriz durante o loop, no ou após o índice i (por exemplo, remover ou inserir um item na array[i] ), um loop de encaminhamento ignorará o item que foi deslocado para a esquerda na posição i ou processará novamente o i o item que foi deslocado para a direita. Em um loop for tradicional, você pode atualizar i para apontar para o próximo item que precisa de processamento - 1, mas simplesmente reverter a direção da iteração é geralmente uma solução mais simples e elegante .
  • Da mesma forma, ao modificar ou remover elementos DOM aninhados , o processamento reverso pode contornar erros . Por exemplo, considere modificar o innerHTML de um nó pai antes de manipular seus filhos. No momento em que o nó filho for alcançado, ele será desanexado do DOM, tendo sido substituído por um filho recém-criado quando o innerHTML do pai foi gravado.
  • É mais curto para digitar e ler do que algumas das outras opções disponíveis. Embora perde para forEach() e para ES6 for ... of .

Desvantagens:

  • Ele processa os itens na ordem inversa. Se você estivesse criando uma nova matriz a partir dos resultados ou imprimindo coisas na tela, naturalmente a saída será invertida em relação à ordem original.
  • Inserir repetidamente irmãos no DOM como primeiro filho para manter a ordem é menos eficiente . (O navegador continuaria tendo que mudar as coisas corretamente.) Para criar nós DOM de maneira eficiente e ordenada, apenas faça um loop para frente e acrescente normalmente (e também use um "fragmento de documento").
  • O loop reverso é confuso para desenvolvedores juniores. (Você pode considerar isso como uma vantagem, dependendo do seu ponto de vista.)

Devo sempre usá-lo?

Alguns desenvolvedores usam o reverso para loop por padrão , a menos que haja uma boa razão para fazer o loop para frente.

Embora os ganhos de desempenho sejam geralmente insignificantes, é um tipo de grito:

"Faça isso em todos os itens da lista, não me importo com o pedido!"

No entanto, na prática, isso não é realmente uma indicação confiável de intenção, uma vez que é indistinguível das ocasiões em que você se importa com a ordem, e realmente precisa fazer um loop ao contrário. Então, de fato, outro construto seria necessário para expressar com precisão a intenção de "não se importar", algo atualmente indisponível na maioria das linguagens, incluindo o ECMAScript, mas que poderia ser chamado, por exemplo, de forEachUnordered() .

Se a ordem não é importante, e a eficiência é uma preocupação (no loop mais interno de um mecanismo de jogo ou animação), pode ser aceitável usar o loop reverso como seu padrão de referência. Apenas lembre-se de que ver um loop reverso no código existente não significa necessariamente que a ordem é irrelevante!

É melhor usar forEach ()

Em geral, para códigos de nível mais alto, em que a clareza e a segurança são preocupações maiores, recomendo usar o Array::forEach como seu padrão padrão:

  • É claro para ler.
  • Isso indica que eu não será deslocado dentro do bloco (o que é sempre uma possível surpresa escondida em loops longos e longos).
  • Dá-lhe um escopo livre para fechamentos.
  • Reduz o vazamento de variáveis ​​locais e a colisão acidental com (e mutação de) variáveis ​​externas.

Então, quando você vê o reverso do loop em seu código, isso é uma dica de que ele é revertido por um bom motivo (talvez uma das razões descritas acima). E ver um forward loop tradicional pode indicar que a mudança pode ocorrer.

(Se a discussão da intenção não faz sentido para você, então você e seu código podem se beneficiar assistindo a palestra de Crockford sobre Estilo de Programação e Seu Cérebro .)

Como funciona?

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

for (var i = array.length; i--; )    { ... }   // Reverse

Você notará que i-- é a cláusula do meio (onde normalmente vemos uma comparação) e a última cláusula está vazia (onde normalmente vemos i++ ). Isso significa que i-- também é usado como condição para continuação. Crucialmente, ele é executado e verificado antes de cada iteração.

  • Como pode começar em array.length sem explodir?

    Como i-- é executado antes de cada iteração, na primeira iteração, na verdade, estaremos acessando o item em array.length - 1 que evita qualquer problema com itens undefined fora de limites .

  • Por que não para iterar antes do índice 0?

    O loop irá parar de iterar quando a condição i-- avaliada como um valor de falsey (quando gerar 0).

    O truque é que, diferentemente de --i , o operador i final decrementa i mas produz o valor antes do decremento. Seu console pode demonstrar isso:

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

    [5, 5, 4]

    Então, na iteração final, eu era anteriormente 1 e a expressão i-- muda para 0 mas na verdade produz 1 (truthy), e assim a condição passa. Na próxima iteração i - muda i para -1, mas produz 0 (falsey), fazendo com que a execução caia imediatamente da parte inferior do loop.

    Nos forwards tradicionais para loop, i++ e ++i são intercambiáveis ​​(como Douglas Crockford aponta). No entanto, no reverso do loop, porque o nosso decréscimo é também a nossa expressão de condição, devemos ficar com i-- se quisermos processar o item no índice 0.

Trivialidades

Algumas pessoas gostam de desenhar uma pequena seta no sentido inverso for loop e terminam com uma piscada:

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

Os créditos vão para o WYL por me mostrar os benefícios e horrores do reverso do loop.

Como posso percorrer todas as entradas em uma matriz usando JavaScript?

Eu pensei que era algo assim:

forEach(instance in theArray)

Onde theArray é minha matriz, mas isso parece estar incorreto.


Resumo:

Ao iterar em um array, muitas vezes podemos realizar um dos seguintes objetivos:

  1. Queremos fazer uma iteração sobre o array e criar um novo array:

    Array.prototype.map

  2. Queremos iterar pelo array e não criar um novo array:

    Array.prototype.forEach

    for..of laço

Em JS, existem muitas maneiras de atingir esses dois objetivos. No entanto, alguns são mais conventivos do que outros. Abaixo você pode encontrar alguns métodos comumente usados ​​(o imo mais conventiente) para realizar iteração de array em javascript.

Criando nova matriz: Map

map()é uma função localizada na Array.prototypequal pode transformar todos os elementos de uma matriz e, em seguida, retorna uma nova matriz. map()toma como argumento uma função de callback e funciona da seguinte maneira:

let arr = [1, 2, 3, 4, 5];

let newArr = arr.map((element, index, array) => {
  return element * 2;
})

console.log(arr);
console.log(newArr);

O callback em que passamos map()como um argumento é executado para cada elemento. Em seguida, uma matriz é retornada, que tem o mesmo tamanho que a matriz original. Nesse novo elemento de matriz é transformado pela função de retorno de chamada passada como um argumento para map().

A diferença distinta entre o mapmecanismo de loop e outro como forEachum for..ofloop é que mapretorna como nova matriz e deixa o antigo array intacto (exceto se você explicitamente manipulá-lo com pensa como splice).

Observe também que o mapretorno de chamada da função fornece como segundo argumento o número do índice da iteração atual. Além disso, o terceiro argumento fornece o array no qual mapfoi chamado. Às vezes, essas propriedades podem ser muito úteis.

Loop usando forEach

forEaché uma função localizada na Array.prototypequal é usada uma função de retorno de chamada como um argumento. Em seguida, ele executa essa função de retorno de chamada para todos os elementos da matriz. Em contraste com a map()função, a função forEach retorna nothing ( undefined). Por exemplo:

let arr = [1, 2, 3, 4, 5];

arr.forEach((element, index, array) => {

  console.log(element * 2);

  if (index === 4) {
    console.log(array)
  }
  // index, and oldArray are provided as 2nd and 3th argument by the callback

})

console.log(arr);

Assim como a mapfunção, o forEachcallback fornece como segundo argumento o número do índice da iteração atual. O terceiro argumento também fornece o array no qual forEachfoi chamado.

Loop através de elementos usando for..of

O for..ofloop faz um loop em todos os elementos de uma matriz (ou qualquer outro objeto iterável). Funciona da seguinte maneira:

let arr = [1, 2, 3, 4, 5];

for(let element of arr) {
  console.log(element * 2);
}

No exemplo acima elementrepresenta um elemento de matriz e arré a matriz que queremos fazer um loop. Não que o nome elementseja arbitrário e poderíamos ter escolhido qualquer outro nome como 'el' ou algo mais declarativo quando isso for aplicável.

Não confunda o for..inloop com o for..ofloop. for..inIrá percorrer todas as propriedades enumeráveis ​​da matriz, enquanto o for..ofloop apenas percorrerá os elementos da matriz. Por exemplo:

let arr = [1, 2, 3, 4, 5];

arr.foo = 'foo';

for(let element of arr) {
  console.log(element);
}

for(let element in arr) {
  console.log(element);
}


Se você estiver usando a biblioteca jQuery , você pode usar jQuery.each :

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

EDITAR:

Como por questão, o usuário quer código em javascript em vez de jquery, então a edição é

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

Se você quiser fazer um loop em uma matriz, use o loop padrão de três partes for loop.

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

Você pode obter algumas otimizações de desempenho armazenando em cache myArray.length ou iterando de trás para frente.


A partir do ES6:

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

Onde ofevita as esquisitices associadas ine faz com que funcione como o forloop de qualquer outra linguagem, e letliga identro do loop em oposição a dentro da função.

As chaves ( {}) podem ser omitidas quando há apenas um comando (por exemplo, no exemplo acima).


Edit : Esta resposta está irremediavelmente desatualizada. Para uma abordagem mais moderna, observe os métodos disponíveis em uma matriz . Os métodos de interesse podem ser:

  • para cada
  • mapa
  • filtro
  • fecho eclair
  • reduzir
  • cada
  • alguns

A maneira padrão de iterar um array em JavaScript é uma baunilha for -loop:

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

Observe, no entanto, que essa abordagem só é boa se você tiver uma matriz densa e cada índice estiver ocupado por um elemento. Se a matriz for escassa, você poderá encontrar problemas de desempenho com essa abordagem, já que você iterará sobre muitos índices que realmente não existem na matriz. Neste caso, um for .. in -loop pode ser uma ideia melhor. No entanto , você deve usar as proteções apropriadas para garantir que apenas as propriedades desejadas da matriz (isto é, os elementos da matriz) sejam acionadas, pois o forin- for..in também será enumerado em navegadores herdados ou, se propriedades são definidas como enumerable .

No ECMAScript 5 , haverá um método forEach no protótipo de matriz, mas não é suportado em navegadores herdados. Portanto, para poder usá-lo consistentemente, você deve ter um ambiente que ofereça suporte a ele (por exemplo, Node.js para JavaScript do lado do servidor) ou use um "Polyfill". O Polyfill para essa funcionalidade é, no entanto, trivial e, como facilita a leitura do código, é um bom polyfill para incluir.


Usando Loops com o operador de destructuring e propagação do ES6

A desestruturação e o uso do spread operator mostraram-se bastante úteis para os recém-chegados ao ES6 como mais legíveis / estéticos, embora alguns veteranos do javascript possam considerá-lo confuso, juniores ou outras pessoas podem achar útil.

Os exemplos a seguir usarão for...ofinstrução e .forEachmétodo.

Exemplos 6, 7 e 8 podem ser usados com quaisquer lacetes funcionais, como .map, .filter, .reduce, .sort, .every, .some, para obter mais informação sobre estes métodos vá para o objeto de matriz .

Exemplo 1:for...of loop normal - sem truques aqui.

let arrSimple = ['a', 'b', 'c'];

for (let letter of arrSimple) {
  console.log(letter);
}

Exemplo 2: dividir palavras para caracteres

let arrFruits = ['apple', 'orange', 'banana'];

for (let [firstLetter, ...restOfTheWord] of arrFruits) {
  // Create a shallow copy using the spread operator
  let [lastLetter] = [...restOfTheWord].reverse();
  console.log(firstLetter, lastLetter, restOfTheWord);

}

Exemplo 3: Looping com um keyevalue

// let arrSimple = ['a', 'b', 'c'];

// Instead of keeping an index in `i` as per example `for(let i = 0 ; i<arrSimple.length;i++)`
// this example will use a multi-dimensional array of the following format type: 
// `arrWithIndex: [number, string][]`

let arrWithIndex = [
  [0, 'a'],
  [1, 'b'],
  [2, 'c'],
];

// Same thing can be achieved using `.map` method
// let arrWithIndex = arrSimple.map((i, idx) => [idx, i]);

// Same thing can be achieved using `Object.entries`
// NOTE: `Object.entries` method doesn't work on internet explorer unless it's polyfilled
// let arrWithIndex = Object.entries(arrSimple);

for (let [key, value] of arrWithIndex) {
  console.log(key, value);
}

Exemplo 4: Obter as propriedades do objeto inline

let arrWithObjects = [{
    name: 'Jon',
    age: 32
  },
  {
    name: 'Elise',
    age: 33
  }
];

for (let { name, age: aliasForAge } of arrWithObjects) {
  console.log(name, aliasForAge);
}

Exemplo 5: Obtenha propriedades de objetos profundos do que você precisa

let arrWithObjectsWithArr = [{
    name: 'Jon',
    age: 32,
    tags: ['driver', 'chef', 'jogger']
  },
  {
    name: 'Elise',
    age: 33,
    tags: ['best chef', 'singer', 'dancer']
  }
];

for (let { name, tags: [firstItemFromTags, ...restOfTags] } of arrWithObjectsWithArr) {
  console.log(name, firstItemFromTags, restOfTags);
}

Exemplo 6: O Exemplo 3 é usado com.forEach

let arrWithIndex = [
  [0, 'a'],
  [1, 'b'],
  [2, 'c'],
];

// Not to be confused here, `forEachIndex` is the real index
// `mappedIndex` was created by "another user", so you can't really trust it

arrWithIndex.forEach(([mappedIndex, item], forEachIndex) => {
  console.log(forEachIndex, mappedIndex, item);
});

Exemplo 7: O exemplo 4 é usado com.forEach

let arrWithObjects = [{
    name: 'Jon',
    age: 32
  },
  {
    name: 'Elise',
    age: 33
  }
];
// NOTE: Destructuring objects while using shorthand functions 
// are required to be surrounded by parenthesis
arrWithObjects.forEach( ({ name, age: aliasForAge }) => {
  console.log(name, aliasForAge)
});

Exemplo 8: O Exemplo 5 é usado com.forEach

let arrWithObjectsWithArr = [{
    name: 'Jon',
    age: 32,
    tags: ['driver', 'chef', 'jogger']
  },
  {
    name: 'Elise',
    age: 33,
    tags: ['best chef', 'singer', 'dancer']
  }
];

arrWithObjectsWithArr.forEach(({
  name,
  tags: [firstItemFromTags, ...restOfTags]
}) => {
  console.log(name, firstItemFromTags, restOfTags);
});


A sintaxe lambda geralmente não funciona no IE 10 ou abaixo.

Eu costumo usar o

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


If you are a jQuery Fan and already have a jQuery file running, you should reverse the positions of the index and value parameters

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

Este é um iterador para a lista NON-SPARSE, onde o índice começa em 0, que é o cenário típico quando se lida com document.getElementsByTagName ou document.querySelectorAll)

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;  

Exemplos de uso:

Exemplo 1

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

Exemplo # 2

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

Cada tag p recebe class="blue"

Exemplo # 3

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

Todas as outras tags p recebem class="red">

Exemplo # 4

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

E finalmente as primeiras 20 tags p azuis são alteradas para verde

Cuidado ao usar string como função: a função é criada fora de contexto e deve ser usada somente quando você tiver certeza do escopo da variável. Caso contrário, é melhor passar funções em que o escopo é mais intuitivo.


Eu também gostaria de adicionar isso como uma composição de um loop reverso e uma resposta acima para alguém que gostaria dessa sintaxe também.

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

Prós:

O benefício para isso: Você já tem a referência no primeiro como esse que não precisará ser declarado posteriormente com outra linha. É útil ao fazer loop através da matriz de objetos.

Contras:

Isto irá quebrar sempre que a referência for falsa - falsey (indefinida, etc.). Pode ser usado como uma vantagem embora. No entanto, isso tornaria um pouco mais difícil de ler. E também dependendo do navegador, ele pode ser "não" otimizado para trabalhar mais rápido que o original.


Você pode ligar paraEn assim:

var a = ["car", "bus", "truck"]
a.forEach(function(item, index) {
    console.log("Index" + index);
    console.log("Element" + item);
})

elemento terá o valor de cada índice de 0 para o comprimento da matriz.

Saída:

let Array = [1,3,2];

theArray.forEach((element)=>{ 
  // use the element of the array
  console.log(element) 
}

Explicação:

forEach está na classe de protótipo. Você também pode chamar isso como theArray.prototype.forEach (...);

protótipo: https://hackernoon.com/prototypes-in-javascript-5bba2990e04b

Você também pode alterar em um array como este:

1    
3    
2

Eu sei que este é um post antigo, e há muitas ótimas respostas já. Para um pouco mais de completude, imaginei que lançaria outro usando o AngularJS . Claro, isso só se aplica se você estiver usando Angular, obviamente, no entanto, eu gostaria de colocá-lo de qualquer maneira.

angular.forEachleva 2 argumentos e um terceiro argumento opcional. O primeiro argumento é o objeto (array) para iterar, o segundo argumento é a função iteradora, e o terceiro argumento opcional é o contexto do objeto (basicamente referido dentro do loop como 'this').

Existem diferentes maneiras de usar o loop forEach de angular. O mais simples e provavelmente o mais usado é

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

Outra maneira útil para copiar itens de um array para outro é

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);

Porém, você não precisa fazer isso, basta fazer o seguinte e é equivalente ao exemplo anterior:

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

Agora existem prós e contras de usar a angular.forEachfunção em oposição ao forloop com sabor baunilha .

Prós

  • Fácil legibilidade
  • Facilidade de escritura
  • Se disponível, angular.forEachusará o loop ES5 forEach. Agora, vou chegar à eficiência na seção cons, já que os loops forEach são muito mais lentos que os loops for. Eu menciono isso como um profissional porque é bom ser consistente e padronizado.

Considere os dois loops aninhados a seguir, que fazem exatamente a mesma coisa. Digamos que tenhamos duas matrizes de objetos e cada objeto contenha uma matriz de resultados, cada qual com uma propriedade Value que é uma string (ou qualquer outra). E digamos que precisamos fazer uma iteração sobre cada um dos resultados e, se forem iguais, executar alguma ação:

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
        }
    }
}

Concedido este é um exemplo hipotético muito simples, mas eu escrevi loops embutidos triplos usando a segunda abordagem e foi muito difícil de ler e escrever para esse assunto.

Contras

  • Eficiência. angular.forEache os nativos forEach, por sinal, são muito mais lentos que o forloop normal ... cerca de 90% mais lento . Portanto, para grandes conjuntos de dados, é melhor manter o forloop nativo .
  • Sem intervalo, continuar ou retornar o suporte. continueNa verdade, é suportado por " accident ", para continuar em um angular.forEachsimples você colocar uma return;declaração na função como o angular.forEach(array, function(item) { if (someConditionIsTrue) return; });que fará com que ele continue fora da função para essa iteração. Isso também se deve ao fato de o nativo forEachnão suportar quebra ou continuar.

Tenho certeza de que há vários outros prós e contras, e sinta-se à vontade para adicionar qualquer um que achar melhor. Eu sinto que, em última análise, se você precisa de eficiência, fique com apenas o forloop nativo para suas necessidades de looping. Mas, se os seus conjuntos de dados são menores e uma certa eficiência é aceitável para desistir em troca de legibilidade e capacidade de escrita, então, de qualquer maneira, jogue um angular.forEachno bad boy.


Existem três implementações de foreachno jQuery seguinte maneira.

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

Não há capacidade inata para entrar forEach. Para interromper a execução use o Array#somemesmo abaixo:

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

Isso funciona porque someretorna true assim que qualquer um dos retornos de chamada, executados em ordem de matriz, retorna true, causando um curto-circuito na execução do resto. Resposta original veja protótipo de matriz para some


Provavelmente o for(i = 0; i < array.length; i++)loop não é a melhor escolha. Por quê? Se você tem isso:

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

O método irá chamar de array[0]para array[2]. Primeiro, isso fará referência a variáveis ​​que você nem possui, segundo você não teria as variáveis ​​na matriz e, em terceiro lugar, tornará o código mais ousado. Olha aqui, é o que eu uso:

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

E se você quiser que seja uma função, você pode fazer isso:

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

Se você quer quebrar, um pouco mais de lógica:

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

Exemplo:

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

Ele retorna:

//Hello
//World
//!!!

Se você quiser usar forEach(), será parecido com -

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

Se você quiser usar for(), será parecido com -

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


Um caminho mais próximo de sua idéia seria usar o Array.forEach()que aceita uma função de cloro que será executada para cada elemento da matriz.

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

Outra via viável seria usar o Array.map()que funciona da mesma forma, mas também mutatescada elemento e retorna como:

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

console.log(myArray); // [2, 3, 4]

Uma solução fácil agora seria usar a biblioteca underscore.js . Ele está fornecendo muitas ferramentas úteis, como eache delegará automaticamente o trabalho para o nativo, forEachse disponível.

Um exemplo de CodePen de como funciona é:

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

Veja também

  • Array::forEach .
  • Em for_each...in (MDN), é explicado que for each (variable in object)está obsoleto como parte do padrão ECMA-357 ( EAX ).
  • for...of (MDN) descreve a próxima maneira de iterar usando for (variable of object)como parte da proposta do Harmony (ECMAScript 6).

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






iteration