Javascript 如何从较大的对象定义较小的对象？

我正在使用的数据结构：

this.theDataStructureIHave = [
  {
    "1304": {
      "id": 6458,
      "data": "Data1",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1305": {
      "id": 6459,
      "data": "Data2",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1306": {
      "id": 6460,
      "data": "Data3",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1307": {
      "id": 6461,
      "data": "1227",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1308": {
      "id": 6462,
      "data": "12256",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "header": null,
    "id": 500
  },
  {
    "1304": {
      "id": 6463,
      "data": "Data4",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1305": {
      "id": 6464,
      "data": "Data5",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1306": {
      "id": 6465,
      "data": "Data6",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1307": {
      "id": 6466,
      "data": "3574",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1308": {
      "id": 6467,
      "data": "25824",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "header": null,
    "id": 501
  },
  {
    "1304": {
      "id": 6468,
      "data": "Data7",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1305": {
      "id": 6469,
      "data": "Data8",
      "created_at": "2020-10-20 23:16:39",
      "updated_at": "2020-10-20 23:16:39"
    },
    "1306": {
      "id": 6470,
      "data": "Data9",
      "created_at": "2020-10-20 23:16:39",
      "updated_at": "2020-10-20 23:16:39"
    },
    "1307": {
      "id": 6471,
      "data": "3061",
      "created_at": "2020-10-20 23:16:39",
      "updated_at": "2020-10-20 23:16:39"
    },
    "1308": {
      "id": 6472,
      "data": "26696",
      "created_at": "2020-10-20 23:16:39",
      "updated_at": "2020-10-20 23:16:39"
    },
    "header": null,
    "id": 502
  }
]

我希望实现的数据结构：

this.theResultIWant = [
  {
    "1304": {
      "id": 6458,
      "data": "Data1",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1306": {
      "id": 6460,
      "data": "Data3",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    }
  },
  {
    "1304": {
      "id": 6463,
      "data": "Data4",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1306": {
      "id": 6465,
      "data": "Data6",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    }
  },
  {
    "1304": {
      "id": 6468,
      "data": "Data7",
      "created_at": "2020-10-20 23:16:38",
      "updated_at": "2020-10-20 23:16:38"
    },
    "1306": {
      "id": 6470,
      "data": "Data9",
      "created_at": "2020-10-20 23:16:39",
      "updated_at": "2020-10-20 23:16:39"
    },
  }
]

总之，我有一个包含两个对象的数组，在这些对象中有更多的对象（this.theDataStructureIHave）

从这个数据结构开始，我想创建一个新的对象数组，它基本上包含来自这个数组的某些元素

这里还有一组数字：[13041306]。假设这被分配给变量arrayOfNumber=[13041306]

然后我想要的最终结果是过滤掉这个。数据结构I拥有并检索索引等于1304和1306的对象。ArrayOfNumber是一个动态值（这只是一个示例），在代码中如下所示：

this.arrayOfNumbers = this.someObject.columns.map(Number);

是否有一种方法可以实现这一点并获得这一结果。数据结构是动态的？没有硬编码值

---

另请参见代码笔底部，了解我正在尝试实现的数据结构，该结构称为this。结果是，根据输入，此解决方案不安全。如果输入数据不正确，它不会引发异常

工作原理：

我们正在映射数据结构ihave，即将此数组中的每个外部对象都更改为其他对象

Object.entries（outerObject）

为我们提供此对象的键和值对（类似于

[[key1，value1]，[key2，value2]，[key3，value3]]

）

我们根据这些键是否包含在

数组编号中
过滤这些键。请注意，数组有整数，对象有键作为字符串，因此需要
parseInt
。如果你被
（[key，val]）
搞糊涂了-这是一个数组的解构，也就是说，它接受
[key，val]
数组，分别给我们
key
和
value
（我没有使用，所以我把它命名为
），否则我们会使用类似
（keyValuePair）的东西
然后将密钥引用为
keyValuePair[0]

Object.fromEntries（…）

基于键/值对构造一个对象

const theDataStructureIHave=[{
"1304": {
“id”：6458，
“数据”：“数据1”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1305": {
“id”：6459，
“数据”：“数据2”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1306": {
“id”：6460，
“数据”：“数据3”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1307": {
“id”：6461，
“数据”：“1227”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1308": {
“id”：6462，
“数据”：“12256”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
“标题”：空，
“身份证”：500
},
{
"1304": {
“id”：6463，
“数据”：“数据4”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1305": {
“id”：6464，
“数据”：“数据5”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1306": {
“id”：6465，
“数据”：“数据6”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1307": {
“id”：6466，
“数据”：“3574”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1308": {
“id”：6467，
“数据”：“25824”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
“标题”：空，
“id”：501
},
{
"1304": {
“id”：6468，
“数据”：“数据7”，
“创建时间”：“2020-10-20 23:16:38”，
“更新时间：”2020-10-20 23:16:38“
},
"1305": {
“id”：6469，
“数据”：“数据8”，
“创建时间”：“2020-10-20 23:16:39”，
“更新时间：”2020-10-20 23:16:39
},
"1306": {
“id”：6470，
“数据”：“数据9”，
“创建时间”：“2020-10-20 23:16:39”，
“更新时间：”2020-10-20 23:16:39
},
"1307": {
“id”：6471，
“数据”：“3061”，
“创建时间”：“2020-10-20 23:16:39”，
“更新时间：”2020-10-20 23:16:39
},
"1308": {
“id”：6472，
“数据”：“26696”，
“创建时间”：“2020-10-20 23:16:39”，
“更新时间：”2020-10-20 23:16:39
},
“标题”：空，
“id”：502
}
]
常量数组编号=[13041306]；
const result=theDataStructureIHave.map（outerObject=>
Object.fromEntries（Object.entries（outerObject）.filter（（[key，)]=>ArrayOfNumber.includes（parseInt（key）））
);
console.log（result）

请将您的问题包括代码本身，而不仅仅是指向代码笔的链接。如果您想创建一个可运行的示例，请使用堆栈片段。