Supposons que nous ayons cet ensemble de données:

var array = [
                {

                        "name": "a",
                        "group": "a"
                },
                {
                        "name": "a",
                        "group": "a"
                },{
                        "name": "b",
                        "group": "b"
                },
                {
                        "name": "b",
                        "group": "b"
                },
                {
                        "name": "c"
                }
            ];

Et je veux parcourir le tableau pour voir s'il y a deux objets ayant la même valeur de groupe, puis supprimer le second d'entre eux.

for(var i = 0 ; i<array.length;i++){
                var a = array[i];
                for(var j = 0; j< array.length;j++){
                    if(array[j].group == a.group){
                        var b = array[j];
                        // I need code here to remove property "group" from the variable b only
                        break;
                    }
                }
            }

Les résultats finaux que je veux sont:

var array2 = [
                {
                    "name": "a",
                    "group": "a"
                },
                {
                    "name": "a"
                },{
                    "name": "b",
                    "group": "b"
                },
                {
                    "name": "b"
                },{
                    "name":"c"
                }                    
            ];

REMARQUE: j'ai essayé delete array[j].group mais cela a provoqué la suppression de la propriété group des deux objets égaux. Comment puis-je résoudre cela?

0
Hala Ba 9 août 2016 à 13:07

6 réponses

Meilleure réponse

Vous ne devez pas comparer les mêmes éléments, il suffit de déplacer les index dans la boucle interne:

 var array = [{"name": "a", "group": "a"},
             {"name": "a", "group": "a"},
             {"name": "b", "group": "b"},
             {"name": "b", "group": "b"},
             {"name": "c"}];


for(var i = 0 ; i < array.length - 1; i++){
  var a = array[i];
  if(!a.group){
    continue;
  }

  for(var j = i+1; j < array.length; j++){
    var b = array[j];
    if(b.group === a.group){
      delete b.group;
    }
  }
}

console.log(array)
2
Aleksey L. 9 août 2016 à 10:31

Enregistrez simplement toutes les valeurs de groupe que vous avez déjà vues et supprimez-les si vous les revoyez. De plus, cela vous fera économiser une boucle.

var myArray = [...];

var existingGroups = [];

myArray.forEach(function(item){
    if(item.group){
        if(existingGroups.indexOf(item.group) === -1)
            existingGroups.push(item.group);
    else
        delete item.group;
    }
});
1
nioKi 9 août 2016 à 10:14

Vous n'avez pas besoin de boucles imbriquées pour ce faire. Vous pouvez utiliser .forEach() tout en gardant une trace des groupes rencontrés jusqu'à présent. Cela peut être fait en utilisant le paramètre facultatif thisArg ou une variable explicite.

Par exemple:

var array = [
  { "name": "a", "group": "a" },
  { "name": "a", "group": "a" },
  { "name": "b", "group": "b" },
  { "name": "b", "group": "b" },
  { "name": "c" }
];

var grp = {};

array.forEach(function(o) {
  grp[o.group] ? delete o.group : grp[o.group] = true;
});

console.log(array);
0
Arnauld 9 août 2016 à 11:17

Voici un code simple qui pourrait vous aider:

var groups = {};
array.forEach(function(o) {
  if (groups[o.group]) {
    delete o.group;
  } else {
    groups[o.group] = true;
  }
})

Vous pouvez également utiliser une approche plus fonctionnelle, mais vous aurez besoin d'une bibliothèque d'utilitaires supplémentaire ou devrez implémenter certaines des méthodes vous-même.

var groups = array.map(function(o) { return o.group; }).unique();

groups
  .map(function(group) {
    return array.filter(function(o) { o.group == group }).slice(1);
  })
  .flatten()
  .forEach(function(o) { delete o.group });

Aplatir et unique ne sont pas inclus dans les spécifications JavaScript.

0
vbuhlev 9 août 2016 à 10:22

Vous pouvez essayer ceci:

var tmpObj = {};
tmpObj.name = array[j].name;
array.splice(j, 1, tmpObj);

Il doit supprimer l'élément avec l'index j et ajouter un nouvel objet avec seulement un nom.

1
Bünyamin Sarıgül 9 août 2016 à 10:12

J'irais avec une approche différente:

Petite explication de la condition if:

array.slice(0, i): nous ne prenons que les éléments précédents du tableau.

.filter(v => v.group === val.group) nous voyons s'ils ont la même valeur pour la propriété groupe .

.length === 0) S'il y a au moins un élément avec la même valeur de groupe, nous n'entrons pas le if et ne retournons que le nom, sinon nous retournons la valeur elle-même

var array = [{"name": "a", "group": "a"},
             {"name": "a", "group": "a"},
             {"name": "b", "group": "b"},
             {"name": "b", "group": "b"},
             {"name": "c"}];

array = array.map((val, i) => {
  if (array.slice(0, i).filter(v => v.group === val.group).length === 0) {
    return val;
  }
  return {name: val.name};
})

console.log(array)
1
rpadovani 9 août 2016 à 10:29