Object : méthode hasOwnProperty()

Exemple interactif

const object = {};
object.toto = 42;

console.log(object.hasOwnProperty("toto"));
// Résultat attendu : true

console.log(object.hasOwnProperty("toString"));
// Résultat attendu : false

console.log(object.hasOwnProperty("hasOwnProperty"));
// Résultat attendu : false

Syntaxe

hasOwnProperty(prop)

Paramètres

prop

La chaîne de caractères (String) du nom ou le symbole de la propriété à tester.

Valeur de retour

Retourne true si l'objet possède la propriété définie en tant que propriété directe ; false sinon.

Description

La méthode hasOwnProperty() retourne true si la propriété définie est une propriété directe de l'objet — même si la valeur est null ou undefined. La méthode retourne false si la propriété est héritée ou si elle n'a pas été déclarée. Contrairement à l'opérateur in, cette méthode ne vérifie pas la propriété définie dans la chaîne de prototypes de l'objet.

La méthode peut être appelée sur la plupart des objets JavaScript, car la plupart des objets descendent de Object, et héritent donc de ses méthodes. Par exemple, Array est un Object, donc vous pouvez utiliser la méthode hasOwnProperty() pour vérifier si un indice existe :

const fruits = ["Pomme", "Banane", "Melon", "Orange"];
fruits.hasOwnProperty(3); // true ('Orange')
fruits.hasOwnProperty(4); // false - n'est pas défini

La méthode n'est pas disponible dans les objets où elle est réimplémentée, ou sur les objets avec prototype null (car ceux-ci n'héritent pas de Object.prototype). Des exemples pour ces cas sont donnés ci-dessous.

Exemples

Utiliser hasOwnProperty() pour tester l'existence d'une propriété

Le code suivant montre comment déterminer si l'objet exemple contient une propriété intitulée prop.

const exemple = {};
exemple.hasOwnProperty("prop"); // false

exemple.prop = "existe";
exemple.hasOwnProperty("prop"); // true - 'prop' est définie

exemple.prop = null;
exemple.hasOwnProperty("prop"); // true - la propriété directe existe avec la valeur null

exemple.prop = undefined;
exemple.hasOwnProperty("prop"); // true - la propriété directe existe avec la valeur undefined

Propriétés directes et propriétés héritées

L'exemple suivant illustre la différence entre les propriétés directes et les propriétés héritées à partir de la chaîne de prototypes :

const exemple = {};
exemple.prop = "existe";

// `hasOwnProperty` retourne uniquement true pour les propriétés directes :
exemple.hasOwnProperty("prop"); // true
exemple.hasOwnProperty("toString"); // false
exemple.hasOwnProperty("hasOwnProperty"); // false

// L'opérateur `in` retourne true pour les propriétés directes et héritées :
"prop" in exemple; // true
"toString" in exemple; // true
"hasOwnProperty" in exemple; // true

Parcourir les propriétés d'un objet

L'exemple suivant montre comment parcourir les propriétés énumérables d'un objet sans traiter les propriétés héritées.

const bidule = {
  truc: "stack",
};

for (const nom in bidule) {
  if (bidule.hasOwnProperty(nom)) {
    console.log(`C'est bien la propriété (${nom}). Valeur : ${bidule[nom]}`);
  } else {
    console.log(nom); // toString ou autre chose
  }
}

Notez que la boucle for...in ne parcourt que les éléments énumérables : l'absence de propriétés non énumérables dans la boucle ne signifie pas que hasOwnProperty est elle-même strictement limitée aux éléments énumérables. Vous pouvez parcourir les propriétés non énumérables avec Object.getOwnPropertyNames().

Utiliser hasOwnProperty() en tant que propriété

JavaScript ne protège pas le nom de propriété hasOwnProperty ; un objet qui a une propriété avec ce nom peut retourner des résultats incorrects :

const toto = {
  hasOwnProperty: function () {
    return false;
  },
  truc: "Voici les dragons",
};

toto.hasOwnProperty("truc"); // la ré-implementation retourne toujours false

La manière recommandée pour contourner ce problème est d'utiliser plutôt Object.hasOwn() (dans les navigateurs qui le prennent en charge). D'autres alternatives incluent l'utilisation d'un hasOwnProperty externe :

const toto = { truc: "Voici les dragons" };

// Utilise la méthode Object.hasOwn() - recommandé
Object.hasOwn(toto, "truc"); // true

// Utilise la propriété hasOwnProperty du prototype Object
Object.prototype.hasOwnProperty.call(toto, "truc"); // true

// Utilise le hasOwnProperty d'un autre objet
// et l'appelle avec 'this' défini sur toto
({}).hasOwnProperty.call(toto, "truc"); // true

Notez que dans les deux premiers cas, aucun nouvel objet n'est créé.

Objets créés avec Object.create(null)

Les objets avec prototype null n'héritent pas de Object.prototype, rendant hasOwnProperty() inaccessible.

const toto = Object.create(null);
toto.prop = "existe";
toto.hasOwnProperty("prop"); // Uncaught TypeError: toto.hasOwnProperty is not a function

Les solutions dans ce cas sont les mêmes que pour la section précédente : utilisez de préférence Object.hasOwn(), sinon utilisez le hasOwnProperty() d'un objet externe.

Spécifications

Compatibilité des navigateurs

Voir aussi

• La méthode statique Object.hasOwn()
• Énumérable et rattachement des propriétés
• La méthode statique Object.getOwnPropertyNames()
• L'instruction for...in
• L'opérateur in
• Héritage et chaîne de prototypes