需要帮助优化合并对象和数组的循环

Question

这是我正在尝试做的一个工作示例：

  private mergeData(dataArray) {
    const mergedData = {
      items: [],
      money: {
        money1: 0,
        money2: 0,
        money3: 0,
      }
    }
    for (const data of dataArray) {
      mergedData.money.money1 += data.money.money1
      mergedData.money.money2 += data.money.money2
      mergedData.money.money3 += data.money.money3
      mergedData.items = [...mergedData.items, ...data.items]
    }

    return mergedData
  }

我正在寻求优化它，因为它感觉有点臭。

我的项目中有 Lodash 可用，如果可能的话最好使用它。

我想添加更多细节，因为我似乎发布得太仓促了

dataArray 看起来像这些对象的数组

{
      items: [],
      money: {
        money1: 0,
        money2: 0,
        money3: 0,
      }
    }

items 只是一个带有字符串键：值对的对象

我希望使其更加简洁，并可能优化项目合并的性能

谢谢。

Answer 1

您可以使用

reduce

private mergeData(dataArray) {
  const mergedData = {
    items: [],
    money: {
      money1: 0,
      money2: 0,
      money3: 0,
    }
  }

  return dataArray.reduce((acc, curr) => {
    acc.items.push(...curr.items)
    acc.money.money1 += curr.money.money1
    acc.money.money2 += curr.money.money2
    acc.money.money3 += curr.money.money3
    return acc;

  }, mergedData)

}

Answer 2

您可以使用 lodash 的 _.mergeWith() 函数来优化对象数组的合并，以合并“money”属性，并使用 _.concat() 来合并“items”数组。以下是如何做到这一点的示例：

const _ = require('lodash');

function mergeData(dataArray) {
  const mergedData = {
    items: [],
    money: {
      money1: 0,
      money2: 0,
      money3: 0,
    },
  };

  for (const data of dataArray) {
    // Merge "money" properties
    _.mergeWith(mergedData.money, data.money, (objValue, srcValue) => objValue + srcValue);

    // Concatenate "items" arrays
    mergedData.items = _.concat(mergedData.items, data.items);
  }

  return mergedData;
}

// Example dataArray
const dataArray = [
  {
    items: [{ key1: 'value1' }],
    money: {
      money1: 10,
      money2: 20,
      money3: 30,
    },
  },
  {
    items: [{ key2: 'value2' }],
    money: {
      money1: 5,
      money2: 15,
      money3: 25,
    },
  },
];

const mergedData = mergeData(dataArray);
console.log(mergedData);

Answer 3

我将使用以下两点来简化代码。

1. 重用

   items

   数组，而不是每次迭代创建一个新数组。这可以通过将

   data.items

   推入现有数组来完成。

   items.push(...data.items);
   

2. 在开始循环之前将金钱键收集到单独的数组中

   dataArray

   。

     const moneyKeys = Object.keys(money)
   

   然后将列出的键的值添加到

   data.money

   中每个

   dataArray

   的总数中。

   moneyKeys.forEach(key => money[key] += data.money[key])
   

function mergeData(dataArray) {
  const items = [];
  const money = { money1: 0, money2: 0, money3: 0 };
  const moneyKeys = Object.keys(money);
  
  for (const data of dataArray) {
    items.push(...data.items);
    moneyKeys.forEach(key => money[key] += data.money[key]);
  }
  
  return { items, money };
}

console.log(mergeData([
  {
    items: ['a', 'b', 'c'],
    money: { money1: 2, money2: 4, money3: 8 },
  }, {
    items: ['x', 'y', 'z'],
    money: { money1: 1, money2: 2, money3: 3 },
  }
]));

如果您确实需要额外的速度，可以将

for...of

循环替换为更快的循环。

ps。如果可能的话，我个人会用一个简单的数组

{ money1: 0, money2: 0, money3: 0 }

替换

[0, 0, 0]

。一旦开始对属性进行编号，您可能想使用数组来代替。仅当您可以控制输入结构的构建过程时，这才有效。