Dieser Artikel gibt Ihnen hauptsächlich eine Zusammenfassung der JS-Array-Deduplizierungsmethoden. Ich hoffe, dass er allen helfen kann.
Der einfachste Weg:
?
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
var arr=[2,8,5,0,5,2,6,7,2];
function unique1(arr){
var hash=[] ;
for (var i = 0; i < arr.length; i++) {
if(hash.indexOf(arr[i])==-1){
hash.push(arr[ i]);
}
}
return hash;
} |
Methode 1:
Zweistufige Schleife, äußeres Schleifenelement, Wert vergleichen, wenn innere Schleife
Falls vorhanden Wenn die Werte gleich sind, werden sie übersprungen. Wenn sie nicht gleich sind, werden sie in das Array verschoben >5
67
89
10
11
12
13
14
15
16
17
18
Array.prototype.distinct = function(){
var arr = this,
result = [],
i,
j,
len = arr.length;
for(i = 0; i < len; i++){
for(j = i + 1; j < len; j++){
if(arr[i] === arr[j]){
j = ++i;
}
}
result.push(arr[i]);
}
return result;
}
var arra = [1,2,3,4,4,1,1,2,1,1,1];
arra.distinct();
|
Methode 2: Verwenden Sie Spleiß, um direkt am ursprünglichen Array zu arbeiten
Doppelschichtige Schleife, äußeres Schleifenelement, innerer Schleifenvergleichswert
Wenn die Werte gleich sind, löschen Sie diesen Wert
Hinweis: Nach dem Löschen des Elements müssen Sie die Länge des Arrays um 1 reduzieren.
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
Array.prototype.distinct = function (){
var arr = this,
i,
j,
len = arr.length;
for(i = 0; i < len; i++){
for(j = i + 1; j < len; j++){
if(arr[i] == arr[j]){
arr.splice(j,1);
len--;
j--;
}
}
}
return arr;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString());
|
Vorteile: einfach und leicht verständlich
Nachteile: hoher Speicherverbrauch und langsame Geschwindigkeit
Methode 3: Nutzen Sie die Eigenschaften von Objekten, die nicht gleich sein können deduplizieren
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Array.prototype.distinct = function (){
var arr = this,
i,
obj = {},
result = [],
len = arr.length;
for(i = 0; i< arr.length; i++){
if(!obj[arr[i]]){
obj[arr[i]] = 1;
result.push(arr[i]);
}
}
return result;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString());
|
Methode 4: Rekursive Deduplizierung von Arrays
Verwenden Sie die Idee der Rekursion
Erst sortieren und dann am Ende vergleichen , wenn Sie auf dasselbe stoßen, dann löschen Sie
?
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
Array.prototype.distinct = function (){
var arr = this,
len = arr.length;
arr.sort(function(a,b){
return a - b;
})
function loop(index){
if(index >= 1){</span></strong></span></span></p>
<p class="line number9 index8 alt2" style="line-height:15.4px;margin:0px;padding:0px 1em;background-image:none;border:0px;float:none;height:auto;vertical-align:baseline;width:auto;min-height:auto;white-space:pre;"><code class="js spaces" style="margin:3px auto 0px;padding:0px 0px 0px 5px;background:rgb(255,255,255);border-left:3px solid rgb(108,226,108);width:640px;font-size:14px;clear:both;border-top:0px;border-right:0px;border-bottom:0px;float:none;height:auto;vertical-align:baseline;font-family:Consolas, 'Bitstream Vera Sans Mono', 'Courier New', Courier, monospace;min-height:auto;"> if(arr[index] === arr[index-1]){
arr.splice(index,1);
}
loop(index - 1);
}
}
loop(len-1);
return arr;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,56,45,56];
var b = a.distinct();
console.log(b.toString());
|
Methode 5: Verwenden Sie indexOf und forEach
?
| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
Array.prototype.distinct = function (){
var arr = this,
result = [],
len = arr.length;
arr.forEach(function(v, i ,arr){
var bool = arr.indexOf(v,i+1);
if(bool === -1){
result.push(v);
}
})
return result;
};
var a = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,3,2,3,3,2,2,1,23,1,23,2,3,2,3,2,3];
var b = a.distinct();
console.log(b.toString());
|
Methode 6: Verwenden Sie den Satz von ES6
Festlegen Sie die Datenstruktur, die einem Array ähnelt, und die Werte seiner Mitglieder sind alle eindeutig.
Verwenden Sie Array.from, um die Set-Struktur in ein Array umzuwandeln
?
|
1
2
3
4
|
function dedupe(array){
return Array.from(new Set(array));
}
dedupe([1,1,2,3])
|
Der Spread-Operator (...) verwendet intern die for...of-Schleife
?
|
1
2
3
|
let arr = [1,2,3,3];
let resultarr = [...new Set(arr)];
console.log(resultarr);
|
Das Folgende ist eine ergänzende Einführung in die Methode zum Zusammenführen von Arrays und Entfernen von Duplikaten
1. concat()-Methode
Idee: Die Methode concat() kombiniert den eingehenden Array- oder Nicht-Array-Wert mit dem ursprünglichen Array zu einem neuen Array und gibt es zurück. Diese Methode generiert ein neues Array.
|
1
2
3
4
5
|
function concatArr(arr1, arr2){
var arr = arr1.concat(arr2);
arr = unique1(arr);
return arr;
}
|
2. Array.prototype.push.apply()
Idee: Der Vorteil dieser Methode besteht darin, dass kein neues Array generiert wird.
?
|
1
2
3
4
5
6
7
8
9
10
|
var a = [1, 2, 3];
var b = [4, 5, 6];
Array.prototype.push.apply(a, b);
function concatArray(arr1,arr2){
Array.prototype.push.apply(arr1, arr2);
arr1 = unique1(arr1);
return arr1;
|
Verwandte Empfehlungen:
Detaillierte Erklärung zum Beispiel für die JS-Array-Deduplizierung
Gemeinschaft von sechs Methoden zum Entfernen von Duplikaten aus JS-Arrays
Gemeinschaft von mehreren Methoden zum Entfernen von Duplikaten aus JavaScript-Arrays
Das obige ist der detaillierte Inhalt vonZusammenfassung der JS-Array-Deduplizierungsmethoden. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
