mozilla

Object.defineProperty()

La méthode Object.defineProperty() permet de définir une nouvelle propriété ou de modifier une propriété existante, directement sur un objet. La méthode renvoie l'objet modifié.

Syntaxe

Object.defineProperty(obj, prop, descripteur)

Paramètres

obj
L'objet sur lequel on souhaite définir ou modifier une propriété.
prop
Le nom de la propriété qu'on définit ou qu'on modifie.
descripteur
Le descripteur de la propriété qu'on définit ou qu'on modifie.

Description

Cette méthode permet d'ajouter ou de modifier une propriété d'un objet avec une certaine précision. En effet, quand on ajoute une propriété « normalement » (via une affectation), on crée une propriété dont le comportement par défaut fait qu'elle sera listée dans une énumération de propriétés (par exemple avec une boucle for...in ou via la méthode Object.keys), dont la valeur peut être changée et qui peut être supprimée via delete. La méthode Object.defineProperty()permet de préciser le comportement attendu, potentiellement différent de celui par défaut.

Les descripteurs de propriété existent en deux versions : les descripteurs de données et les descripteurs d'accesseur. Un descripteur de données est une propriété qui possède une valeur et qui peut ou non être accessible en écriture. Un descripteur d'accesseur est une propriété décrite par une paire d'accesseur/mutateur (getter/setter) qui sont des fonctions. Un descripteur est un descripteur de données ou un descripteur d'accesseur, il ne peut pas être les deux.

Les descripteurs de données et d'accesseur sont des objets. Ils partagent les propriétés suivantes :

configurable
true si et seulement si le type de ce descripteur de propriété peut être changé et si la propriété peut/pourra être supprimée de l'objet correspondant..
La valeur par défaut est false.
enumerable
true si et seulement si la propriété apparaît lors de l'énumération des propriétés de l'objet correspondant.
La valeur par défaut est false.

Un descripteur de données possède les propriétés optionnelles suivantes :

value
La valeur associée à la propriété. Peut être n'importe quelle valeur JavaScript valide (un nombre, un objet, etc.).
La valeur par défaut est undefined.
writable
true si et seulement si la valeur associée à la propriété peut être modifiée en utilisant un opérateur d'affectation.
La valeur par défaut est false.

Un descripteur d'accesseur possède les propriétés optionnelles suivantes :

get
Un fonction qui est utilisée comme accesseur (getter) pour la propriété ou bien undefined s'il n'existe pas d'accesseur. La valeur de retour de la fonction sera utilisée comme valeur pour la propriété.
La valeur par défaut est undefined.
set
Une fonction qui est utilisée comme mutateur (setter) pour la propriété ou bien undefined s'il n'existe pas de mutateur. Pour unique argument, la fonction recevra la nouvelle valeur à affecter à la propriété.
La valeur par défaut est undefined.

Il faut garder à l'esprit que ces options ne sont pas nécessairement des propriétés propres. Elles peuvent être héritées. Afin de s'assurer que les valeur par défaut sont préservées, on peut d'abord geler le prototype Object.prototype, définir toutes les options explicitement ou faire pointer la propriété __proto__ vers null.

var obj = {};
// en utilisant __proto__
Object.defineProperty(obj, "clé", {
  __proto__: null, // aucune propriété héritée
  value: "static"  // non énumérable
                   // non configurable
                   // non accessible en écriture
                   // par défaut
});

// en étant explicite
Object.defineProperty(obj, "clé", {
  enumerable: false,
  configurable: false,
  writable: false,
  value: "static"
});

// en recyclant un objet
function avecValeur(valeur) {
  var d = avecValeur.d || (
    avecValeur.d = {
      enumerable: false,
      writable: false,
      configurable: false,
      value: null
    }
  );
  d.value = valeur;
  return d;
}
// ... autres instructions... puis
Object.defineProperty(obj, "clé", avecValeur("static"));

// si la méthode freeze est disponible, on peut empêcher que du code
// ajoute des propriétés (valeur, get, set, enumerable, writable, configurable)
// au prototype d'Object
(Object.freeze||Object)(Object.prototype);

Exemples

Pour plus d'exemples utilisant la méthode Object.defineProperty avec une syntaxe de masque binaire, voir les exemples supplémentaires.

Créer une propriété

Lorsqu'une propriété n'existe pas pour l'objet, Object.defineProperty() créera une nouvelle propriété telle qu'elle est décrite. Certains champs du descripteur peuvent manquer, les valeurs par défaut seront alors utilisées. Tous les booléens ont false pour valeur par défaut. Une propriété définie sans get/set/value/writable est appelée « générique » et « correspond » à un descripteur de données.

var o = {}; // on crée un nouvel objet

