Bonjour,

Une coquille c'est glissé quand le portage python -> javascript

let lRes = [];
if (this.dSugg.get(0).length) {
// we sort the better results with the original word
let dDistTemp = new Map();
lRes.forEach((sSugg) => { dDistTemp.set(sSugg, str_transform.distanceDamerauLevenshtein(this.sWord, sSugg)); });
lRes = lRes.sort((sA, sB) => { return dDistTemp.get(sA) - dDistTemp.get(sB); });
dDistTemp.clear();
}
...

Comme nous pouvons le remarquer le lRes.forEach... essaie de faire quelque chose sur un tableau vide et après ça essaie de le trier ... alors que normalement un tri devrait se faire sur this.dSugg.get(0)

Je pense que ça devrait plutôt être du style :

if (this.dSugg.get(0).length) {
// we sort the better results with the original word
this.dSugg.get(0) = new Set([...this.dSugg.get(0)].sort(function(a,b){
return str_transform.distanceDamerauLevenshtein(this.sWord, a)- str_transform.distanceDamerauLevenshtein(this.sWord, b);
})
);
}
...
let lRes = [];
...

Et sinon la version python fait aussi le trie sur this.dSugg.get(1).

J'espère que ça aidera !

Bonjour,

Oui, merci. En effet.
C’est corrigé.

Je pense que tu peux aussi ajouté comme condition pour le triage de this.dSugg[1] si

this.dSugg.get(0).length <= nSuggLimit

ça permettra de ne faire le trie s'il y a déjà assez de résultat. A répercuté aussi sur la version python.

Sinon l'argument nDistLimit de la function en js n'est pas utilisé ( je viens juste de voir ça ;) )

ça permettra de ne faire le trie s'il y a déjà assez de résultat.

On ne trie qu’une seule liste ou aucune dans tous les cas de figure.

Sinon l'argument nDistLimit de la function en js n'est pas utilisé ( je viens juste de voir ça ;) )

En effet, ce paramètre n’existe même pas en Python.

En faite la fonction peut même être simplifié :

getSuggestions(nSuggLimit = 10) {
// return a list of suggestions
let lRes = [];
for (let [nDist, lSugg] of this.dSugg.entries()) {
if (nDist > this.nDistLimit) {
break;
}
if (lSugg.length > 1) {
// we sort the better results with the original word
lSugg.sort((a, b) => { return str_transform.distanceDamerauLevenshtein(this.sWord, a) - str_transform.distanceDamerauLevenshtein(this.sWord, b); });
}
lRes.push(...lSugg);
if (lRes.length > nSuggLimit) {
break;
}
}
if (this.sWord.gl_isUpperCase()) {
lRes = lRes.map((sSugg) => { return sSugg.toUpperCase(); });
lRes = [...new Set(lRes)];
}
else if (this.sWord.slice(0, 1).gl_isUpperCase()) {
lRes = lRes.map((sSugg) => { return sSugg.slice(0, 1).toUpperCase() + sSugg.slice(1); });
lRes = [...new Set(lRes)];
}
return lRes.slice(0, nSuggLimit);
}

Désolé de ne pas avoir pensée à cette simplification avant, mais n'arrivant pas a tout faire actuellement en rust je me venge sur le javascript lol

Si on ne trie pas toutes les listes, c’est pour une question de performance. Le calcul de distance n’est pas anodin.

J'en suis conscience que ça prend pas mal de ressource le trie mais vue qu'il y a

lRes.push(...lSugg);
if (lRes.length > nSuggLimit) {
break;
}

donc dès qu'il y a assez de suggestion on quitte la boucle et donc si dans le this.dSugg.get(0) il y a déjà assez de suggestions ça ne fera même pas le trie de this.dSugg.get(1) donc je pense que globalement nous avons même un gain de performance avec cette simplification.

Après si tu veux être sure que ça s'applique a moins de liste il suffit de rajouter

if (lSugg.length > 1 && nDist < 2) {
// we sort the better results with the original word

Pour amélioré encore plus les performances

if (this.sWord.gl_isUpperCase()) {
lRes = lRes.map((sSugg) => { return sSugg.toUpperCase(); });
lRes = [...new Set(lRes)];
}
else if (this.sWord.slice(0, 1).gl_isUpperCase()) {
lRes = lRes.map((sSugg) => { return sSugg.slice(0, 1).toUpperCase() + sSugg.slice(1); });
lRes = [...new Set(lRes)];
}
return lRes.slice(0, nSuggLimit);

==>

lRes = new Set(lRes.slice(0, nSuggLimit));
if (this.sWord.gl_isUpperCase()) {
lRes = [...lRes].map((sSugg) => { return sSugg.toUpperCase(); });
lRes = [...new Set(lRes)];
}
else if (this.sWord.slice(0, 1).gl_isUpperCase()) {
lRes = [...lRes].map((sSugg) => { return sSugg.slice(0, 1).toUpperCase() + sSugg.slice(1); });
lRes = [...new Set(lRes)];
}
return lRes;

Ce qui permet de mettre les majuscules qu'aux suggestions qui sont retourné et non a une plus grande liste.

nSuggLimit pourrait changer pour un nombre plus élevé. Il faut aussi se prémunir de ça.
Et comment pourrait-il y avoir un gain de performance si on en fait plus que moins ?
Je suis peut-être trop prudent, mais dans certains cas il vaut parfois mieux l’être trop que pas assez.
Par ailleurs, si cette fonction se contente de trier les premières suggestions, c’est précisément parce que ce sont les meilleures. Ça n’apporte la plupart du temps rien de trier les dernières entrées, dont l’utilisateur va se foutre complètement. La plupart du temps, il ne va même pas les lire. À quoi bon perdre du temps à quelque chose qui n’est pas utile ?

Pour le second cas, effectivement, il y a un gain de performance, mais infime, attendu que c’est un coût négligeable. En revanche, si la troncation se fait à la fin et non avant (comme vous le faites), c’est parce qu’avec les changements de casse, dans certains cas, certaines suggestions vont fusionner (ce n’est pas pour rien qu’on purge les multiples avec Set()) : vous aurez donc moins d’entrées que ce qui est demandé par nSuggLimit. Voilà pourquoi.

J'ai faits divers Benchmark, et effectivement vous avez raison votre version est plus rapide (j'aurais dût le faire avant mes propositions :s ). Durant ce Benchmark j'ai remarqué que le this.dSugg.get(0) soit qu'il n'y a rien soit qu'il n'y a qu'un élément (c'est logique en réfléchissant)... Pour se Benchmark je l'ai fait avec des mots et non mots !

Pour le slice avant la mise en majuscule ça fait même perdre un peu vu qu'en faite le retour de cette fonction serait dans se cas return [...lRes]; et donc çà ajoute des conversions de array <-> set

Ma constations sur le this.dSugg.get(0) est déjà prise en compte par vos derniers changement ;) c'est du rapide !
Vous avez du lire dans mes pensées mdr!