Question

我有一组代表类别的数组。每个数组都是一个类别，数组中的每个项目都是一个主题，例如

4 Categories containing Subjects
['A','B','D']
['C']
['E','F']
['G','H','I','J']

我有另一组数组。每个项目最多有四个可能的主题，例如

3 Items containing Subjects
['A','F']
['E','I','C']
['E','F','G']

我想计算每个类别的项目数。在这种情况下，结果应为：

Total Items: 3
Category 1: 1
Category 2: 1
Category 3: 3
Category 4: 2

3项，其中一些属于多个类别。我的一些项目在一个类别中有两个主题，这就是我搞砸的地方。我的结果是：

Total Items: 3
Category 1: 1
Category 2: 1
Category 3: 4
Category 4: 2

我对第3类的计数是1，因为我的第三项有两个属于同一类别的科目，即E和F.

我尝试过什么

作为参考，categories是一个对象数组：

categories = [
  { name: string, subjects: string[], count: number }
]

项目有点相似：

items = [
  { subjects: Subject[] }
]

主题只是：

{ id: string, name: string }

这是我需要调整的内容：

categories.map(category => 
  category.subjects.map(categorySubject => {
    if(items.subjects.map(itemSubject => itemSubject.id)
      .some(val => itemSubject.indexOf(val) === 0)) {
        category.count++;
    }
  }));

我认为我正朝着正确的方向前进，但我需要找到一种方法来检查项目主题是否在类别中，而不是计算两个类别中具有多个主题的项目。我知道这是我的方法就是问题。我无法改变项目格式的方式（是的，ID确实是字符串），但如果有更好的方法，我可以更改类别。

Answer 1

要回答你的问题，这似乎有效：

var categories: Array<{ name: string, subjects: Subject[], count: number }> = [];

type Subject = { id: string, name: string }

var items: Array<{ subjects: Subject[] }> = [];

function inItem(subject: Subject, item: { subjects: Subject[] }): boolean {
    return item.subjects.some(itemSubject => itemSubject.id === subject.id);
}

categories.forEach((category, index) => {
    let count = 0;

    for (let j = 0; j < items.length; j++) {
        for (let i = 0; i < category.subjects.length; i++) {
            if (inItem(category.subjects[i], items[j])) {
                count++;
                break;
            }
        }
    }

    console.log(`Category ${ index + 1 }: ${ count }`);
});

（code with the data in playground）

但这不是一个很好的解决方案，因为如果你不是谁编写代码，或者你是在2个月后就不是很容易理解的。
你应该提出一个更好的解决方案，例如索引它。

只需拥有一个CategoriesIndex即可保存所有类别/主题，并通过它添加/删除/更改它们。在其中，您可以拥有相同的数组，但也可以包含从项目到类别的引用。

Answer 2

这就是我想出来的，但当他们看到这一点时，没有人能够立即理解发生的事情。

categories.map(category => category.count = 0);
let nextCategory = false;
let itemSubjects = items.map(item => item.subjects)
  .map(subjects => subjects.map(subject => subject.id));
for(var i = 0; i < items.length; i++){
  for(var j = 0; j < categories.length; j++){
    nextCategory = false;
    for(var k = 0; k < categories[j].subjects.length; k++){
      for(var l = 0; l < itemSubjects[i].length; l++){
        if(itemSubjects[i][l] === categories[j].subjects[k]){
          categories[j].count++;
          nextCategory = true;
          break;
        }
      }
      if(nextCategory === true){
        break;
      }
    }
  }
}

比必要更复杂：比较和计算数组中的项

2 个答案: