Javascript 映射对象键值的替代方法

不使用

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

有没有更好/更干净的方法来实现这一点？

对于of循环，我会在

中查看（从ES2017开始新增，但可多填充）和分解结构

如果没有其他东西可以访问
源
上的数组（我倾向于假设，因为
排序
在适当的位置工作，所以代码已经修改了原始数组；但同时，
源
从外部进入，所以…：

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

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

与

如果您愿意，但这将使用迭代器，它比
切片
开销更大。您还可以使用map循环对象条目，并使用splice切断数组长度：

const getSortedObj = (source) => {
    let obj = Object.assign({}, source);
    Object.entries(obj).map( entry => {
        let [key, arr] = entry;
        arr.sort((a, b) => b.priority - a.priority).splice(Math.min(arr.length, 5));
        return entry;
    });
    return obj;
};

你能给出一个实际输入的例子，而不是占位符空的对象，这样我们就有了一个可玩的工具吗？@CertainPerformance sure！请稍等，您也可以使用，请注意，
sort
可以正常工作，因此不需要
object[key]=object[key].sort（…）
。当你发现自己一遍又一遍地重复类似于
object[key]
的东西时，它表明你可能想把它放在一个变量中并重用它。这是对
map
的滥用<代码>映射

生成并返回一个数组。如果您没有使用

map

的返回值（它构建的数组），并且不想将

用于of

，请使用

forEach

。我不同意。为什么这是地图的错误？问题是，在不使用forEach的情况下映射对象键值的替代/最佳方法是什么？我在上面的评论中提到了原因：您没有使用它创建的数组，因此让它创建该数组是毫无意义的。见MDN:。请注意，

map

示例中没有一个无法使用它返回的数组。你在用螺丝刀钉钉子。用锤子代替。

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

const getSortedObj = (source) => {
    let obj = Object.assign({}, source);
    Object.entries(obj).map( entry => {
        let [key, arr] = entry;
        arr.sort((a, b) => b.priority - a.priority).splice(Math.min(arr.length, 5));
        return entry;
    });
    return obj;
};