Objet.clés, valeurs, entrées

Laissons de côté les structures de données individuelles et parlons des itérations sur celles-ci.

Dans le chapitre précédent, nous avons vu les méthodes map.keys() , map.values() , map.entries() .

Ces méthodes sont génériques, il existe un accord commun pour les utiliser pour les structures de données. Si jamais nous créons notre propre structure de données, nous devrions également la mettre en œuvre.

Ils sont pris en charge pour :

• Map

• Set

• Array

Les objets simples prennent également en charge des méthodes similaires, mais la syntaxe est un peu différente.

Objet.clés, valeurs, entrées

Pour les objets simples, les méthodes suivantes sont disponibles :

• Object.keys(obj) – renvoie un tableau de clés.

• Object.values(obj) – renvoie un tableau de valeurs.

• Object.entries(obj) – renvoie un tableau de paires [key, value] .

Attention aux distinctions (par rapport à la carte par exemple) :

La première différence est que nous devons appeler Object.keys(obj) , et non obj.keys() .

Pourquoi ? La principale raison est la flexibilité. N'oubliez pas que les objets constituent la base de toutes les structures complexes en JavaScript. Nous pouvons donc avoir notre propre objet, comme data , qui implémente sa propre méthode data.values() . Et nous pouvons toujours appeler Object.values(data) dessus.

La deuxième différence est que les méthodes Object.* renvoient des objets tableau « réels », pas seulement un itérable. C'est principalement pour des raisons historiques.

Par exemple:

 laissez l'utilisateur = {
  nom : "Jean",
  âge : 30 ans
} ;

• Object.keys(user) = ["name", "age"]

• Object.values(user) = ["John", 30]

• Object.entries(user) = [ ["name","John"], ["age",30] ]

Voici un exemple d'utilisation de Object.values ​​pour parcourir les valeurs de propriété :

 laissez l'utilisateur = {
  nom : "Jean",
  âge : 30 ans
} ;

// boucle sur les valeurs
for (laisser la valeur de Object.values ​​(user)) {
  alerte (valeur); // Jean, alors 30 ans
}

Object.keys/values/entries ignore les propriétés symboliques

Tout comme une boucle for..in , ces méthodes ignorent les propriétés qui utilisent Symbol(...) comme clés.

Habituellement, c'est pratique. Mais si nous voulons également des clés symboliques, il existe une méthode distincte Object.getOwnPropertySymbols qui renvoie un tableau de clés symboliques uniquement. Il existe également une méthode Reflect.ownKeys(obj) qui renvoie toutes les clés.

Transformer des objets

Les objets manquent de nombreuses méthodes qui existent pour les tableaux, par exemple map , filter et autres.

Si nous souhaitons les appliquer, nous pouvons utiliser Object.entries suivi de Object.fromEntries :

1. Utilisez Object.entries(obj) pour obtenir un tableau de paires clé/valeur à partir de obj .

2. Utilisez des méthodes de tableau sur ce tableau, par exemple map , pour transformer ces paires clé/valeur.

3. Utilisez Object.fromEntries(array) sur le tableau résultant pour le transformer en objet.

Par exemple, nous avons un objet avec des prix, et nous aimerions les doubler :

 laissez les prix = {
  banane : 1,
  oranges : 2,
  viande : 4,
} ;

laissez doublePrices = Object.fromEntries (
  // convertit les prix en tableau, mappe chaque paire clé/valeur dans une autre paire
  // puis fromEntries rend l'objet
  Object.entries(prices).map(entry => [entry[0], input[1] * 2])
);

alerte (doublePrices.meat); // 8

Cela peut paraître difficile à première vue, mais devient facile à comprendre après l'avoir utilisé une ou deux fois. Nous pouvons ainsi créer de puissantes chaînes de transformations.

Tâches

Additionner les propriétés

importance : 5

Il existe un objet salaries avec un nombre arbitraire de salaires.

Écrivez la fonction sumSalaries(salaries) qui renvoie la somme de tous les salaires en utilisant Object.values ​​et la boucle for..of .

Si salaries est vide, alors le résultat doit être 0 .

Par exemple:

 laissez les salaires = {
  "Jean": 100,
  "Pierre": 300,
  "Marie": 250
} ;

alert( sumSalaries(salaires) ); // 650

Ouvrez un bac à sable avec des tests.

solution

 fonction sommeSalaires(salaires) {

  soit somme = 0 ;
  pour (laisser le salaire de Object.values ​​(salaires)) {
    somme += salaire ;
  }

  retourner la somme ; // 650
}

laissez les salaires = {
  "Jean": 100,
  "Pierre": 300,
  "Marie": 250
} ;

alert( sumSalaries(salaires) ); // 650

Ou, éventuellement, nous pourrions également obtenir la somme en utilisant Object.values ​​et reduce :

 // réduit les boucles sur la gamme de salaires,
// les additionnant
// et renvoie le résultat
fonction sommeSalaires(salaires) {
  return Object.values(salaries).reduce((a, b) => a + b, 0) // 650
}

Ouvrez la solution avec des tests dans un bac à sable.

Compter les propriétés

importance : 5

Écrivez une fonction count(obj) qui renvoie le nombre de propriétés dans l'objet :

 laissez l'utilisateur = {
  nom : « Jean »,
  âge : 30 ans
} ;

alert( count(utilisateur) ); // 2

Essayez de rendre le code aussi court que possible.

PS Ignorez les propriétés symboliques, ne comptez que les propriétés « normales ».

Ouvrez un bac à sable avec des tests.

solution

 fonction compte (obj) {
  return Object.keys(obj).length;
}

Ouvrez la solution avec des tests dans un bac à sable.