Obtenir la clé d'un objet JavaScript

Utilisez Object.keys(obj) pour obtenir un tableau des noms des propriétés propres énumérables de type chaîne d’un objet. Choisissez Object.entries(obj) lorsque chaque clé doit rester associée à sa valeur. Ces deux méthodes ne modifient pas l’objet. Pour parcourir aussi des propriétés énumérables héritées, utilisez for...in et filtrez les propriétés propres si votre tâche l’exige.

Obtenir les clés d’un objet avec Object.keys()

Object.keys() renvoie un tableau de clés propres énumérables de type chaîne. Cette méthode est utile lorsque les noms des propriétés ne sont pas connus à l’avance, par exemple pour traiter un enregistrement renvoyé par une API. Le tableau ne contient que les noms ; pour lire une valeur, utilisez obj[key]. Si un objet ne possède aucune propriété propre énumérable de type chaîne, le résultat est un tableau vide. Les propriétés symboliques ne sont pas incluses.

L’ordre des propriétés est défini, mais ne correspond pas toujours à celui dans lequel les clés ont été écrites. Les clés d’indices de tableau — chaînes représentant des indices entiers canoniques de 0 à 4294967294 — apparaissent d’abord, par ordre numérique croissant. Les autres clés de type chaîne suivent dans leur ordre de création. Une chaîne comme "01" n’est pas un indice de tableau : elle reste donc parmi les autres clés de type chaîne. Le même principe s’applique aux tableaux : Object.keys() renvoie sous forme de chaînes leurs indices présents et énumérables, et non leurs valeurs.

Exécutez cet exemple :

const record = { 4: 'pear', 2: 'mango', name: 'fruit', '01': 'label' };
const keys = Object.keys(record);
console.log(keys);
console.log(record[keys[0]]);
console.log(Object.keys(['red', 'blue']));

Cet exemple place les clés d’indices numériques avant les autres chaînes, garde "01" parmi les clés de type chaîne ordinaires et utilise une clé renvoyée pour accéder à sa valeur. L’obtention des clés ne réordonne ni ne réécrit les propriétés de record.

Obtenir les clés et les valeurs d’un objet avec Object.entries()

Utilisez Object.entries(obj) lorsque l’étape suivante nécessite chaque clé avec la valeur correspondante. La méthode renvoie un tableau de sous-tableaux à deux éléments, de la forme [[key, value], ...]. Comme Object.keys(), elle inclut uniquement les propriétés propres énumérables de type chaîne de l’objet, conserve le même ordre et exclut les symboles. Elle ne parcourt pas récursivement les valeurs qui sont elles-mêmes des objets.

La déstructuration facilite le traitement de chaque paire. L’exemple complet suivant affiche un libellé et la valeur de chaque propriété :

const settings = { theme: 'dark', language: 'English' };
for (const [key, value] of Object.entries(settings)) {
  console.log(`${key}: ${value}`);
}

Choisissez Object.keys() si les noms seuls suffisent, et Object.entries() si la boucle a besoin des noms et des valeurs ensemble. Si vous connaissez déjà une clé, inutile d’énumérer l’objet : accédez directement à la valeur avec settings.theme ou settings['theme'].

Parcourir les clés d’un objet avec for…in

Une boucle for...in parcourt les propriétés énumérables de type chaîne. Elle peut aussi inclure des propriétés héritées via le prototype de l’objet ; ses résultats peuvent donc différer de ceux de Object.keys(), qui ne liste que les propriétés propres. Pour exclure les propriétés héritées, utilisez Object.hasOwn(obj, key) dans la boucle. Cette méthode est disponible dans les versions modernes de JavaScript ; dans les environnements plus anciens, utilisez Object.prototype.hasOwnProperty.call(obj, key).

const parent = { category: 'fruit' };
const item = Object.create(parent);
item.name = 'mango';

for (const key in item) {
  if (Object.hasOwn(item, key)) {
    console.log(`${key}: ${item[key]}`);
  }
}

La boucle peut rencontrer à la fois name et la propriété héritée category, tandis que la vérification des propriétés propres n’affiche que name. Pour parcourir toutes les propriétés énumérables, omettez cette vérification. Pour obtenir une liste prévisible des clés propres énumérables de type chaîne d’un objet, Object.keys() est généralement le choix le plus clair.

L’énumération est superficielle. Si une propriété de premier niveau contient un autre objet, la liste de clés contient le nom de cette propriété, et sa valeur reste cet objet imbriqué. Pour lister les clés imbriquées, appelez séparément Object.keys() sur cette valeur ; un parcours récursif nécessite une logique supplémentaire pour visiter chaque objet imbriqué. Choisissez parmi ces trois approches selon les propriétés dont vous avez besoin : Object.keys() pour les noms, Object.entries() pour les paires nom-valeur, et for...in pour les propriétés énumérables présentes dans la chaîne de prototypes.