Question

我需要从3个数组中创建一个单个数组，

我已经实现了逻辑并且可以正常工作，但是我认为使用Array.prototype可以达到相同的效果，并且性能更高

let classrooms = [
    1,
    2
]
let modules = [
    5,
    6
]

let weeks = [
   7,
   8
]

let avalArray = [];
classrooms.forEach(classroomId => {
        modules.forEach(moduleId => {
            weeks.forEach(week => {
                avalArray.push({
                    classroomId: classroomId,
                    moduleId: moduleId,
                    week: week
                });
            });
        });
    });

这是预期的输出：

[ { classroomId: 1, moduleId: 5, week: 7 },
  { classroomId: 1, moduleId: 5, week: 8 },
  { classroomId: 1, moduleId: 6, week: 7 },
  { classroomId: 1, moduleId: 6, week: 8 },
  { classroomId: 2, moduleId: 5, week: 7 },
  { classroomId: 2, moduleId: 5, week: 8 },
  { classroomId: 2, moduleId: 6, week: 7 },
  { classroomId: 2, moduleId: 6, week: 8 } ] ```

Answer 1

这是一种功能更强大的解决方案，它结合使用Array.flatMap()和Array.map()来生成对象数组。

但是，我认为您的性能应该更好，因为您不会生成时态数组，然后将其展平为其他时态数组，这些时态数组将展平为单个数组。

const classrooms = [1, 2]
const modules = [5, 6]
const weeks = [7, 8]

const result = classrooms.flatMap(classroomId =>
  modules.flatMap(moduleId =>
    weeks.map(week => ({
      classroomId,
      moduleId,
      week
    }))))
    
console.log(result)

Answer 2

您可以使用地图和平面。它会更紧凑，但是会很慢。使用for循环可获得更好的性能。

classrooms .map(classroomId => modules .map(moduleId => weeks.map(week => ({classroomId, moduleId, week}))) ).flat(2)

Answer 3

前一段时间有一个关于#852的笛卡尔乘积的请求（2015年1月！）。如您所见，它尚未实现。

正如其他人所说，在没有外部阵列的情况下执行简单循环肯定会更快。可以肯定的是：只需对其进行基准测试。我在perf.link上准备了一个简单的套件，结果如下：

for-loop:         175us
for-of-loop:      175us
forEach:          290us
map-map-map-flat: 465us
flatMap:          5635us

确切的数字在这里并不重要，但这是一个要点：for-of循环（不是转译！）是最快但仍然非常优雅的循环之一：

const result = [];
for (const classroomId of classrooms)
  for (const moduleId of modules)
    for (const week of weeks)
      result.push({classroomId, moduleId, week});

合并数组并将其相乘成一个数组

3 个答案: