Javascript NodeJS：创建api，该api将根据键值以动态方式生成for循环

我有一个MySQL表，如下所示：

id   product_id  option_type
-------------------------------
14       6           2
15       6           1
16       6           1
17       6           2
18       6           2

在上面的sql表上，借助于

Sequelize ORM

应用sql查询，呈现下面的对象数组，并在

option_type

键上，我需要基于

option_type

值生成集合组合：

var records = [
{ id: 14, value: "M", product_id: 6, option_type: 2 },
{ id: 15, value: "White", product_id: 6, option_type: 1 },
{ id: 16, value: "Black", product_id: 6, option_type: 1 },
{ id: 17, value: "S", product_id: 6, option_type: 2 },
{ id: 18, value: "L", product_id: 6, option_type: 2 }]

我使用

Array.prototype.filter（）

方法创建了这些组合

const option_type_1 = records.filter((el) => { return el.option_type == 1 });
const option_type_2 = records.filter((el) => { return el.option_type == 2 });


for(const opt1 of option_type_1) {
  for(const opt2 of option_type_2) {
    const options = {
      "opt_one_id": opt1.id,
      "opt_two_id": opt2.id,
    };
    optionList.push(options)
  }
}

并得到如下响应

{
  "data": [
  { "opt_one_id": 15, "opt_one_value": White, "opt_two_id": 14, "opt_two_value": M },
  { "opt_one_id": 15, "opt_one_value": White, "opt_two_id": 17,"opt_two_value": S },
  ...and so on
]}

现在，当添加更多选项时，我如何动态地管理它

现在我们正在考虑选项_type=1和选项_type=2，但将来如果再添加一个选项，那么选项_type=3也将出现在集合中

因此，在这种情况下，如何使用密钥名管理此集合，以便在那时它将变成如下所示

{ "opt_one_id": 15, "opt_two_id": 14, "opt_three_id": 17 },

因此，添加或删除任何

选项\u type

，都将对其进行相应的管理

提前感谢

==已更新===

考虑此选项类型的基表

id   option_type
-----------------
1     Colour
2     Size

因此，相应地，它将生成如下组合

15 (White) * 14 (M)
15 (White) * 17 (S)
15 (White) * 18 (L)
16 (Black) * 14 (M)
16 (Black) * 17 (S)
16 (Black) * 18 (L)

---

您可以使用

选项\u type

使用下划线对结果进行分组，如下所示

const options = _.groupBy(records, record => record.option_type);

console.log(options);

分组后，您将得到以下结构（考虑我们现在有第三种选项类型）

之后，您可以组合使用for..in和for循环，以获得所需的结果，如下所示

const keys = Object.keys(options);
const rootItem = options[keys[0]];
delete options[keys[0]];
const finalResults = [];

for(let i =0; i< rootItem.length; i++) {
    for (option in options) {
        for (let j = 0; j<options[option].length; j++) {
            let item = {};
            item[`option_type_${rootItem[i].option_type}`] = rootItem[i].id;
            item[`option_type_${options[option][j].option_type}`] = options[option][j].id;
            finalResults.push(item);
        }
    }
} 

console.log(finalResults)  

[ { option_type_1: 15, option_type_2: 14 },
  { option_type_1: 15, option_type_2: 17 },
  { option_type_1: 15, option_type_2: 18 },
  { option_type_1: 15, option_type_3: 19 },
  { option_type_1: 16, option_type_2: 14 },
  { option_type_1: 16, option_type_2: 17 },
  { option_type_1: 16, option_type_2: 18 },
  { option_type_1: 16, option_type_3: 19 } ] 

const keys=Object.keys（选项）；
const rootItem=选项[键[0]]；
删除选项[键[0]]；
常量最终结果=[]；
for（设i=0；i对于（让j=0；j您可以使用
选项\u type
使用下划线对结果进行分组，如下所示

const options = _.groupBy(records, record => record.option_type);

console.log(options);

分组后，您将得到以下结构（考虑我们现在有第三种选项类型）

之后，您可以组合使用for..in和for循环，以获得所需的结果，如下所示

const keys = Object.keys(options);
const rootItem = options[keys[0]];
delete options[keys[0]];
const finalResults = [];

for(let i =0; i< rootItem.length; i++) {
    for (option in options) {
        for (let j = 0; j<options[option].length; j++) {
            let item = {};
            item[`option_type_${rootItem[i].option_type}`] = rootItem[i].id;
            item[`option_type_${options[option][j].option_type}`] = options[option][j].id;
            finalResults.push(item);
        }
    }
} 

console.log(finalResults)  

[ { option_type_1: 15, option_type_2: 14 },
  { option_type_1: 15, option_type_2: 17 },
  { option_type_1: 15, option_type_2: 18 },
  { option_type_1: 15, option_type_3: 19 },
  { option_type_1: 16, option_type_2: 14 },
  { option_type_1: 16, option_type_2: 17 },
  { option_type_1: 16, option_type_2: 18 },
  { option_type_1: 16, option_type_3: 19 } ] 

const keys=Object.keys（选项）；
const rootItem=选项[键[0]]；
删除选项[键[0]]；
常量最终结果=[]；
for（设i=0；i对于（让j=0；jIn）响应
数据
opt_[option_n]\u id的相关值是多少？
“opt_one\u id”：15
是在查询
中呈现的值，其中option_type==1
与
“opt_two\u id”相同：14
其中option_type==2
对于每个id_一附加所有id_二？代码就是这样做的。我对吗？对于每个id_一附加所有id_二？对不起，伙计，我没法回答你的问题。optionList结果是
[{“opt_一/id”：15，“opt_二/id”：14}，{“opt u一/id”：15，“opt u二/id”：17}，{“opt u一/id”：15，“opt u二/id”：18}，{：16，“opt_two_id”：14}，{“opt_one_id”：16，“opt_two_id”：17}，{“opt_one_id”：16，“opt_two_id”：18}
。因此，对于每个_one id，添加所有两个_id。请参见响应
数据中的结果
opt_[option_n]\u id:？
“opt one_id”的相关值是什么：15
是查询中呈现的值，其中option\u type==1
与
“opt\u two\u id”的呈现方式相同：14
其中option\u type==2
对于每个id\u one附加所有id\u two？代码就是这样做的。我说得对吗？对于每个id\u one附加所有id\u two？对不起，伙计，无法得到你的问题。optionList结果是
[{“option\u one\u id”：15，“opt_two_id”：14}，{“opt_one_id”：15，“opt_two_id”：17}，{“opt_one_id”：15，“opt_two_id”：18}，{“opt_one_id”：16，“opt_two_id”：14}，{“opt one_id”：16，“opt two_id”：17}，{“opt one_one_id”：16，“opt two_id”：18}]
。因此，对于每一个id，请添加所有两个id。查看结果。这听起来像是我在寻找的……让我尝试一下，并将更新您。这听起来像是我在寻找的……让我尝试一下，并将更新您。