javascript - 映射对象键值的替代方法

Question

在不使用 forEach 的情况下通过对象键值映射的替代/最佳方法是什么？

这是我目前拥有的:

sortObject(source) {
    const object = Object.assign({}, source);

    Object.keys(object).forEach(key => {
      // Sort array by priority (the higher the number, the higher the priority)
      object[key] = object[key].sort((a, b) => b.priority - a.priority);

      // Limit the array length to the 5
      if (object[key].length > 5) {
        object[key] = object[key].slice(0, 5);
      }
    });

    return object;
}

source 是一个像这样的对象:

{
  base: [
    { id: 1, priority: 5 },
    { id: 2, priority: 10 },
    { id: 3, priority: 1 },
    { id: 4, priority: 5 },
    { id: 5, priority: 15 }
  ],
  extra: [
    { id: 1, priority: 1 },
    { id: 2, priority: 5 },
    { id: 3, priority: 10 }
  ],
  additional: [
    { id: 1, priority: 5 },
    { id: 2, priority: 10 },
    { id: 3, priority: 10 },
    { id: 4, priority: 15 },
    { id: 5, priority: 1 },
    { id: 6, priority: 29 },
    { id: 7, priority: 100 },
    { id: 8, priority: 100 },
    { id: 9, priority: 5 }
  ]
}

最终输出如下:

{
  base: [
    { id: 5, priority: 15 },
    { id: 2, priority: 10 },
    { id: 1, priority: 5 },
    { id: 4, priority: 5 },
    { id: 3, priority: 1 }
  ],
  extra: [
    { id: 3, priority: 10 },
    { id: 2, priority: 5 },
    { id: 1, priority: 1 }
  ],
  additional: [
    { id: 7, priority: 100 },
    { id: 8, priority: 100 },
    { id: 6, priority: 29 },
    { id: 4, priority: 15 },
    { id: 2, priority: 10 }
  ]
}

是否有更好/更清洁的方法来做到这一点？

Answer 1

我会看看 Object.entries (自 ES2017 起新增，但可填充)并在 for-of 循环中解构。

如果没有其他任何东西可以访问 source 上的数组(我倾向于假设，因为 sort 就地工作，所以code 已经修改了原始数组；但与此同时，source 是从外部传入的，所以...):

sortObject(source) {
    const object = Object.assign({}, source);

    for (const [key, array] of Object.entries(object)) {
        array.sort((a, b) => b.priority - a.priority);
        array.length = Math.min(array.length, 5);
    }

    return object;
}

如果其他东西可以访问这些数组并且除了对它们进行排序之外你不应该修改它们，那么你将需要你的原始 length 检查和 slice:

sortObject(source) {
    const object = Object.assign({}, source);

    for (const [key, array] of Object.entries(object)) {
        array.sort((a, b) => b.priority - a.priority);
        if (array.length > 5) {
            object[key] = array.slice(0, 5);
        }
    }

    return object;
}

您的代码表明您可能没有意识到 sort 就地工作，因为您将结果分配回原始位置。如果是这样，并且您不打算就地对数组进行排序，则需要在排序之前复制数组:

sortObject(source) {
    const object = Object.assign({}, source);

    for (const [key, array] of Object.entries(object)) {
        object[key] = array = array.slice();
        array.sort((a, b) => b.priority - a.priority);
        array.length = Math.min(array.length, 5);
    }

    return object;
}

你可以替换

        object[key] = array = array.slice();
        array.sort((a, b) => b.priority - a.priority);

与

        object[key] = array = Array.from(array).sort((a, b) => b.priority - a.priority);

如果您愿意，那将使用一个迭代器，它比 slice 开销更大。