Explication détaillée du problème de déduplication de tableau Javascript_compétences Javascript

Tout d'abord, ce à quoi j'ai pensé était de créer un autre tableau de résultats pour stocker des données uniques dans le tableau d'origine. Parcourez le tableau d'origine et comparez-le avec les éléments du tableau de résultats pour détecter les doublons. J'ai donc écrit le code A suivant :

Array.prototype.clearRepetitionA = function(){
   var result = [];
   var isRepetition;
   for(var i=0; i<this.length; i++){
     isRepetition = false;
     for(var j=0; j<result.length; j++){
       if(this[i] === result[j]){
         isRepetition = true;
         break;
       }
     }
     if(!isRepetition){
       result.push(this[i]);
     }
   }
   return result;
 } 

Après avoir fini d'écrire, je me suis soudainement rappelé que la méthode de tableau indexOf dans ECMAScript 5 que je viens de lire il y a quelques jours peut récupérer des éléments de tableau. J'ai donc utilisé la méthode indexOf pour remplacer la boucle de deuxième niveau et j'ai écrit le Code B suivant :

Array.prototype.clearRepetitionB = function(){
   var result = [];
   for(var i=0; i<this.length; i++){
     if(result.indexOf(this[i]) == -1){
       result.push(this[i]);
     }
   }
   return result;
 } 

Le code est passé subitement de 17 lignes à 9 lignes, ce qui est beaucoup plus simple. Il existe généralement plusieurs façons de résoudre de grandes questions en mathématiques au secondaire, et je continue ensuite de penser à d’autres méthodes. La méthode indexOf consiste à rechercher des éléments avec une valeur donnée dans l'ensemble du tableau et à renvoyer l'index du premier élément trouvé. S'il n'est pas trouvé, il renvoie -1. Le premier paramètre est la valeur à rechercher et le deuxième paramètre. est facultatif : il spécifie un index dans le tableau à partir duquel démarrer la recherche. Si ce paramètre est omis, la recherche démarre depuis le début. Dès que j'ai commencé à réfléchir, j'ai pensé que la méthode précédente consistait à détecter si la valeur était répétée. Maintenant que nous avons la méthode indexOf, nous pouvons juger en fonction de l'index de la première occurrence de chaque élément détecté et de la valeur de l'index. de l’élément lui-même. Est-il répété ? Alors, j'ai écrit le Code C :

 Array.prototype.clearRepetitionC = function(){
   var result = [this[0]];
   for(var i=1; i<this.length; i++){
     if(this.indexOf(this[i]) == i){
       result.push(this[i]);
     }
   }
   return result;
 } 

Après avoir écrit ceci, j'ai continué à y réfléchir, mais je ne vois vraiment pas d'autres méthodes. Ces trois méthodes sont toutes très basiques. Alors, je suis allé comparer les réponses et me tester. Quand j'ai regardé les réponses, j'ai découvert que j'étais encore trop faible et que les questions simples contenaient encore des idées fantastiques. Ce qui suit n’est pas ce que je pense, donc je ne parlerai pas trop de mon parcours mental. Sans plus attendre, passons directement à l’analyse classique des réponses.
Parlons d’abord d’une solution qui est souvent évoquée dans les algorithmes pour échanger de l’espace contre du temps et maintenir la formation. Appelons-la Code D :
.

Array.prototype.clearRepetitionD = function(){
   var result = [];
   var obj = {};
   var key,type;
   for(var i=0; i<this.length; i++){
     key = this[i];
     type = typeof key;
     if(!obj[key]){
       obj[key] = [type];
       result.push(key);
     }else if(obj[key].indexOf(type)){
       obj[key].push(type);
       result.push(key);
     }
   }
   return result;
 } 

Dans cette méthode, l'attribut d'un objet obj est utilisé pour enregistrer la valeur de l'élément dans le tableau d'origine lors du parcours du tableau d'origine. En même temps, la valeur de cet attribut est un tableau, utilisé pour stocker le type de cet attribut. Celui-ci permet de distinguer les éléments similaires au chiffre 1 et les éléments de la chaîne '1' dans le tableau d'origine. Cette méthode réduit le temps passé par la méthode indexOf parmi les trois méthodes ci-dessus en construisant un objet supplémentaire, qui peut être considéré comme plus efficace.
Si vous êtes satisfait de la méthode efficace mentionnée ci-dessus pour échanger de l'espace contre du temps et que vous ne continuez pas à lire, alors vous vous trompez totalement. Les meilleures choses sont toujours à venir. Maintenant, le plaisir commence, il ne fait aucun doute que c'est le Code E :

 Array.prototype.clearRepetitionE = function(){
   var result = [];
   for(var i=0; i<this.length; i++){
     for(var j=i+1; j<this.length; j++){
       if(this[i] === this[j]){
         j = ++i;
       }
     }
     result.push(this[i]);
   }
   return result;
 }

Le Code D échange l'espace contre le temps, et le sentiment est juste moyen. Et le code E ? Ce code est-il erroné ? Cela peut-il vraiment supprimer les doublons ? Oui, je n'ai pas compris le code au début, je ne l'ai pas compris jusqu'à ce que je lise l'analyse et la relise. Ensuite, les lecteurs qui ne comprennent pas devraient lire attentivement l'analyse : le premier niveau parcourt le tableau d'origine d'avant en arrière, et la boucle de deuxième niveau détecte si chaque élément est répété avec l'élément qui le suit s'il y a des éléments répétés après. , Ignorez-le ; si tous les éléments après cet élément sont uniques, ajoutez-le au tableau résultant. L'idée de mettre en œuvre cette méthode est d'obtenir la valeur la plus à droite sans duplication et de l'ajouter au tableau de résultats. Par rapport à la première méthode, cela optimise également la boucle de deuxième niveau et est cependant plus efficace que celle-ci. tableau de cette méthode L'ordre des éléments est différent de l'ordre des éléments dans le tableau d'origine.

Après avoir lu l'analyse du Code E, avez-vous déjà levé le pouce et m'avez regardé avec admiration ? (Ne me donnez pas ces fleurs et ces honneurs, ils devraient aller au maître qui a écrit cette méthode). Parlons de la dernière méthode : C'est-à-dire trier d'abord puis supprimer les doublons. Selon les anciennes règles, cela s'appelle Code F :

Array.prototype.clearRepetitionF = function(){
   this.sort();
   var result = [this[0]];
   for(var i=1; i<this.length; i++){
     if(this[i] !== result[result.length-1]){
       result.push(this[i]);
     }
   }
   return result;
 } 

Ceci utilise d'abord la méthode de tri de tableau sort pour trier les éléments du tableau, puis effectue le travail de duplication.

Ce qui précède est une étude étape par étape sur le problème de la déduplication de tableaux javascript Le code est constamment amélioré. Un total de six morceaux de code sont partagés. J'espère que tout le monde étudiera dur et. gagner quelque chose.