1. Nach dem Prinzip des nicht wiederholten Schlüssels von Key im JS -Objekt lautet die Methode des Angeklagten das Array nach dem konventionellsten Denken:
Kopieren Sie den Code -Code wie folgt:
Funktion DISTEMENTARARAY (arr) {
var obj = {}, temp = [];
für (var i = 0; i <arr.length; i ++) {
if (! obj [arr [i]]) {{{{
temp.push (arr [i]);
obj [arr [i]] = true;
}
}
Temperatur zurückgeben;
}
var testarr = [1,2,3,2];
console.log (DifferentArray (testarr));
Es sieht ziemlich gut aus, aber wenn es sich in eine Situation verwandelt:
var testarr1 = [1,2,3, "2"];
console.log (DifferentArray (testarr));
Es stellte sich heraus, dass dies das gleiche Ergebnis ist. .
Als Reaktion auf das oben genannte verbessern wir die oben genannten Methoden:
Kopieren Sie den Code -Code wie folgt:
Funktion DesticleArrayImprove (arr) {
var obj = {}, temp = [];
für (var i = 0; i <arr.length; i ++) {
if (! obj [typeof (arr [i])+arr [i]) {) {
temp.push (arr [i]);
obj [typeof (arr [i])+arr [i]] = true;
}
}
Temperatur zurückgeben;
}
Die obige Methode fügt das Präfix von Typeof hinzu, wenn der Schlüssel in das Objekt eingebaut wird. Sehen Sie also den Effekt an.
var testarr1 = [1,2,3, "2"];
console.log (DifferentArray (testarr));
Hoppla, gut! Ist diese Funktion also völlig in Ordnung, schauen wir uns eine andere Situation an!
var testarr1 = [1,2,3, "2", {a: 1}, {b: 1}];
console.log (condentArray (testarr));
Dieses Ergebnis löschen Sie {B: 1}, um es unerklärlicherweise zu löschen. .
2. In 1 zu 1 ist unsere Hauptidee, das Konzept des Schlüssels im JS -Objekt zu verwenden, um unser Denken zu leiten, aber am Ende gibt es keine Lösung für alle Probleme. Wir wollen
Verwenden Sie die Scheiben- und Spleißmethoden, um das Gewicht des Arrays wie folgt zu erreichen:
Kopieren Sie den Code -Code wie folgt:
Funktion Distanzerray2 (arr) {{{{
var test = arr.slice (0);
für (var i = 0; i <temp.length; i ++) {
für (j = i+1; j <temp.length; j ++) {
if (temp [j] == temp [i]) {
temp.SPLICE (j, 1);
J ---;
}
}
}
Temperatur zurückgeben;
}
prüfen:
var testarr1 = [1,2,3, "2"];
console.log (DifferentArray (testarr));
var testarr2 = [1,2,2, {a: 1}, {a: 1}, {a: 1, b: 2}, function () {alert ("b");}, function () {alert ("B");}];;
// [1,2, {a: 1}, {a: 1}, {a: 1, b: 2}, function () {alert ("b");}, function () {alert ("B (" B ");}]
Die Testergebnisse können unsere Bedürfnisse immer noch nicht erfüllen. Nachdem wir die oben genannten Methoden unseres Teams untersucht haben, fanden wir, dass die Hauptprobleme bei der Vergleich der beiden Objekte in DistributionArray2 "" "" "" "" "" "" " In Anbetracht dieser Situation können wir, wir, wir, wir, wir können eine andere Methode:
Kopieren Sie den Code -Code wie folgt:
Funktion Distanzerrayall (arr) {
var isequal = function (obj1, obj2) {{{{{{{{
// Zwei Objekte sind gleich und sie müssen gleich sind.
if (obj1 === obj2) {{{{{{{{{{{{{{{{{{{{{
Zurückkehren;
}
if (typeof (obj1) == typeof (obj2)) {{{{{{
if (ibj1) == "Objekt" && typeof (obj2) == "Objekt") {{{{{{{
var pcount = 0;
für (var p in obj1) {
pcount ++;
if (! isequal (obj1 [p], obj2 [p]) {{{{{{{{{{{{
False zurückgeben;
}
}
für (var p in obj2) {
pcount-;
}
Return pcount == 0;
} Else if (typeof (obj1) == "Funktion" && typeof (obj2) == "Funktion") {
if (obj1.tostring () !! = obj2.toString ()) {
False zurückgeben;
}
} Anders {
if (obj1! = obj2) {{{{{{{{{{{{{{{{{{{
False zurückgeben;
}
}
} Anders {
False zurückgeben;
}
Zurückkehren;
}
var test = arr.slice (0);
für (var i = 0; i <temp.length; i ++) {
für (j = i+1; j <temp.length; j ++) {
ifqual (temp [j], temp [i]) {{) {{{{{{{
temp.SPLICE (j, 1);
J ---;
}
}
}
Temperatur zurückgeben;
}
prüfen:
var testarr3 = [1,2,2, {a: 1}, {a: 1}, {a: 1, b: 2}, function () {alert ("b");}, function () {alert ("B");}];;
console.log (desticalArrayall (testarr3));
// Ergebnisse [1,2, {a: 1}, {a: 1, b: 2}, function () {alert ("b");}]
Hoppla, schließlich erfolgreich die Aufgabe des schweren Gewichts. Wir können sehen, dass die letzte Methode darin besteht, das Gesetz zu betonen, das für komplexe Arrays wichtig sein kann, aber der entsprechende Ausführungsaufwand ist auch ziemlich groß. Schwere, dass wir den entsprechenden Algorithmus entsprechend den Bedürfnissen flexibel wählen müssen.