Javascript ES6 / ES5 buscar en matriz y cambiar

Tengo una gran variedad de objetos. Quiero buscar por algún campo, y luego cambiarlo:

var item = {...}
var items = [{id:2}, {id:2}, {id:2}];

var foundItem = items.find(x => x.id == item.id);
foundItem = item;

Quiero que cambie el objeto original. ¿Cómo? (No me importa si también estará en lodash)

Puede usar findIndex para buscar el índice en la matriz del objeto y reemplazarlo según sea necesario:

var item = {...}
var items = [{id:2}, {id:2}, {id:2}];

var foundIndex = items.findIndex(x => x.id == item.id);
items[foundIndex] = item;

Esto supone identificaciones únicas. Si sus ID están duplicadas (como en su ejemplo), probablemente sea mejor si usa forEach:

items.forEach((element, index) => {
    if(element.id === item.id) {
        items[index] = item;
    }
});

Mi mejor enfoque es:

var item = {...}
var items = [{id:2}, {id:2}, {id:2}];

items[items.findIndex(el => el.id === item.id)] = item;

Referencia para findIndex

Y en caso de que no desee reemplazar con un nuevo objeto, sino que copie los campos item, puede usar Object.assign:

Object.assign(items[items.findIndex(el => el.id === item.id)], item)

como alternativa con .map() :

Object.assign(items, items.map(el => el.id === item.id? item : el))

Enfoque funcional :

No modifique la matriz, use una nueva, para no generar efectos secundarios.

const updatedItems = items.map(el => el.id === item.id ? item : el)

Otro enfoque es usar el empalme .

El splice()método cambia el contenido de una matriz eliminando o reemplazando elementos existentes y / o agregando nuevos elementos en su lugar .

NB: en caso de que esté trabajando con marcos reactivos, actualizará la "vista", su matriz "sabrá" que la ha actualizado.

Responder :

var item = {...}
var items = [{id:2}, {id:2}, {id:2}];

let foundIndex = items.findIndex(element => element.id === item.id)
items.splice(foundIndex, 1, item)

Y en caso de que solo desee cambiar el valor de un elemento, puede usar la función de búsqueda :

// Retrieve item and assign ref to updatedItem
let updatedItem = items.find((element) => { return element.id === item.id })

// Modify object property
updatedItem.aProp = ds.aProp

Dado un objeto cambiado y una matriz:

const item = {...}
let items = [{id:2}, {id:3}, {id:4}];

Actualice la matriz con el nuevo objeto iterando sobre la matriz:

items = items.map(x => (x.id === item.id) ? item : x)

Se puede utilizar filtro .

const list = [{id:0}, {id:1}, {id:2}];
let listCopy = [...list];
let filteredDataSource = listCopy.filter((item) => {
       if (item.id === 1) {
           item.id = 12345;
        }

        return item;
    });
console.log(filteredDataSource);

Matriz [Object {id: 0}, Object {id: 12345}, Object {id: 2}]

trabajó para mi

let returnPayments = [ ...this.payments ];

returnPayments[this.payments.findIndex(x => x.id == this.payment.id)] = this.payment;

Mientras que la mayoría de las respuestas existentes son geniales, me gustaría incluir una respuesta usando un bucle for tradicional, que también debería considerarse aquí. El OP solicita una respuesta que es compatible con ES5 / ES6, y se aplica el bucle for tradicional :)

El problema con el uso de funciones de matriz en este escenario es que no mutan objetos, pero en este caso, la mutación es un requisito. La ganancia de rendimiento del uso de un bucle for tradicional es solo una bonificación (enorme).

const findThis = 2;
const items = [{id:1, ...}, {id:2, ...}, {id:3, ...}];

for (let i = 0, l = items.length; i < l; ++i) {
  if (items[i].id === findThis) {
    items[i].iAmChanged = true;
    break;
  }
}

Aunque soy un gran admirador de las funciones de matriz, no permita que sean la única herramienta en su caja de herramientas. Si el propósito es mutar la matriz, no son la mejor opción.

One-liner con operador de propagación.

 const updatedData = originalData.map(x => (x.id === id ? { ...x, updatedField: 1 } : x));