JavaScript-Arrays auf unserer täglichen Entwicklung konzentrieren kann, wie sehr häufiges Problem beschrieben wird, so ist die Frage? Alle wie eine Reihe von Problemen, den starken Belastung, welche Methoden zu lösen?
1, vorbehaltlich der Gewichtsmethode
Ein Verfahren, als ich begann, JS zu lernen, kann diese Methode Anfänger erste Lösung gedacht, weil nach den Objektattributen werden überschreiben, wenn das gleiche Objekt, wodurch die Anwesenheit der gleichen Elemente des Urteils zu verwenden.
const unique = (arr) => {
let map = {};
let res = [];
for (let i = 0; i < arr.length; i++) {
if (!map[arr[i]]) {
map[arr[i]] = 1;
res.push(arr[i]);
}
}
return res;
}
2 zu verwenden, schweren indexOf
IndexOf Prinzip des Verfahrens ist auch sehr einfach zu schwer, aber in Übereinstimmung mit der Array-Index-Array-Speicher bestimmt werden, wenn die Existenz dieses Elements, das das Elements gibt, das bereits wiederholt wird, keinen Zugang so.
const unique = (arr) => {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (res.indexOf(arr[i]) < 0) {
res.push(arr[i]);
}
}
return res;
}
3, und mit Hilfe der Indexwert-Bestimmungs indexOf
IndexOf zu Richter verwendet wird, gemäß dem Beurteilungsindex indexOf mit dem aktuellen Wert des Index vorgenommen, wenn der Wert-Index und die Indexwerte nicht gleich sind, was die Anwesenheit von sich wiederholenden Elemente können entfernt werden.
const unique = (arr) => {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (arr.indexOf(arr[i]) == i) {
res.push(arr[i]);
}
}
return res;
}
4, und mit Hilfe der Indexwert-Bestimmungs lastIndexOf
Und nach einem ähnlichen Prinzip, sondern nutzen
const unique = (arr) => {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (arr.lastIndexOf(arr[i]) == i) {
res.push(arr[i]);
}
}
return res;
}
5, die Anzahl der Round-Robin-zweiundzwanzig
Ein Zyklus unter Verwendung von zwei benachbarten Bestimmt, ob die Anzahl der Wiederholungen (im Voraus das Array zu sortieren), wenn die Wiederholung entfernt
const unique = (arr) => {
let res = [];
// 需要先排序
arr.sort((a, b) => a - b);
res[0] = arr[0];
for (let i = 1; i < arr.length; i++) {
if (arr[i] !== arr[i - 1]) {
res.push(arr[i]);
}
}
return res;
}
6, umfaßt das Verfahren die Verwendung eines Arrays (A New Method für ES6)
Das schließt ein Verfahren zur Bestimmung, ob es vorübergehend in dem Array gespeichert ist, wenn es nicht notwendig ist hinzuzufügen
const unique = (arr) => {
let res = [];
for (let i = 0; i < arr.length; i++) {
if (!res.includes(arr[i])) {
res.push(arr[i]);
}
}
return res;
}
7, eine Anordnung der Filterfunktion bestimmt + indexOf
Das Verfahren zur Filteranordnung verwendet, wird durchlaufen, und auch der Indexwert, um zu beurteilen indexOf
const unique = (arr) => {
return arr.filter((item, index, _arr) => {
return _arr.indexOf(item) === index;
})
}
8, Splice Deduplizierung
Durch Spleiß Reihe von Methoden direkt auf dem ursprünglichen Array werden, um Notiz geändert, dass, wenn Sie nicht das ursprüngliche Array ändern, dann müssen Sie eine Kopie, und dann auf das Verfahren kann sein
const unique = (arr) => {
arr.sort((a, b) => a - b);
for (let i = 0; i < arr.length - 1; i++) {
if (arr[i + 1] === arr[i]) {
arr.splice(i, 1);
i--;
}
}
return arr;
}
9, die Datenstruktur auf Wiederverwendung der Karte
Deduplizierung kann mit dem Betrieb von Nicht-Wiederholbarkeit Karte nach durchgeführt werden, aber das erfordert einen gewissen Gedächtnisverlust.
const unique = (arr) => {
let res = [];
let map = new Map();
for (let i = 0; i < arr.length; i++) {
if (!map.has(arr[i])) {
res.push(arr[i]);
map.set(arr[i], true);
}
}
return res;
}
10, den Einsatz von Schwer (Neue Methode für ES6) zu reduzieren,
Code ist einfach, wenn Sie nicht vertraut mit dem Verfahren sind reduzieren kleine Partner bei dieser Methode suchen lernen können, diese Methode ist gut, wenn in der Tat von großem Nutzen.
const unique = (arr) => {
return arr.reduce((prev, cur) => prev.includes(cur) ? prev : [...prev, cur], []);
}
11, die Datenstruktur auf Wiederverwendung der Set
Dies kann Verfahren nach dem ES6, einfach und bequem, einfach zu bedienen, eine kleine Menge an Code neu lernen, verwendet werden,
const unique = (arr) => {
return [...new Set(arr)];
}
Wenn die Notwendigkeit der Wieder komplexe Strukturen wie ein Array von Wörtern kann auch zur Wieder Struktur Set verwendet werden
let arr = [1, {a: 1, b: 2}, [1, 2, 3], {a: 1, b: 2}, [1, 2, 3]
const unique = (arr) => {
return [...new Set(arr.map(item => JSON.stringify(item)))].map(item => JSON.parse(item));
}
Code ist oben nur für einfachen Array Betrieb Deduplizierung
in den letzten geschrieben
Da mehr Methoden, so können wir verschiedene Methoden verwenden, nach unterschiedlichen Szenarien, Zeitkomplexität und Raum Komplexität solcher oft müssen in Betracht gezogen werden. Wird nach den unterschiedlichen Bedürfnissen für Raum-Zeit oder Raum für Zeit ausgewählt.
Ich hoffe, Sie lernen etwas! Ah verstehe immer noch nicht, den Punkt des Wissens, und es schnell lernen!
