é possível alterar os valores da matriz ao fazer foreach em javascript?

exemplo:

var arr = ["one","two","three"];

arr.forEach(function(part){
  part = "four";
  return "four";
})

alert(arr);

A matriz ainda está com seus valores originais; existe alguma maneira de ter acesso de gravação aos elementos da matriz a partir da função de iteração?

O retorno de chamada é passado para o elemento, o índice e a própria matriz.

arr.forEach(function(part, index, theArray) {
  theArray[index] = "hello world";
});

editar - conforme observado em um comentário, a .forEach()função pode usar um segundo argumento, que será usado como o valor de thisem cada chamada para o retorno de chamada:

arr.forEach(function(part, index) {
  this[index] = "hello world";
}, arr); // use arr as this

Esse segundo exemplo mostra arr-se configurado como thisno retorno de chamada. Alguém pode pensar que a matriz envolvida na .forEach()chamada possa ser o valor padrão de this, mas por qualquer motivo, não; thisserá undefinedse esse segundo argumento não for fornecido.

(Nota: o material acima thisnão se aplica se o retorno de chamada for uma =>função, porque thisnunca estará vinculado a nada quando essas funções forem chamadas.)

Também é importante lembrar que existe toda uma família de utilitários semelhantes no protótipo Array, e muitas perguntas surgem no Stackoverflow sobre uma função ou outra, de modo que a melhor solução é simplesmente escolher uma ferramenta diferente. Você tem:

• forEach por fazer algo com ou para cada entrada em uma matriz;
• filter por produzir uma nova matriz contendo apenas entradas qualificadas;
• map para criar uma nova matriz individual transformando uma matriz existente;
• some verificar se pelo menos um elemento em uma matriz se encaixa em alguma descrição;
• everyverificar se todas as entradas em uma matriz correspondem a uma descrição;
• find procurar um valor em uma matriz

e assim por diante. Link MDN

Vamos tentar simplificar e discutir como está realmente funcionando. Tem a ver com tipos de variáveis ​​e parâmetros de função.

Aqui está o seu código que estamos falando:

var arr = ["one","two","three"];

arr.forEach(function(part) {
  part = "four";
  return "four";
})

alert(arr);

Primeiro, aqui é onde você deve ler sobre Array.prototype.forEach ():

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach

Segundo, vamos falar brevemente sobre os tipos de valor em JavaScript.

Primitivas (indefinidas, nulas, String, Boolean, Number) armazenam um valor real.

ex: var x = 5;

Os tipos de referência (objetos personalizados) armazenam a localização da memória do objeto.

ex: var xObj = { x : 5 };

E terceiro, como os parâmetros de função funcionam.

Nas funções, os parâmetros são sempre passados ​​por valor.

Como arré uma matriz de Strings, é uma matriz de objetos primitivos , o que significa que eles são armazenados por valor.

Portanto, para o seu código acima, isso significa que toda vez que o forEach () itera, parté igual ao mesmo valor que arr[index], mas não o mesmo objeto .

part = "four";mudará a partvariável, mas deixará em arrpaz.

O código a seguir alterará os valores que você deseja:

var arr = ["one","two","three"];

arr.forEach(function(part, index) {
  arr[index] = "four";
});

alert(arr);

Agora, se a matriz arrfor uma matriz de tipos de referência , o código a seguir funcionará porque os tipos de referência armazenam um local de memória de um objeto em vez do objeto real.

var arr = [{ num : "one" }, { num : "two"}, { num : "three"}];

arr.forEach(function(part, index) {
  // part and arr[index] point to the same object
  // so changing the object that part points to changes the object that arr[index] points to

  part.num = "four";
});

alert(arr[0].num);
alert(arr[1].num);
alert(arr[2].num);

A seguir, ilustra que você pode alterar partpara apontar para um novo objeto enquanto deixa os objetos armazenados arrsozinhos:

var arr = [{ num : "one" }, { num : "two"}, { num : "three"}];

arr.forEach(function(part, index) {
  // the following will not change the object that arr[index] points to because part now points at a new object
  part = 5;
});

alert(arr[0].num);
alert(arr[1].num);
alert(arr[2].num);

Matriz: [1, 2, 3, 4]
Resultado:["foo1", "foo2", "foo3", "foo4"]

Array.prototype.map() Manter matriz original

const originalArr = ["Iron", "Super", "Ant", "Aqua"];
const modifiedArr = originalArr.map(name => `${name}man`);

console.log( "Original: %s", originalArr );
console.log( "Modified: %s", modifiedArr );

Array.prototype.forEach() Substituir matriz original

const originalArr = ["Iron", "Super", "Ant", "Aqua"];
originalArr.forEach((name, index) => originalArr[index] = `${name}man`);

console.log( "Overridden: %s", originalArr );

Javascript é transmitido por valor, e o que essencialmente significa parté uma cópia do valor na matriz.

Para alterar o valor, acesse a própria matriz no seu loop.

arr[index] = 'new value';

substitua-o pelo índice da matriz.

array[index] = new_value;

Aqui está uma resposta semelhante usando uma =>função de estilo:

