Javascript 获取对象数组而不是对象数组

我有两个对象数组（this.so，model），我正试图操纵它们来创建一个新的对象数组（this.soModelBOMs）

我在两个数组上都使用了array.filter（）.map（）

但是，我得到的是一个对象数组，而不仅仅是一个对象数组

this.soModelBOMs = this.so.filter(x => x.lacking > 0).map(so => 
    model.filter(x => x.model_no == so.model_no).map(m => ({
        production_id: so.production_id,
        model_id: m.model_id,
        model_no: m.model_no,
        process_rev: m.process_rev,
        bom_rev: m.bom_rev,
        process: m.process.map(p => ({
            process_order: p.process_order,
            process_name: p.process_name,
            process_no: p.process_no,
            process_yield: p.process_yield,
            bom: p.bom.map(b => ({
                alt: b.alt,
                bom_item: b.bom_item,
                bom_name: b.bom_name,
                bom_code: b.bom_code,
                bom_qty: b.bom_qty,
                bom_stock: b.bom_stock,
                bom_yield: b.bom_yield,
                bom_req: b.bom_qty * so.lacking
            }))
        }))
    }))
)

我得到了这样的东西：

[
  [
    {
      "production_id": 1,
      "model_id": 1,
      ...
    }
  ],
    {
      "production_id": 2,
      "model_id": 2,
      ...
    }
  [
    {
      "production_id": 3,
      "model_id": 3,
      ...
    }
  ],
]

我如何修复我的代码，以便我可以将对象推入数组，而不是将对象数组推入数组

大概是这样的：

[
    {
      "production_id": 1,
      "model_id": 1,
      ...
    },
    {
      "production_id": 2,
      "model_id": 2,
      ...
    },
    {
      "production_id": 3,
      "model_id": 3,
      ...
    }
]

---

您可以使用

find

而不是

filter

this.soModelBOMs = this.so.filter(x => x.lacking > 0).map(so => {
var m = model.find(x => x.model_no == so.model_no);
if(m) {
    return {
        production_id: so.production_id,
        model_id: m.model_id,
        model_no: m.model_no,
        process_rev: m.process_rev,
        bom_rev: m.bom_rev,
        process: m.process.map(p => ({
            process_order: p.process_order,
            process_name: p.process_name,
            process_no: p.process_no,
            process_yield: p.process_yield,
            bom: p.bom.map(b => ({
                alt: b.alt,
                bom_item: b.bom_item,
                bom_name: b.bom_name,
                bom_code: b.bom_code,
                bom_qty: b.bom_qty,
                bom_stock: b.bom_stock,
                bom_yield: b.bom_yield,
                bom_req: b.bom_qty * so.lacking
            }))
        }))
    };
}
})

但是我没有测试这段代码

附言：

您可以使用

spread操作符

将代码重构为如下内容

this.soModelBOMs=this.so.filter（x=>x.com>0）.map（so=>{
var m=model.find（x=>x.model\u no==so.model\u no）；
如果（m）{
返回{
所以
M
进程：m.process.map（p=>
({
P
bom:p.bom.map（b=>
（{……b，
物料清单需求：b.物料清单数量*so.缺失
}))
})),
}
}
});

有太多的

map

函数，它们中的每一个都将返回一个新的数组，而不是重复的数组。之所以得到数组的数组是因为map（）函数。我需要消除这一点，并使用正确的方法。好吧，尽管给出了这个问题，但我认为最终将阵列展平是有意义的。嘿，成功了！我想知道是否有更好的版本。有人说这个词是用来指传播算子的。我想知道reduce（）函数是否也可以在这里工作。如果使用ES6，则可以使用扩展运算符。您可以使用扩展运算符替换整个对象文字，因为我可以看到类似这样的内容

this.soModelBOMs=this.so.filter（x=>x.loaking>0）.map（so=>{var m=model.find（x=>x.model\u no==so.model\u no）；if（m）{return{…so，…m}；}}）

，在我看来，在对象内部调用

map

是没有用的，因为返回的对象的属性和值与修改某些属性和添加属性所需的参数相同，这就是我必须使用map的原因。但是是的，如果我正在创建一个新对象，那么这可能没有意义。不过我还在学习。