在Javascript中计算两个数组对象的唯一值

给定一个类别数组和一个条目数组，创建一个具有类别名称和条目计数的对象数组。考虑ID等于CyryId。< /P>

var categories = [
  { name: 'Cats', id: 10 },
  { name: 'Dogs', id: 20 },
 
];

var entries = [
  {categoryId: 10, name: 'Fluffy'},
  {categoryId: 10, name: 'Spot'},
  {categoryId: 10, name: 'Lil'},
  {categoryId: 20, name: 'Tom'},
  {categoryId: 20, name: 'Buck'},
  {categoryId: 20, name: 'Flo'},
  {categoryId: 20, name: 'Cheek'},
  {categoryId: 10, name: 'Stan'},
  {categoryId: 20, name: 'Stila'}
  
]

Expected Output: [{ name:'Cats', count: 4 }, { name:'Dogs', count: 5 }];

我在下面这样写的，但是当你试图在数百个类别和数万个条目中运行它时，似乎存在性能问题

const categoriesByEntryCount = (categories, entries) =>
  categories.map(category => ({
    name: category.name,
    count: entries.filter(entry => entry.categoryId === category.id).length,
  }));

我的问题是，还有其他方法来编写或实现此功能吗？

const categories=[{name:'Cats'，id:10}，{name:'Dogs'，id:20}]；
const entries=[{categoryId:10，name:'Fluffy'}，{categoryId:10，name:'Lil'}，{categoryId:20，name:'Tom'}，{categoryId:20，name:'Buck'}，{categoryId:20，name:'Flo'}，{categoryId:20，name:'chick'}，{categoryId:10，name:'Stan categoryId:20，name:'Stila'}；
//获取条目中每个类别的出现次数
const categoriesCount=entries.reduce（（countMap，{categoryId}）=>
countMap.set（categoryId，1+（countMap.get（categoryId）| | 0））
，新地图）；
//迭代类别并返回categoriesCount中的名称和计数
const res=categories.map（{name，id}）=>
（{name，count:categoriesCount.get（id）}）
);
控制台日志（res）您需要在所有可能的位置使用
地图


var categories=newmap（）；
类别。集合（10个“猫”）；
类别：集合（20只“狗”）；
变量项=[
{categoryId:10，名称：'Fluffy'}，
{类别ID:10，名称：'Spot'}，
{类别ID:10，名称：'Lil'}，
{类别ID:20，名称：'Tom'}，
{类别ID:20，名称：'Buck'}，
{类别ID:20，名称：'Flo'}，
{类别ID:20，名称：'脸颊'}，
{类别ID:10，名称：'Stan'}，
{类别ID:20，名称：'斯蒂拉'}，
];
console.log（Array.from(
减少(
（m，{categoryId，name}）=>
m、 set（categoryId，（m.get（categoryId）| | 1）+1），
新地图（）
),
（[k，v]）=>（{name:categories.get（k），count:v}）
));我们可以使用时间复杂度O（M+N）


var类别=[
{姓名：'猫'，id:10}，
{姓名：'狗'，id:20}，
];
变量项=[
{categoryId:10，名称：'Fluffy'}，
{类别ID:10，名称：'Spot'}，
{类别ID:10，名称：'Lil'}，
{类别ID:20，名称：'Tom'}，
{类别ID:20，名称：'Buck'}，
{类别ID:20，名称：'Flo'}，
{类别ID:20，名称：'脸颊'}，
{类别ID:10，名称：'Stan'}，
{类别ID:20，名称：'Stila'}
]
const categoriesByEntryCount=（类别、条目）=>{
常量entriesHash=条目。减少（（acc，ele）=>{
附件[ele.categoryId]=附件[ele.categoryId]？附件[ele.categoryId]+1:1；
返回acc；
}, {});
返回categories.map（category=>({
名称：category.name，
计数：entriesHash[category.id]，
}));
}
log（categoriesByEntryCount（categories，entries））
这显然是一项减少工作量的工作


var categories=[{name:'Cats'，id:10}
，{name:'Dogs'，id:20}
],
条目=[{categoryId:10，名称：'Fluffy'}
，{categoryId:10，名称：'Spot'}
，{categoryId:10，名称：'Lil'}
，{类别ID:20，名称：'Tom'}
，{类别ID:20，名称：'Buck'}
，{类别ID:20，名称：'Flo'}
，{类别ID:20，名称：'脸颊'}
，{类别ID:10，名称：'Stan'}
，{类别ID:20，名称：'Stila'}
],
结果=条目.reduce（（cs，e）=>（cs.map（c=>c.id===e.categoryId？c.count？c.count++
：c.计数=1
：c）
，cs
)，类别）；
控制台日志（结果）