var data = [1,2,3,4];
data.forEach( (item, i, self) => self[i] = item + 10 );

dá o resultado:

[11,12,13,14]

O selfparâmetro não é estritamente necessário com a função de estilo de seta, portanto

data.forEach( (item,i) => data[i] = item + 10);

também funciona.

A função .forEach pode ter uma função de retorno de chamada (eachelement, elementIndex). Então, basicamente, o que você precisa fazer é:

arr.forEach(function(element,index){
    arr[index] = "four";   //set the value  
});
console.log(arr); //the array has been overwritten.

Ou, se você quiser manter a matriz original, poderá fazer uma cópia antes de executar o processo acima. Para fazer uma cópia, você pode usar:

var copy = arr.slice();

Com os métodos de objeto Array, você pode modificar o conteúdo da matriz e, em comparação com o básico para loops, esses métodos não possuem uma funcionalidade importante. Você não pode modificar o índice em execução.

Por exemplo, se você remover o elemento atual e colocá-lo em outra posição de índice na mesma matriz, poderá fazê-lo facilmente. Se você mover o elemento atual para uma posição anterior, não haverá problema na próxima iteração, o próximo item será o mesmo, como se você não tivesse feito nada.

Considere esse código em que movemos o item na posição 5 do índice para a posição 2 quando o índice conta até 5.

var ar = [0,1,2,3,4,5,6,7,8,9];
ar.forEach((e,i,a) => {
i == 5 && a.splice(2,0,a.splice(i,1)[0])
console.log(i,e);
}); // 0 0 - 1 1 - 2 2 - 3 3 - 4 4 - 5 5 - 6 6 - 7 7 - 8 8 - 9 9

No entanto, se movermos o elemento atual para algum lugar além da posição atual do índice, as coisas ficam um pouco confusas. Em seguida, o item seguinte mudará para a posição de itens movidos e, na próxima iteração, não poderemos vê-lo ou avaliá-lo.

Considere este código em que movemos o item na posição 5 do índice para a posição 7, depois que o índice conta até 5.

var a = [0,1,2,3,4,5,6,7,8,9];
a.forEach((e,i,a) => {
i == 5 && a.splice(7,0,a.splice(i,1)[0])
console.log(i,e);
}); // 0 0 - 1 1 - 2 2 - 3 3 - 4 4 - 5 5 - 6 7 - 7 5 - 8 8 - 9 9

Portanto, nunca encontramos 6 no circuito. Normalmente, em um loop for, é esperado que você diminua o valor do índice ao mover o item da matriz para frente, para que o índice permaneça na mesma posição na próxima execução e você ainda possa avaliar o item deslocado para o lugar do item removido. Isso não é possível com métodos de matriz. Você não pode alterar o índice. Verifique o seguinte código

var a = [0,1,2,3,4,5,6,7,8,9];
a.forEach((e,i,a) => {
i == 5 && (a.splice(7,0,a.splice(i,1)[0]), i--);
console.log(i,e);
}); // 0 0 - 1 1 - 2 2 - 3 3 - 4 4 - 4 5 - 6 7 - 7 5 - 8 8 - 9 9

Como você vê quando diminuímos, iele não continuará de 5, mas 6, de onde foi deixado.

Portanto, mantenha isso em mente.

Para adicionar ou excluir completamente elementos que alterariam o índice, por meio da extensão da sugestão zhujy_8833 de slice () para iterar sobre uma cópia, basta contar o número de elementos que você já excluiu ou adicionou e alterou o índice de acordo. Por exemplo, para excluir elementos:

let values = ["A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8"];
let count = 0;
values.slice().forEach((value, index) => {
    if (value === "A2" || value === "A5") {
        values.splice(index - count++, 1);
    };
});
console.log(values);

// Expected: [ 'A0', 'A1', 'A3', 'A4', 'A6', 'A7', 'A8' ]

Para inserir elementos antes:

if (value === "A0" || value === "A6" || value === "A8") {
    values.splice(index - count--, 0, 'newVal');
};

// Expected: ['newVal', A0, 'A1', 'A2', 'A3', 'A4', 'A5', 'newVal', 'A6', 'A7', 'newVal', 'A8' ]

Para inserir elementos após:

if (value === "A0" || value === "A6" || value === "A8") {
    values.splice(index - --count, 0, 'newVal');
};

// Expected: ['A0', 'newVal', 'A1', 'A2', 'A3', 'A4', 'A5', 'A6', 'newVal', 'A7', 'A8', 'newVal']

Para substituir um elemento:

if (value === "A3" || value === "A4" || value === "A7") {
    values.splice(index, 1, 'newVal');
};

// Expected: [ 'A0', 'A1', 'A2', 'newVal', 'newVal', 'A5', 'A6', 'newVal', 'A8' ]

Nota: se implementar inserções 'antes' e 'depois', o código deve manipular 'antes' as inserções primeiro, o contrário não seria o esperado

Você pode tentar isso se quiser substituir

var newArray= [444,555,666];
var oldArray =[11,22,33];
oldArray.forEach((name, index) => oldArray [index] = newArray[index]);
console.log(newArray);