1. Selon le principe de la clé non répétée de Key dans l'objet JS, la méthode de l'observation du tableau est la suivante selon la pensée la plus conventionnelle:
Copier le code du code comme suit:
Fonction distincte (arr) {
var obj = {}, temp = [];
pour (var i = 0; i <arr.length; i ++) {
if (! obj [arr [i]]) {{{{{
temp.push (arr [i]);
obj [arr [i]] = true;
}
}
Tempère de retour;
}
var testarr = [1,2,3,2];
Console.log (DistinctArray (Testarr));
Il a l'air plutôt bien, mais si cela se transforme en situation:
var testarr1 = [1,2,3, "2"];
Console.log (DistinctArray (Testarr));
Il s'est avéré être le même résultat. .
En réponse à ce qui précède, nous améliorons les méthodes ci-dessus:
Copier le code du code comme suit:
Fonction distinctaRayImprove (arr) {
var obj = {}, temp = [];
pour (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;
}
}
Tempère de retour;
}
La méthode ci-dessus ajoute le préfixe de type de type lorsque la touche est placée dans l'objet, alors voyons l'effet.
var testarr1 = [1,2,3, "2"];
Console.log (distinct (Testarr));
Oups, bien! Cette fonction est donc complètement OK, voyons une autre situation!
var testarr1 = [1,2,3, "2", {a: 1}, {b: 1}];
console.log (distinctRay (Testarr));
Ce résultat, comment supprimer {b: 1} pour le supprimer inexplicablement. .
2. Dans 1 sur 1, notre idée principale est d'utiliser le concept de clé dans l'objet JS pour guider notre réflexion, mais en fin de compte, il n'y a pas de solution à tous les problèmes. Nous voulons.
Utilisez les méthodes de tranche et d'épissage pour atteindre le poids du tableau, comme suit:
Copier le code du code comme suit:
Fonction distanerRay2 (arr) {{
var test = arr.slice (0);
pour (var i = 0; i <temp.length; i ++) {
pour (j = i + 1; j <temp.length; j ++) {
if (temp [j] == temp [i]) {
Temp.splice (J, 1);
J ---;
}
}
}
Tempère de retour;
}
test:
var testarr1 = [1,2,3, "2"];
Console.log (DistinctArray (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");}]
Les résultats des tests ne peuvent toujours pas répondre à nos besoins. Après avoir étudié les méthodes ci-dessus de notre équipe, nous avons constaté que les principaux problèmes sont dans le fonctionnement de la comparaison des deux objets. égal.
Copier le code du code comme suit:
Fonction DistanCerRayall (arr) {
var isEqual = fonction (obj1, obj2) {{
// Deux objets sont égaux et ils doivent être égaux.
if (obj1 === obj2) {{{
Retour Vrai;
}
if (typeof (obj1) == typeof (obj2)) {{
if (ibj1) == "objet" && typeof (obj2) == "objet") {{
var pcount = 0;
pour (var p dans obj1) {
pcount ++;
if (! isEqual (obj1 [p], obj2 [p]) {{
Retourne false;
}
}
pour (var p dans obj2) {
pCount-;
}
Return pcount == 0;
} Else if (typeof (obj1) == "fonction" && typeof (obj2) == "fonction") {
if (obj1.toString () !! = obj2.toString ()) {
Retourne false;
}
} Autre {
if (obj1! = obj2) {{
Retourne false;
}
}
} Autre {
Retourne false;
}
Retour Vrai;
}
var test = arr.slice (0);
pour (var i = 0; i <temp.length; i ++) {
pour (j = i + 1; j <temp.length; j ++) {
ifqual (temp [j], temp [i]) {{) {{
Temp.splice (J, 1);
J ---;
}
}
}
Tempère de retour;
}
test:
var testarr3 = [1,2,2, {a: 1}, {a: 1}, {a: 1, b: 2}, function () {alert ("b");}, function () {alert ("b");}] ;;
console.log (distinctArrayall (TestArr3));
// Résultats [1,2, {a: 1}, {a: 1, b: 2}, function () {alert ("b");}]
Oups, finalement terminé avec succès la tâche de poids lourd. Nous pouvons voir que la dernière méthode est de souligner la loi, qui peut être importante pour les tableaux complexes, mais la surcharge d'exécution correspondante est également assez grande. Heavy, ce qui nous oblige à choisir de manière flexible l'algorithme correspondant en fonction des besoins.