// Exemple d'une propriété ajoutée via defineProperty avec un descripteur de données
Object.defineProperty(o, "a", {value : 37,
                               writable : true,
                               enumerable : true,
                               configurable : true});
// la propriété 'a' existe pour l'objet o et vaut 37

// Exemple d'une propriété ajoutée via defineProperty avec un descripteur d'accesseur
var valeurB = 38;
Object.defineProperty(o, "b", {get : function(){ return valeurB; },
                               set : function(nouvelleValeur){ valeurB = nouvelleValeur; },
                               enumerable : true,
                               configurable : true});
o.b; // 38
// la propriété 'b' existe pour l'objet o et vaut 38
// La valeur de o.b est désormais toujours identique à valeurB, sauf si o.b est redéfini

// On ne peut pas mélanger les deux :
Object.defineProperty(o, "conflit", { value: 0x9f91102, 
                                       get: function() { return 0xdeadbeef; } });
// une exception TypeError sera lancée : value n'apparaît que dans les descripteur de données
// get n'apparait que dans les descripteurs d'accesseur

Modifier une propriété existante

Quand une propriété existe d'ores et déjà pour un objet, Object.defineProperty() tentera de modifier la propriété pour qu'elle corresponde aux valeurs indiquées dans le descripteur et à la configuration de l'objet courant. Si l'ancien descripteur avait configurable à  false (la propriété est dite non-configurable), aucun attribut, à l'exception de writable, ne peut être changé. Dans ce cas, il n'est pas possible de changer entre les types de descripteur.

Si une propriété est non-configurable, son attribut writable ne peut être mis qu'à false.

