Est-ce que tester .includes() sur une matrice aplatie avant de tester sur différents sous-réseaux améliore les performances dans js?

Question

J'écris un programme qui vérifie si des mots-clés particuliers reviennent dans une chaîne, en utilisant .includes(). J'ai catégorisé les mots-clés dans un objet json, principalement parce que je veux des comptes séparés par catégorie.

Ma première approche consistait à parcourir chaque mot dans le texte et à exécuter une instruction if pour chaque tableau de l'objet keywords. Cela a abouti à 6 if-déclarations différentes pour chaque mot dans le texte, ce qui, je pense, pourrait ne pas être très efficace, surtout parce que beaucoup de mots dans le texte ne correspondent à aucun des mots dans les tableaux de mots-clés. J'ai alors décidé de vérifier s'il serait mieux d'aplatir mon objet keywords en un seul tableau, et de vérifier si un mot correspond à l'un des mots du tableau aplati avant de passer aux tableaux plus spécifiques de mots-clés.

J'ai inclus un exemple simplifié ci-dessous:

La liste des mots-clés:

{ 
    "category1": { 
    "subcategory1": [ 
     "keyword", 
     "keyword" 
    ], 
    "subcategory2": [ 
     "keyword" 
    ] 
    }, 
    "category2" : { 
    "subcategory1" : [ 
     "keyword", 
     "keyword", 
     "keyword" 
    ], 
    "subcategory2" : [ 
     "keyword", 
     "keyword" 
    ] 
    }, 
    "category3": [ 
    "keyword", 
    "keyword", 
    "keyword"  
    ] 
} 

Maintenant, pour la deuxième approche, je pressai l'objet JSON (keywordlist) à un certain nombre de tableaux, puis le réduire à un seul tableau (keywordListArray) en utilisant reduce(). J'ai ensuite inclus une instruction if qui filtrerait tous les mots qui n'étaient dans aucun des tableaux, avant d'exécuter des tests plus spécifiques.

for (let property in text) { 

    if (keywordListArray.includes(property)) { 
    // Will this improve performance? 

     if (keywordList.category.subcategory.includes(property)) { 
      result.category.subcategory ++; 
     } 
     if (keywordList.category.otherSubcategory.includes(property)) { 
      result.category.subcategory ++; 
     } 

    } 
    } 

J'ai ensuite vérifié le temps d'exécution de chaque approche. J'ai fourni un exemple simplifié, mais dans mon cas, mon objet de mots-clés se composait de 6 tableaux différents avec environ 10 mots-clés chacun. Le texte d'entrée fait environ 200 caractères, et renverra probablement 15 correspondances avec les mots-clés.

texte de 200 mots:

Temps d'exécution sans matrice aplatie et le filtre avant (approche 1): 10-12 ms de temps d'exécution avec matrice aplatie et le filtre avant (approche 2): 9-11 ms

J'ai également testé avec 400 mots, mais il n'y a presque aucune différence dans le temps d'exécution. Je me demandais quelle approche vous recommanderiez, à la fois en termes d'écriture de «bon code» et en termes de performance?

Deux hypothèses pour commencer:

• Le plus de mots du texte qui correspondent à un mot-clé, plus redondant le filtre avant en utilisant le tableau aplaties.
• Plus il y a de catégories (tableaux) dans l'objet json, plus il y a d'instructions if, et plus l'approche est lente sans filtre préalable.

Est-ce vrai, et vous attendez-vous à ce qu'il y ait une grande différence de performance lorsque vous l'utilisez dans un projet à plus grande échelle?

Merci d'avance! Daan

Answer 1

Je prendrais un seul objet pour compter les mots-clés avec les mots clés comme clé et un objet pour le nombre, les catégories et les sous-catégories.

{ 
    pizza: { 
     count: 0, 
     category: 'Food', 
     subcategory: 'Italian' 
    }, 
    ramen: { 
     // ... 
    } 
} 

Plus tard, vous pourriez rendre un objet avec tous les mots-clés regroupés par catégorie et sous-catégorie.

L'avantage de ce qui précède, vous pouvez vérifier que si la clé est dans l'objet et de prendre ensuite la clé pour incrément du compteur, comme

if (property in object) { 
    object.count++; 
}