que utilidade tem o método javascript forEach (esse mapa não pode fazer)?

A única diferença que vejo em map e foreach é que mapestá retornando uma matriz e forEachnão está. Porém, eu nem entendo a última linha do forEachmétodo " func.call(scope, this[i], i, this);". Por exemplo, não é " this" e " scope" referindo-se ao mesmo objeto e não é this[i]e ireferindo-se ao valor atual no loop?

Notei em outro post que alguém disse "Use forEachquando quiser fazer algo com base em cada elemento da lista. Você pode adicionar coisas à página, por exemplo. Essencialmente, é ótimo para quando você deseja" efeitos colaterais ". Não sei o que significa efeitos colaterais.

Array.prototype.map = function(fnc) {
    var a = new Array(this.length);
    for (var i = 0; i < this.length; i++) {
        a[i] = fnc(this[i]);
    }
    return a;
}

Array.prototype.forEach = function(func, scope) { 
    scope = scope || this; 
    for (var i = 0, l = this.length; i < l; i++) {
        func.call(scope, this[i], i, this); 
    } 
}

Finalmente, existem outros usos reais para esses métodos em javascript (uma vez que não estamos atualizando um banco de dados) além de manipular números como este:

alert([1,2,3,4].map(function(x){ return x + 1})); //this is the only example I ever see of map in javascript.

Obrigado por qualquer resposta.

A diferença essencial entre mape forEachem seu exemplo é que forEachopera nos elementos da matriz original, enquanto mapretorna explicitamente uma nova matriz como resultado.

Com forEachvocê está realizando alguma ação com - e opcionalmente alterando - cada elemento na matriz original. O forEachmétodo executa a função fornecida para cada elemento, mas não retorna nada ( undefined). Por outro lado, mappercorre o array, aplica uma função a cada elemento e emite o resultado como um novo array .

O "efeito colateral" forEaché que a matriz original está sendo alterada. "Nenhum efeito colateral" mapsignifica que, no uso idiomático, os elementos originais do array não são alterados; a nova matriz é um mapeamento um para um de cada elemento na matriz original - a transformação de mapeamento sendo sua função fornecida.

O fato de não haver banco de dados envolvido não significa que você não terá que operar em estruturas de dados, o que, afinal, é uma das essências da programação em qualquer linguagem. Quanto à sua última pergunta, seu array pode conter não apenas números, mas objetos, strings, funções, etc.

A principal diferença entre os dois métodos é conceitual e estilística: você usa forEachquando quer fazer algo para ou com cada elemento de uma matriz (fazer "com" é o que a postagem que você cita quer dizer com "efeitos colaterais", eu acho) , enquanto você usa mapquando deseja copiar e transformar cada elemento de uma matriz (sem alterar o original).

Como mape forEachchamam uma função em cada item de uma matriz, e essa função é definida pelo usuário, não há quase nada que você possa fazer com um e não com o outro. É possível, embora feio, usá-lo mappara modificar uma matriz no local e / ou fazer algo com os elementos da matriz:

var a = [{ val: 1 }, { val: 2 }, { val: 3 }];
a.map(function(el) {
    el.val++; // modify element in-place
    alert(el.val); // do something with each element
});
// a now contains [{ val: 2 }, { val: 3 }, { val: 4 }]

mas muito mais limpo e mais óbvio quanto à sua intenção de uso forEach:

var a = [{ val: 1 }, { val: 2 }, { val: 3 }];
a.forEach(function(el) { 
    el.val++;
    alert(el.val);
});

Especialmente se, como geralmente é o caso no mundo real, el for uma variável legível útil:

cats.forEach(function(cat) { 
    cat.meow(); // nicer than cats[x].meow()
});

Da mesma forma, você pode usar facilmente forEach para fazer uma nova matriz:

var a = [1,2,3],
    b = [];
a.forEach(function(el) { 
    b.push(el+1); 
});
// b is now [2,3,4], a is unchanged

mas é mais limpo de usar map :

var a = [1,2,3],
    b = a.map(function(el) { 
        return el+1; 
    });

Observe também que, porque map formar uma nova matriz, ela provavelmente incorre em pelo menos algum impacto de desempenho / memória quando tudo o que você precisa é iteração, especialmente para matrizes grandes - consulte http://jsperf.com/map-foreach

Quanto ao motivo de você querer usar essas funções, elas são úteis sempre que você precisa fazer manipulação de array em javascript, o que (mesmo que estejamos falando apenas de javascript em um ambiente de navegador) é muito comum, quase a qualquer momento você está acessando um array que não está escrevendo manualmente em seu código. Você pode estar lidando com uma matriz de elementos DOM na página, ou dados extraídos de uma solicitação AJAX ou dados inseridos em um formulário pelo usuário. Um exemplo comum que encontro é a extração de dados de uma API externa, onde você pode querer usar mappara transformar os dados no formato que deseja e, em seguida, usar forEachpara iterar em seu novo array a fim de exibi-los para o usuário.

A resposta votada (de Ken Redler) é enganosa.

Um efeito colateral na ciência da computação significa que uma propriedade de uma função / método altera um estado global [wiki] . Em certo sentido, isso também pode incluir a leitura de um estado global, ao invés de argumentos. Na programação imperativa ou OO, os efeitos colaterais aparecem na maioria das vezes. E provavelmente você está fazendo uso dele sem perceber.

A diferença significativa entre forEache mapé que mapaloca memória e armazena o valor de retorno, enquanto o forEachjoga fora. Veja as especificações do emca para obter mais informações.

Já o motivo pelo qual as pessoas dizem que forEaché usado quando você quer um efeito colateral é que o valor de retorno de forEaché sempre undefined. Se não tiver efeito colateral (não muda o estado global), a função está apenas desperdiçando tempo de CPU. Um compilador otimizado irá eliminar este bloco de código e substituí-lo pelo valor final (undefined ).

A propósito, deve-se observar que o JavaScript não tem restrições aos efeitos colaterais. Você ainda pode modificar a matriz original dentro map.

var a = [1,2,3]; //original
var b = a.map( function(x,i){a[i] = 2*x; return x+1} );
console.log("modified=%j\nnew array=%j",a,b);
// output:
// modified=[2,4,6]
// new array=[2,3,4]

Esta é uma bela pergunta com uma resposta inesperada.

O seguinte é baseado na descrição oficial deArray.prototype.map() .

Não há nada que forEach()possa fazer que map()não possa. Ou seja, map()é um superconjunto estrito de forEach().

Embora map()seja normalmente usado para criar um novo array, também pode ser usado para alterar o array atual. O exemplo a seguir ilustra isso:

var a = [0, 1, 2, 3, 4], mapped = null;
mapped = a.map(function (x) { a[x] = x*x*x; return x*x; });
console.log(mapped); // logs [0, 1, 4, 9, 16]  As expected, these are squares.
console.log(a); // logs [0, 1, 8, 27, 64] These are cubes of the original array!!

No exemplo acima, afoi convenientemente definido de modo que a[i] === ipara i < a.length. Mesmo assim, ele demonstra o poder map()e, em particular, sua capacidade de alterar o array no qual é chamado.

Nota1:
A descrição oficial implica que map()pode até alterar o comprimento do array no qual é chamado! No entanto, não vejo (uma boa) razão para fazer isso.

Nota2:
Embora o map()mapa seja um superconjunto de forEach(), forEach()ainda deve ser usado onde se deseja a alteração de um determinado array. Isso deixa suas intenções claras.

Espero que tenha ajudado.

Você pode usar mapcomo se fosse forEach.

Mas fará mais do que o necessário.

scopepode ser um objeto arbitrário; não é necessariamente this.

Quanto a saber se existem usos reais para mape forEach, também perguntar se existem usos reais para forou whileloops.

Embora todas as perguntas anteriores estejam corretas, eu definitivamente faria uma distinção diferente. O uso de mape forEachpode implicar intenção.

Eu gosto de usar mapquando estou simplesmente transformando os dados existentes de alguma forma (mas quero ter certeza de que os dados originais não foram alterados.

Gosto de usar forEachquando estou modificando a coleção no local.

Por exemplo,

var b = [{ val: 1 }, { val: 2 }, { val: 3 }];
var c = b.map(function(el) {
    return { val: el.val + 1 }; // modify element in-place
});
console.log(b);
//  [{ val: 1 }, { val: 2 }, { val: 3 }]
console.log(c);
//  [{ val: 3 }, { val: 4 }, { val: 5 }]

Minha regra é certificar-se de que mapvocê está sempre criando algum novo objeto / valor para retornar para cada elemento da lista de fontes e retornando -o ao invés de apenas realizar alguma operação em cada elemento.

A menos que você tenha alguma necessidade real de modificar a lista existente, realmente não faz sentido modificá-la no local e se encaixa melhor em estilos de programação funcionais / imutáveis.

Resposta TL; DR -

map sempre retorna outro array.

forEach não. Cabe a você decidir o que ele faz. Retorne um array se quiser ou faça outra coisa se não quiser.

A flexibilidade é desejável em certas situações. Se não for para o que você está lidando, use o mapa.

Mais uma vez, sinto-me como um necromante adicionando uma resposta a uma pergunta que foi feita há 5 anos (felizmente, há atividades bem recentes, então não sou o único a perturbar os mortos :).

Outros já postaram sobre sua principal dúvida em relação à diferença entre as funções. Mas pelo...

há algum uso real para esses métodos em javascript (já que não estamos atualizando um banco de dados) além de manipular números como este:

... é engraçado você perguntar. Hoje mesmo escrevi um pedaço de código que atribui uma série de valores de uma expressão regular a várias variáveis ​​usando mapa para transformação. Foi usado para converter uma estrutura baseada em texto muito complicada em dados visualizáveis ​​... mas para simplificar, vou oferecer um exemplo usando strings de data, porque provavelmente são mais familiares para todos (embora, se meu problema fosse realmente com datas , em vez de mapa, eu teria usado objeto-data, que teria feito o trabalho esplendidamente por conta própria).

const DATE_REGEXP = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})Z$/;
const TEST_STRING = '2016-01-04T03:20:00.000Z';

var [
    iYear,
    iMonth,
    iDay,
    iHour,
    iMinute,
    iSecond,
    iMillisecond
    ] = DATE_REGEXP
        // We take our regular expression and...
        .exec(TEST_STRING)
        // ...execute it against our string (resulting in an array of matches)...
        .slice(1)
        // ...drop the 0th element from those (which is the "full string match")...
        .map(value => parseInt(value, 10));
        // ...and map the rest of the values to integers...

// ...which we now have as individual variables at our perusal
console.debug('RESULT =>', iYear, iMonth, iDay, iHour, iMinute, iSecond, iMillisecond);

Então ... embora isso fosse apenas um exemplo - e fizesse apenas uma transformação muito básica para os dados (apenas por exemplo) ... ter feito isso sem o mapa teria sido uma tarefa muito mais tediosa.

Concedido, ele é escrito em uma versão de JavaScript que não acho que muitos navegadores suportem ainda (pelo menos totalmente), mas - estamos chegando lá. Se eu precisasse rodar no navegador, acredito que transpilaria muito bem.