Javascript 将数组合并并乘法为一个数组

我需要从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 } ] ```

---

这是一个功能更强大的解决方案，它使用

Array.flatMap（）

和

Array.map（）

生成对象数组

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

const教室=[1,2]
常量模块=[5,6]
常数周=[7,8]
const result=classes.flatMap（classroomId=>
modules.flatMap（moduleId=>
weeks.map（week=>({
班级室友，
模块ID，
周
}))))
console.log（result）

这是一个功能更强大的解决方案，它使用

Array.flatMap（）

和

Array.map（）

生成对象数组

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

const教室=[1,2]
常量模块=[5,6]
常数周=[7,8]
const result=classes.flatMap（classroomId=>
modules.flatMap（moduleId=>
weeks.map（week=>({
班级室友，
模块ID，
周
}))))
console.log（结果）

您可以使用map和flat。它会更紧凑，但速度会很慢。对循环使用

，以获得更好的性能

教室
.map（classroomId=>modules
.map（moduleId=>weeks.map（week=>（{classroomId，moduleId，week}）））
).flat（2）
您可以使用map和flat。它会更紧凑，但速度会很慢。对

循环使用

，以获得更好的性能

教室
.map（classroomId=>modules
.map（moduleId=>weeks.map（week=>（{classroomId，moduleId，week}）））
).flat（2）
不久前（2015年1月！）有人请求使用笛卡尔产品。正如您所看到的，它没有实现

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

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

准确的数字在这里并不重要，但这里有一个要点：
for of
循环（不传输！）是最快且非常优雅的循环之一：

const result=[]；
for（教室的const classroomId）
for（模块的常数moduleId）
用于（连续几周）
push（{classroomId，moduleId，week}）；
不久前（2015年1月！）有人请求使用笛卡尔产品。正如您所看到的，它没有实现

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

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

准确的数字在这里并不重要，但这里有一个要点：
for of
循环（不传输！）是最快且非常优雅的循环之一：

const result=[]；
for（教室的const classroomId）
for（模块的常数moduleId）
用于（连续几周）
push（{classroomId，moduleId，week}）；
这可能有帮助：这可能有帮助：