Detaillierte Erläuterung des Javascript-Array-Deduplizierungsproblems_Javascript-Fähigkeiten

Zuerst dachte ich daran, ein weiteres Ergebnis-Array zu erstellen, um eindeutige Daten im ursprünglichen Array zu speichern. Durchlaufen Sie das ursprüngliche Array und vergleichen Sie es mit den Elementen im Ergebnisarray, um Duplikate zu erkennen. Also habe ich den folgenden Code A geschrieben:

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;
 } 

Nachdem ich mit dem Schreiben fertig war, fiel mir plötzlich ein, dass die Array-Methode indexOf in ECMAScript 5, die ich erst vor ein paar Tagen gelesen habe, Array-Elemente abrufen kann. Also habe ich die indexOf-Methode verwendet, um die Schleife der zweiten Ebene zu ersetzen, und den folgenden Code B:
geschrieben

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;
 } 

Der Code wurde plötzlich von 17 Zeilen auf 9 Zeilen geändert, was viel einfacher ist. Normalerweise gibt es mehr als eine Möglichkeit, große Fragen in der Mathematik der Oberstufe zu lösen, und dann denke ich weiterhin über andere Methoden nach. Die indexOf-Methode bedeutet, im gesamten Array nach Elementen mit einem bestimmten Wert zu suchen und den Index des ersten gefundenen Elements zurückzugeben. Wenn es nicht gefunden wird, gibt es -1 zurück ist optional: Gibt einen Index im Array an, ab dem die Suche gestartet werden soll. Wenn dieser Parameter weggelassen wird, beginnt die Suche von vorne. Sobald ich anfing zu denken, dachte ich, dass die vorherige Methode darin besteht, zu erkennen, ob der Wert wiederholt wird. Da wir nun die indexOf-Methode haben, können wir anhand des Index des ersten Vorkommens jedes erkannten Elements und des Indexwerts beurteilen des Elements selbst. Wird es wiederholt? Also habe ich Code C:
geschrieben

 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;
 } 

Nachdem ich das geschrieben habe, habe ich weiter darüber nachgedacht, aber mir fallen wirklich keine anderen Methoden ein. Diese drei Methoden sind alle sehr einfach. Also habe ich die Antworten verglichen und mich selbst getestet. Als ich mir die Antworten ansah, stellte ich fest, dass ich immer noch zu schwach war und einfache Fragen immer noch einige fantastische Ideen enthielten. Das Folgende ist nicht das, was ich denke, daher werde ich nicht zu viel über meine mentale Reise sprechen. Kommen wir ohne Umschweife direkt zur klassischen Antwortanalyse.
Lassen Sie uns zunächst über eine Lösung sprechen, von der in Algorithmen häufig gesagt wird, dass sie Raum gegen Zeit austauscht und die Formation aufrechterhält. Nennen wir sie 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;
 } 

Bei dieser Methode wird das Attribut eines Objekts obj verwendet, um den Wert des Elements im ursprünglichen Array zu speichern, wenn das ursprüngliche Array durchlaufen wird. Gleichzeitig ist der Wert dieses Attributs ein Array, das zum Speichern des Typs dieses Attributs verwendet wird. Dadurch können Elemente ähnlich der Zahl 1 und die Elemente der Zeichenfolge „1“ im ursprünglichen Array unterschieden werden. Diese Methode reduziert den Zeitaufwand der indexOf-Methode unter den oben genannten drei Methoden, indem sie ein zusätzliches Objekt erstellt, was als effizienter bezeichnet werden kann.
Wenn Sie mit der oben genannten effizienten Methode, Raum gegen Zeit zu tauschen, zufrieden sind und nicht weiterlesen, dann liegen Sie völlig falsch. Die besten Dinge kommen immer. Jetzt beginnt der Spaß, es besteht kein Zweifel, dass es Code E ist:

 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;
 }

Code D tauscht Raum gegen Zeit und das Gefühl ist nur durchschnittlich. Was ist mit Code E? Ist dieser Code falsch? Kann dies wirklich Duplikate entfernen? Ja, ich habe den Code zunächst nicht verstanden, bis ich die Analyse gelesen und erneut gelesen habe. Dann sollten Leser, die es nicht verstehen, die Analyse sorgfältig lesen: Die erste Ebene durchläuft das ursprüngliche Array von vorne nach hinten, und die Schleife der zweiten Ebene erkennt, ob jedes Element mit dem darauffolgenden Element wiederholt wird , Überspringen Sie es; wenn alle Elemente nach diesem Element eindeutig sind, fügen Sie es dem resultierenden Array hinzu. Die Idee bei der Implementierung dieser Methode besteht darin, den Wert ganz rechts ohne Duplizierung zu erhalten und ihn dem Ergebnisarray hinzuzufügen. Dies optimiert auch die Schleife der zweiten Ebene und ist im Ergebnis effizienter Array dieser Methode Die Reihenfolge der Elemente unterscheidet sich von der Reihenfolge der Elemente im ursprünglichen Array.

Haben Sie nach der Lektüre der Analyse von Code E bereits den Daumen hochgehoben und mich bewundernd angesehen? (Geben Sie mir diese Blumen und Ehrungen nicht, sie sollten an den Meister gehen, der diese Methode geschrieben hat.) Lassen Sie uns über die letzte Methode sprechen: Das heißt, zuerst zu sortieren und dann Duplikate zu entfernen. Nach den alten Regeln heißt es 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;
 } 

Dabei wird zunächst die Array-Sortiermethode sort verwendet, um die Array-Elemente zu sortieren, und dann wird die Duplizierungsarbeit durchgeführt.

Das Obige ist eine Schritt-für-Schritt-Studie zum Problem der Javascript-Array-Deduplizierung Der Code wird ständig verbessert. Ich hoffe, dass jeder fleißig lernt etwas gewinnen.