Javascript 如何按数组对象的一个字段对其进行分组？

我试图通过从另一个数组列表中筛选来重构数组

包含筛选器的数组：

const filteringTags: [
    'Kitchen',
    'Accessories',
    ...
]

[
    {
        category: 'free',
        date: '2020-04-04',
        title: 'Some Title',
        tags: [
            'Kitchen',
            'Accessories'
        ]
    },
    {
        category: 'premium',
        date: '2020-04-05',
        title: 'Another Title',
        tags: [
            'Kitchen'
        ]
    },
    ...
]

[
    'Kitchen': [
        {
            category: 'free',
            date: '2020-04-04',
            title: 'Some Title',
            tags: [
                'Kitchen',
                'Accessories'
            ]
        },
        {
            category: 'premium',
            date: '2020-04-05',
            title: 'Another Title',
            tags: [
                'Kitchen'
            ]
        }
    ],
    'Accessories': [
        {
            category: 'free',
            date: '2020-04-04',
            title: 'Some Title',
            tags: [
                'Kitchen',
                'Accessories'
            ]
        }
    ]
]

我要操作的数组：

const filteringTags: [
    'Kitchen',
    'Accessories',
    ...
]

[
    {
        category: 'free',
        date: '2020-04-04',
        title: 'Some Title',
        tags: [
            'Kitchen',
            'Accessories'
        ]
    },
    {
        category: 'premium',
        date: '2020-04-05',
        title: 'Another Title',
        tags: [
            'Kitchen'
        ]
    },
    ...
]

[
    'Kitchen': [
        {
            category: 'free',
            date: '2020-04-04',
            title: 'Some Title',
            tags: [
                'Kitchen',
                'Accessories'
            ]
        },
        {
            category: 'premium',
            date: '2020-04-05',
            title: 'Another Title',
            tags: [
                'Kitchen'
            ]
        }
    ],
    'Accessories': [
        {
            category: 'free',
            date: '2020-04-04',
            title: 'Some Title',
            tags: [
                'Kitchen',
                'Accessories'
            ]
        }
    ]
]

预期结果：

const filteringTags: [
    'Kitchen',
    'Accessories',
    ...
]

[
    {
        category: 'free',
        date: '2020-04-04',
        title: 'Some Title',
        tags: [
            'Kitchen',
            'Accessories'
        ]
    },
    {
        category: 'premium',
        date: '2020-04-05',
        title: 'Another Title',
        tags: [
            'Kitchen'
        ]
    },
    ...
]

[
    'Kitchen': [
        {
            category: 'free',
            date: '2020-04-04',
            title: 'Some Title',
            tags: [
                'Kitchen',
                'Accessories'
            ]
        },
        {
            category: 'premium',
            date: '2020-04-05',
            title: 'Another Title',
            tags: [
                'Kitchen'
            ]
        }
    ],
    'Accessories': [
        {
            category: 'free',
            date: '2020-04-04',
            title: 'Some Title',
            tags: [
                'Kitchen',
                'Accessories'
            ]
        }
    ]
]

我尽量避免使用库，所以如果您有任何建议，如果您使用vanilla JS，我将不胜感激

const filteringTags = [
  'Kitchen',
  'Accessories',
] 

const arr = [
  {
    category: 'free',
    date: '2020-04-04',
    title: 'Some Title',
    tags: [
        'Kitchen',
        'Accessories'
    ]
},
{
    category: 'premium',
    date: '2020-04-05',
    title: 'Another Title',
    tags: [
        'Kitchen'
    ]
}
]

const resultArr = filteringTags.map((it, index) => {
  return { [it]: arr }
})

如果需要对象，请使用此函数

const resultObj = filteringTags.reduce((acc, it) => {
  return { ...acc, [it]: arr }
}, {})

---

下面是一个完整的工作示例，可以产生所需的结果：

const filteringTags=[
“厨房”，
“附件”，
];
常数数据=[
{
类别:"免费",，
日期：“2020-04-04”，
标题：“一些标题”，
标签：[
“厨房”，
“配件”
]
},
{
类别:"特优",，
日期：“2020-04-05”，
标题：“另一个标题”，
标签：[
“厨房”
]
},
];
函数byTag（标记、数据）{
设tagMap={}；
for（让标签中的标签）{
tagMap[tag]=[]；
用于（数据的基准）{
if（基准标签包括（标签））{
tagMap[tag]。推送（基准）；
}
}
}
返回标记图；
}
让结果=按标签（过滤标签、数据）；
log（JSON.stringify（result，null，2））您可以执行以下操作：


var-arr=[
{
类别:"免费",，
日期：“2020-04-04”，
标题：“一些标题”，
标签：[
“厨房”，
“配件”
]
},
{
类别:"特优",，
日期：“2020-04-05”，
标题：“另一个标题”，
标签：[
“厨房”
]
},
];
var res=arr.REDUCT（（acc，elem）=>{
elem.tags.forEach（k=>{
acc[k]=acc[k]？[…acc[k]，JSON.parse（JSON.stringify（elem））]：[JSON.parse（JSON.stringify（elem））]；
})
返回acc
},{});
console.log（res）
将所需输出视为对象数组


const数据=[
{
类别:"免费",，
日期：“2020-04-04”，
标题：“一些标题”，
标签：[“厨房”、“附件”]，
},
{
类别:"特优",，
日期：“2020-04-05”，
标题：“另一个标题”，
标签：[“厨房”]，
},
];
const filteringTags=[“厨房”、“附件”]；
常量getGroupedData=（数据、筛选器）=>{
const result={}；
filters.forEach（filter=>{
结果[过滤器]=[
…JSON.parse（JSON.stringify（（结果[过滤器]| |“”），
…JSON.parse（JSON.stringify（data.filter（d=>d.tags.includes（filter））），
];
});
返回结果；
};
让finalResult=getGroupedData（数据、筛选标记）；
finalResult=Object.keys（finalResult.map）（key=>({
[键]：最终结果[键]，
}));
控制台日志（最终结果）您可以通过以下方式执行此操作：


reduce（）
filter（）


var filteringTags=[“厨房”、“附件”]；
var arr=[{类别：'free'，日期：'2020-04-04'，标题：'Some title'，标签：['Kitchen'，'associates']}，{类别：'premium'，日期：'2020-04-05'，标题：'other title'，标签：['Kitchen']}；
var结果=过滤标记减少（（acc，e）=>{
acc[e]=arr.filter（k=>k.tags.includes（e））；
返回acc；
},{});
控制台日志（结果）“…这里没有有用的帖子”。不管怎样，发布它-它显示了努力，这使得很可能有人会提供帮助。看起来预期结果不是有效的JSON对象。它是一个对象数组还是仅仅是一个对象？如果有N个数据项和M个标记，你会得到类似于O（N3）@ABGR的东西，上面的解决方案是O（N*M）。我不知道O（N^3）是从哪里来的。N*M仍然被认为是N^2。另外，你忽略了还有
包含
，它们一起构成了三个过程，因此为0（N^3）。无论如何，没有冒犯：）这里有一个严重的循环引用问题。如果您修改
厨房[0]。类别
，则
附件
的类别也将更改。我同意@ABGR。谢谢你指出这一点。我已经用修复程序更新了答案。