2
votes

Création d'objets à partir de tableaux avec des valeurs répétitives

J'ai un tableau avec des valeurs répétitives:

[ ['Deer Skin', 1], ['Bear Skin', 1], ['Deer Skin', 1], ['Cougar Skin', 2] ... ]

Je veux les comparer par la valeur sting de index [0] et supprimer les doublons tout en stockant le résultat dans un nouvel objet.

Les valeurs résultantes ressembleraient à:

[
{name: "Deer Skin", quantity: 0}
{name: "Bear Skin", quantity: 0}
{name: "Cougar Skin", quantity: 0}
...

Je ne sais pas trop comment procéder à partir de là. À l'heure actuelle, j'ai un tableau d'objets avec toutes les valeurs de tableau en double initiales supprimées:

[ {name: 'Deer Skin', quantity: 4}, {name: 'Bear Skin', quantity: 5}, {name: 'Cougar Skin', quantity: 4} ... ]

Mais je ne comprends pas comment je peux mapper les valeurs de:

XXX

à l'objet ci-dessus.

javascript object arrays

3 commentaires

Vous ne devez rien cartographier. Effectuez simplement une itération sur le tableau et ajoutez la valeur de élément [1] à obj [élément [0]] .

@FelixKling Cela fonctionnerait-il avec la valeur de l'élément? Je pense que obj ['Deer Skin'] n'existe pas.

voir sous "Unique par ...", rubrique stackoverflow.com/a/9229821/2096695

3 Réponses :

0
votes

Puisque vous n'avez pas mentionné la structure du nouvel objet dans lequel vous allez stocker les uniques, vous pouvez faire quelque chose comme ceci:

deduplicatedObj = {
    'Deer Skin': 2,
    'Bear Skin': 1,
    'Cougar Skin': 2
}

Puisque vous stockez la valeur dans un objet, et un objet ne peut avoir que des clés uniques, lorsque vous attribuez item [1] à deduplicatedObj [item [0]] , il écrasera le préexistant valeur le cas échéant.

Le deduplicatedObj ressemblera à quelque chose comme ceci:

const arrayItems = [ ['Deer Skin', 1], ['Bear Skin', 1], ['Deer Skin', 2], ['Cougar Skin', 2] ... ];
const deduplicatedObj = {};

for(let item of arrayItems){
    deduplicatedObj[item[0]] = item[1];
}

console.log(deduplicatedObj); // This should be an object with key as 'Deer Skin' and value as 1, and so on.

0 commentaires

2
votes

Vous pouvez utiliser .reduce pour y parvenir. Ici, j'ai initialisé l'accumulateur ( acc ) pour être un objet vide {} . Au fur et à mesure que le tableau est itéré, l'opérateur ternaire décide s'il faut ajouter la quantité à la valeur courante de la clé ( elem [0] ) (nous ajoutons seulement si nous l'avons vu auparavant - si nous avons essayé de ajouter à quelque chose que nous n'avions pas vu avant que nous obtenions NaN comme valeur) ou s'il fallait créer une nouvelle paire clé-valeur (si nous n'avons pas vu la valeur de clé auparavant).

Voir l'exemple de travail ci-dessous:

const arr = [
  ['Deer Skin', 1],
  ['Bear Skin', 1],
  ['Deer Skin', 1],
  ['Cougar Skin', 2]
];

const res = arr.reduce((acc, elem) => {
  elem[0] in acc ? acc[elem[0]] += elem[1] : acc[elem[0]] = elem[1];
  return acc;
}, {});

console.log(res);

2 commentaires

Ceci est exactement ce que je cherchais. Merci pour l'explication!

@KylePfahler pas de soucis: D

1
votes

Utilisation de Object.entries, array.reduce et de la déstructuration de tableaux:

const data = [
  ['Deer Skin', 1],
  ['Bear Skin', 1],
  ['Deer Skin', 1],
  ['Cougar Skin', 2]
];

const reduceData = (data) => data.reduce((acc, [key, count]) => {
  if (!acc[key]) acc[key] = 0; // If key doesn't exist yet, add and set count to zero
  acc[key] += count;
  return acc;
}, {});

console.log(reduceData(data));

// But if you want an array, use Object.entries
console.log(Object.entries(reduceData(data)));

0 commentaires