Une exception TypeError peut être levée quand on essaie de modifier des attributs de propriété non-configurables (en dehors de l'attribut writable) sauf dans le cas où les valeurs souhaitées sont les mêmes que les valeurs courantes.

Attribut writable

Lorsque l'attribut writable vaut false pour la propriété, cette dernière n'est plus accessible en écriture. Il est impossible de la réaffecter.

var o = {}; // On crée un nouvel objet

Object.defineProperty(o, "a", { value : 37,
                                writable : false });

console.log(o.a); // inscrit 37 dans les journaux (logs)
o.a = 25; // Aucune exception n'est lancée (on aurait une exception en mode strict,
          // y compris si la valeur souhaitée aurait été la même)
console.log(o.a); // inscrit toujours 37. L'affectation n'a pas fonctionné.

Comme on l'a vu dans l'exemple, essayer de modifier une propriété non accessible en écriture ne la modifie pas. Cela ne rend pas d'erreur non plus (en mode non-strict).

Attribut enumerable

L'attribut de propriété enumerable permet de définir si la propriété est listée avec une boucle for...in et la méthode Object.keys().

var o = {};
Object.defineProperty(o, "a", { value : 1, enumerable:true });
Object.defineProperty(o, "b", { value : 2, enumerable:false });
Object.defineProperty(o, "c", { value : 3 }); // enumerable vaut false par défaut
o.d = 4; // enumerable vaut true par défaut si on définit une propriété en l'affectant

for (var i in o) {    
  console.log(i);  
}
// affiche 'a' et 'd' dans le journal (dans un ordre quelconque)

Object.keys(o); // ["a", "d"]

o.propertyIsEnumerable('a'); // true
o.propertyIsEnumerable('b'); // false
o.propertyIsEnumerable('c'); // false

Attribut configurable

L'attribut configurable permet de contrôler si la propriété peut être supprimée et si les autres attributs de propriété (voir ci-avant), à l'exception de writable, peuvent être modifiés.

var o = {};
Object.defineProperty(o, "a", { get : function(){return 1;}, 
                                configurable : false } );

Object.defineProperty(o, "a", {configurable : true}); // renvoie une TypeError
Object.defineProperty(o, "a", {enumerable : true}); // renvoie une TypeError
Object.defineProperty(o, "a", {set : function(){}}); // renvoie une TypeError (set était non défini avant)
Object.defineProperty(o, "a", {get : function(){return 1;}}); // renvoie une TypeError (bien que le nouveau get soit identique au précédent)
Object.defineProperty(o, "a", {value : 12}); // renvoie une TypeError

console.log(o.a); // log 1
delete o.a; // Rien ne se passe
console.log(o.a); // log 1

Si l'attribut configurable de o.a avait été true, aucune de ces erreurs n'aurait été renvoyée et la propriété aurait été supprimée au final.

Ajouter des propriétés et des valeurs par défaut

Il est toujours important de savoir comment les valeurs par défaut sont appliquées. Le comportement est souvent différent entre une affectation simple et l'utilisation de Object.defineProperty(). Par exemple :

var o = {};

o.a = 1;
// est équivalent à :
Object.defineProperty(o, "a", {value : 1,
                               writable : true,
                               configurable : true,
                               enumerable : true});


// D'un autre côté,
Object.defineProperty(o, "a", {value : 1});
// sera équivalent à :
Object.defineProperty(o, "a", {value : 1,
                               writable : false,
                               configurable : false,
                               enumerable : false});

Accesseurs et mutateurs adaptés

L'exemple ci-dessous illustre comment implémenter un objet qui archive des données. Lorsque la propriété température est définie, on ajoute une entrée au tableau archive :

function Archiviste() {
  var température = null;
  var archive = [];

  Object.defineProperty(this, "température",{
    get: function() {
      console.log("accès !"); 
      return température; 
    },
    set: function(value) { 
      température = value; 
      archive.push({val: température}); 
    }
  });

  this.getArchive = function() {return archive;};
}

var arc = new Archiviste();
arc.température; // "accès !"
arc.température = 11; 
arc.température = 13; 
arc.getArchive(); // [{val: 11}, {val: 13}]

Spécifications

Spécification Statut Commentaires
ECMAScript 5.1 (ECMA-262)
La définition de 'Object.defineProperty' dans cette spécification.
Standard Définition initiale. Implémentée par JavaScript 1.8.5
ECMAScript 6 (ECMA-262)
La définition de 'Object.defineProperty' dans cette spécification.
En cours de validation comme recommandation  

Compatibilité des navigateurs

Fonctionnalité Firefox (Gecko) Chrome Internet Explorer Opera Safari
Support simple 4.0 (2) 5 (versions antérieures non-testées) 9 (8, uniquement sur les objets DOM avec certains comportements non standard. Voir ci-après.) 11.60 5.1 (5, mais pas sur les objets DOM)
Fonctionnalité Firefox Mobile (Gecko) Android IE Mobile Opera Mobile Safari Mobile
Support simple 4.0 (2) (Oui) 9 et supérieurs 11.50 (Oui)

Tableau basé sur les tableaux de compatibilité de Kangax.

Redéfinir la propriété length d'un tableau (Array)

Il est possible de redéfinir la propriété length utilisée pour les tableaux, avec les restrictions vues. (La propriété length est initialement non-configurable, non-enumérable et accessible en écriture (writable vaut true)). Ainsi, sur un tableau, si rien n'a été fait, on peut modifier la valeur de la propriété length ou la rendre non accessible en écriture. Il n'est pas permis de changer son caractère énumérable ou configurable. Cependant, tous les navigateurs n'autorisent pas cette redéfinition.

Les versions de Firefox 4 à 22 renverront une exception TypeError pour chaque tentative (licite ou non) de modification de la propriété length d'un tableau.

Pour les versions de Chrome qui implémentent Object.defineProperty(), elles ignorent, dans certaines circonstances, une redéfinition de la propriété utilisant une valeur différente de la valeur courante de length. Sous certaines circonstances, le changement de l'accès en écriture n'aura aucun effet (et ne renverra aucune exception). Les méthodes relatives comme  Array.prototype.push ne respectent pas le non accès en écriture.

Pour les versions de Safari qui implémentent Object.defineProperty() elles ignorent la redéfinition d'une valeur différente de la valeur courante. Toute tentative de modifier l'accès en écriture échouera silencieusement (aucune modification effective, aucune exception renvoyée).

Seules les versions Internet Explorer 9 et supérieures et Firefox 23 et supérieures semblent supporter complètement la redéfinition de la propriété length pour les tableaux. À l'heure actuelle, il n'est pas conseillé de s'attendre à ce qu'une telle redéfinition fonctionne ou ne fonctionne pas. Même dans le cas où on peut supposer que cela fonctionne de façon cohérente : ce n'est pas vraiment une bonne idée de le faire (en anglais).

Notes spécifiques relatives à Internet Explorer 8

Internet Explorer 8 a implémenté une méthode Object.defineProperty() uniquement utilisable sur les objets DOM. Quelques éléments sont à noter :

  • L'utilisation de Object.defineProperty() sur les objets natifs renvoie une erreur.
  • Les attributs de propriétés doivent être définis avec certaines valeurs. true (pour Configurable), true (pour enumerable), true (pour writable) pour les descripteurs de données et true pour configurable, false pour enumerable pour les descripteurs d'accesseur. Fournir d'autres valeurs résultera en une erreur (à confirmer).
  • Pour modifier une propriété, il faut d'abord la supprimer. Si ça n'a pas été fait, elle reste telle quelle.

Voir aussi

Étiquettes et contributeurs liés au document

Contributeurs à cette page : SphinxKnight, yboukhata
Dernière mise à jour par : SphinxKnight,