Javascript ES6 / ES5在数组中查找并更改

我有一个对象数组。我想按某个字段查找，然后对其进行更改：

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

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

我希望它更改原始对象。怎么样？（我不在乎它是否也会在lodash中使用）

您可以使用findIndex在对象数组中查找索引，并根据需要替换它：

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

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

这假设唯一的ID。如果您的ID是重复的（如您的示例所示），则最好使用forEach：

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

我最好的方法是：

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

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

findIndex的参考

并且如果您不想替换为新对象，而是要复制的字段item，则可以使用Object.assign：

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

作为替代.map()：

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

功能方法：

不要修改数组，使用新数组，这样就不会产生副作用

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

另一种方法是使用拼接。

该splice()方法通过删除或替换现有元素和/或在适当位置添加新元素来更改数组的内容。

注意：如果您正在使用反应式框架，它将更新“视图”，数组“知道”您已更新它。

答：

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

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

如果只想更改项目的值，可以使用find函数：

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

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

给定一个更改的对象和一个数组：

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

通过遍历数组，使用新对象更新数组：

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

可以使用Filter。

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

数组[对象{id：0}，对象{id：12345}，对象{id：2}]

为我工作

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

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

尽管大多数现有答案都很不错，但我想提供一个使用传统for循环的答案，此处也应考虑。OP请求一个与ES5 / ES6兼容的答案，并且传统的for循环适用:)

在这种情况下使用数组函数的问题在于，它们不会使对象发生突变，但是在这种情况下，必须进行突变。使用传统的for循环所带来的性能提升仅仅是（巨大）奖励。

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

尽管我非常喜欢数组函数，但不要让它们成为工具箱中的唯一工具。如果目的是使阵列变异，则它们不是最合适的。

一线使用传播算子。

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