Javascript 获取两个数组之间的精确匹配元素

我有两个数组，如下所示：

array1 = [
         {id:1, children: ['a', 'b']},
         {id:2, children: ['a', 'b']},
         {id:3, children: ['b', 'c']},
         {id:4, children: ['c', 'a']},
         {id:5, children: ['a', 'b', 'c']}];

array2 = ['a', 'b'];

 const productOrders: ProductOrder[] =
      [
        {
          productId: 1, subProductOrders:
            [{subProduct: {subProductId: 1}}, {subProduct: 
{subProductId: 2}}]
        },
        {
          productId: 1, subProductOrders:
            [{subProduct: {subProductId: 2}}, {subProduct: 
{subProductId: 1}}]
        },
        {
          productId: 1, subProductOrders:
            [{subProduct: {subProductId: 2}}, {subProduct: 
{subProductId: 3}}]
        },
        {
          productId: 1, subProductOrders:
            [{subProduct: {subProductId: 1}}, {subProduct: 
{subProductId: 2}}, {subProduct: {subProductId: 3}}]
        },
      ];

    const matchingCriteria: SubProductOrder[] =
      [
        [{subProduct: {subProductId: 1}}, {subProduct: {subProductId: 
2}}]

      ];

现在我想在JS/TS中编写一个代码，它将找到array1中的确切对象，其中Array2中的子数组的每个元素都与array1中的子数组的每个元素完全匹配（顺序无关紧要）

我尝试用三个过滤器来解决这个问题，附加条件是数组1和数组2之间的子数组长度匹配。但如果这些子数组中至少有一个元素与所需的数组长度匹配，这也会起作用

如果有人给我答案，我会非常感激

array1
.filter(a => a.children
.filter(b => array2
.filter(c => b === c)).length === array2.length);

编辑：

在上面的例子中，我实际上简化了这个问题。在我的实际项目中，这两个阵列的作用如下：

array1 = [
         {id:1, children: ['a', 'b']},
         {id:2, children: ['a', 'b']},
         {id:3, children: ['b', 'c']},
         {id:4, children: ['c', 'a']},
         {id:5, children: ['a', 'b', 'c']}];

array2 = ['a', 'b'];

 const productOrders: ProductOrder[] =
      [
        {
          productId: 1, subProductOrders:
            [{subProduct: {subProductId: 1}}, {subProduct: 
{subProductId: 2}}]
        },
        {
          productId: 1, subProductOrders:
            [{subProduct: {subProductId: 2}}, {subProduct: 
{subProductId: 1}}]
        },
        {
          productId: 1, subProductOrders:
            [{subProduct: {subProductId: 2}}, {subProduct: 
{subProductId: 3}}]
        },
        {
          productId: 1, subProductOrders:
            [{subProduct: {subProductId: 1}}, {subProduct: 
{subProductId: 2}}, {subProduct: {subProductId: 3}}]
        },
      ];

    const matchingCriteria: SubProductOrder[] =
      [
        [{subProduct: {subProductId: 1}}, {subProduct: {subProductId: 
2}}]

      ];

现在我想从productOrders数组中查找产品，其中subProductOrders数组的SubProductd与matchingCriteria数组的SubProductd匹配（顺序无关紧要）。在上面的示例中，productOrders数组的前两个产品应该匹配，尽管您可以在单个筛选器中使用无序的子产品和长度

const arr1=[
{id:1，子项：[a'，b']}，
{id:2，子项：[a'，b']}，
{id:3，子项：['b'，'c']}，
{id:4，子项：['c'，'a']}，
{id:5，子项：['a'，'b'，'c']}
];
常数arr2=['a'，'b']；
const matched=arr1.filter（（{children:c}）=>c.length===arr2.length&&arr2.every（v=>c.includes（v）））
console.log（匹配）

array1=[
{id:1，子项：[a'，b']}，
{id:2，子项：['b'，'a']}，
{id:3，子项：['b'，'c']}，
{id:4，子项：['c'，'a']}，
{id:5，儿童：[a'，b'，c']}；
array2=['a'，'b']；
常数x=阵列1
.map（a=>a.children.sort（））
.filter（a=>a.length==array2.length）
.map（a=>a.sort（））
.filter（a=>JSON.stringify（a）=JSON.stringify（array2））
console.log（x）

您可以选择一个

集合

并根据此结构检查子项

var array1=[{id:1，子项：['a'，'b']}，{id:2，子项：['a'，'b']}，{id:3，子项：['b'，'c']}，{id:4，子项：['c'，'a']}，{id:5，子项：['a'，'b'，'c']}，
array2=['a'，'b']，
set2=新设置（阵列2），
result=array1.filter（{children}）=>
childrence.length==set2.size&&children.every（Set.prototype.has，set2））；
控制台日志（结果）
.as console wrapper{max height:100%！important；top:0；}
您正在根据element.children与array2的相等性筛选array1元素。
所以我鼓励大家看看这些。因为它讨论了javascript中两个数组的相等性

并根据您的需要修改以下代码，这只是可用的最简单选项之一：

array1.filter((element,index) => {
      return JSON.stringify(element.children) === JSON.stringify(array2)
})

查看此问题的详细答案-仅当订单匹配但OP声明的订单不重要时有效考虑
arr2=abb
，
children=abX
@georg Right…仅当
arr2
值唯一时有效。不清楚OP是否正确。如果使用
Set
@charlietfl，也会出现同样的问题对不起，我把示例简化得太多了。我添加了一个编辑部分。你能给我一个更新的解决方案吗？使用JSON.stringify只有在顺序相同的情况下才有效。我修改了我的回答，指出这是两个数组相等的众多选项之一。好的……但是OP已经声明的顺序并不重要，所以这种方法在这种情况下不相关。返回JSON.stringify如何（element.children.sort（））==JSON.stringify（array2.sort（））在这种情况下也会失败吗？效率不是很高，如果需要保持顺序，排序可能会带来其他问题。请注意，如果确实使用这种方法，
JSON.stringify（array2.sort（））
不需要每次迭代都执行。只执行一次并存储结果恐怕我对示例简化得太多了。我添加了一个编辑部分。您能给我一个更新的解决方案吗？

匹配条件的其他项会发生什么变化，如果只有一个数组而没有嵌套数组不是更好吗？太棒了他的工作很有魅力。为了回答你前面的问题，我只需要一些特定的subProductOrders（带subproductd）使用匹配的subProductOrders合并一些产品。因此，为此，我仅使用subProductOrders创建了匹配条件数组。此编码的目的是，在POS系统中，用户可以添加特定产品（例如卡布奇诺）的多个子产品（topping/add-on等）。用户可以为每单位的卡布奇诺杯添加一个/多个配料/附加组件。因此，这里的目的是合并具有相同附加组件的单位，并计算数量和总价。基本上就是这样