过滤嵌套的嵌套数组

Question

你好有这个数组：

   [ {
        "Navn": "Long Island Iced Tea",
        "Nummer": "2",
        "Glas i ml": "250",
        "Instruktioner": "",
        "a": "Hæld is i glasset",
        "b": "pynt med en skive lime",
        "Ingredienser": [
            {
                "Type": "Spiritus",
                "Del1": [
                    {
                        "Cointreau": 20
                    }
                ],
                "Del2": [
                    {
                        "Gin": 20
                    }
                ],
                "Del3": [
                    {
                        "Rom_Lys": 20
                    }
                ],
                "Del4": [
                    {
                        "Tequila": 20
                    }
                ],
                "Del5": [
                    {
                        "Vodka": 20
                    }
                ]
            },
            {
                "Type": "Vand/Juice",
                "Del1": [
                    {
                        "Cola": 40
                    }
                ],
                "Del2": [
                    {
                        "Sprite": 20
                    }
                ]
            },
            {
                "Type": "Mixer",
                "Del1": [
                    {
                        "Lime_Sirup": 20
                    }
                ]
            }
        ]
    }]

它用于鸡尾酒机。

我想通过“Del1”搜索（示例）“Rom_Lys”&“Cola”&“Vodka”来过滤它，然后输出一个具有这些规范的新数组。

我尝试搜索论坛，但似乎找不到有用的东西。玩过过滤器和包含，但想不出任何有用的东西。

谢谢！

Answer 1

如果要获取包含Cola 的项目，则可以使用filter 和some 方法：

const filterWord = 'Cola';

const result = sampleData.filter(s => 
    s.Ingredienser.some(s => 
        s.Del1.some( e=> e[filterWord])));

console.log(result);

一个例子：

let sampleData = [
{
    "Navn": "Rom & Cola/ Cuba Libre",
    "Nummer": "0",
    "Glas i ml": "200",
    "Instruktioner": "",
    "a": "Hæld is i glasset",
    "b": "pynt med en skive citron",
    "Ingredienser": [
        {
            "Type": "Spiritus",
            "Del1": [
                {
                    "Rom_Lys": 40
                }
            ]
        },
        {
            "Type": "Vand/Juice",
            "Del1": [
                {
                    "Cola": 100
                }
            ]
        },
        {
            "Type": "Mixer",
            "Del1": [
                {}
            ]
        }
    ]
},
{
    "Navn": "Isbjørn",
    "Nummer": "1",
    "Glas i ml": "200",
    "Instruktioner": "",
    "a": "Hæld is i glasset",
    "b": "pynt med en skive citron",
    "Ingredienser": [
        {
            "Type": "Spiritus",
            "Del1": [
                {
                    "Vodka": 30
                }
            ]
        },
        {
            "Type": "Vand/Juice",
            "Del1": [
                {
                    "Sprite": 60
                }
            ]
        },
        {
            "Type": "Mixer",
            "Del1": [
                {
                    "Blå_Sirup": 30
                }
            ]
        }
    ]
}];


const filterWord = 'Cola';
const result = sampleData.filter(s => s.Ingredienser.some(s => s.Del1.some( e=> e[filterWord])));
console.log(result);

更新：

如果要检查多个键，则可以使用hasOwnProperty 方法检查对象是否包含所需的键：

const filters = ['Cointreau', 'Gin', 'Rom_Lys'];
const result = sampleData.filter(s =>
    s.Ingredienser.some(ingred => {
        return Object.keys(ingred).some(k=> {
            if (Array.isArray(ingred[k])) {
                return ingred[k].some(s=> filters.some(f=> {
                    return s.hasOwnProperty(f);
                }))
            }
        });
    }
));

还有这个例子：

let sampleData = [ {
"Navn": "Long Island Iced Tea",
"Nummer": "2",
"Glas i ml": "250",
"Instruktioner": "",
"a": "Hæld is i glasset",
"b": "pynt med en skive lime",
"Ingredienser": [
    {
        "Type": "Spiritus",
        "Del1": [
            {
                "Cointreau": 20
            }
        ],
        "Del2": [
            {
                "Gin": 20
            }
        ],
        "Del3": [
            {
                "Rom_Lys": 20
            }
        ],
        "Del4": [
            {
                "Tequila": 20
            }
        ],
        "Del5": [
            {
                "Vodka": 20
            }
        ]
    },
    {
        "Type": "Vand/Juice",
        "Del1": [
            {
                "Cola": 40
            }
        ],
        "Del2": [
            {
                "Sprite": 20
            }
        ]
    },
    {
        "Type": "Mixer",
        "Del1": [
            {
                "Lime_Sirup": 20
            }
        ]
    }
]
}];

const filters = ['Cointreau', 'Gin', 'Rom_Lys'];
const result = sampleData.filter(s =>
s.Ingredienser.some(ingred => {
    return Object.keys(ingred).some(k=> {
        if (Array.isArray(ingred[k])) {
            return ingred[k].some(s=> filters.some(f=> {
                return s.hasOwnProperty(f);
            }))
        }
    });
}
));
console.log(result);

Answer 2

尝试使用以下代码过滤数组。

var filtered = arr.filter(function(unique) {
    for (var index = 0; index < unique.Ingredienser.length; index++) {
        if (unique.Ingredienser[index].Del1[0].hasOwnProperty(selectedchoice)) {
            return true;
        }
    }
    return false;
});