Object

Description

Presque tous les objets en JavaScript sont des instances de Object ; un objet typique hrite de proprits (y compris des mthodes) de Object.prototype, bien que ces proprits puissent tre masques (c'est--dire remplaces). Les seuls objets qui n'hritent pas de Object.prototype sont ceux avec un prototype null, ou qui en descendent.

Les modifications apportes l'objet Object.prototype sont visibles par tous les objets via la chane de prototypes, sauf si les proprits et mthodes soumises ces modifications sont remplaces ailleurs dans la chane de prototypes. Cela fournit un mcanisme trs puissant, bien que potentiellement dangereux, pour remplacer ou tendre le comportement des objets. Pour plus de scurit, Object.prototype est le seul objet du langage JavaScript de base qui possde un prototype immuable le prototype de Object.prototype est toujours null et ne peut pas tre modifi.

Proprits de prototype d'Object

Vous devez viter d'appeler directement les mthodes de Object.prototype partir de l'instance, en particulier celles qui ne sont pas destines tre polymorphes (c'est--dire que seul son comportement initial a du sens et aucun objet descendant ne pourrait le remplacer de manire significative). Tous les objets descendant de Object.prototype peuvent dfinir une proprit propre personnalise qui porte le mme nom, mais avec une smantique entirement diffrente de ce que vous attendez. De plus, ces proprits ne sont pas hrites par les objets avec prototype null. Tous les utilitaires JavaScript modernes pour travailler avec des objets sont statiques. Plus prcisment :

• valueOf(), toString(), et toLocaleString() existent pour tre polymorphes et vous devez vous attendre ce que l'objet dfinisse sa propre implmentation avec des comportements sensibles, de sorte que vous pouvez les appeler comme des mthodes d'instance. Cependant, valueOf() et toString() sont gnralement appeles implicitement via la conversion de type et vous n'avez pas besoin de les appeler vous-mme dans votre code.
• __defineGetter__(), __defineSetter__(), __lookupGetter__(), et __lookupSetter__() sont dprcies et ne doivent pas tre utilises. Utilisez plutt les alternatives statiques Object.defineProperty() et Object.getOwnPropertyDescriptor().
• La proprit __proto__ est dprcie et ne doit pas tre utilise. Les alternatives Object.getPrototypeOf() et Object.setPrototypeOf() sont des mthodes statiques.
• Les mthodes propertyIsEnumerable() et hasOwnProperty() peuvent tre remplaces respectivement par les mthodes statiques Object.getOwnPropertyDescriptor() et Object.hasOwn().
• La mthode isPrototypeOf() peut gnralement tre remplace par instanceof, si vous vrifiez la proprit prototype d'un constructeur.

Au cas o une mthode statique smantiquement quivalente n'existe pas, ou si vous voulez vraiment utiliser la mthode Object.prototype, vous devez appeler directement call() la mthode Object.prototype sur votre objet cible au lieu de cela, pour empcher l'objet d'avoir une proprit de remplacement qui produit des rsultats inattendus.

const obj = {
  foo: 1,
  // Vous ne devez pas dfinir une telle mthode sur votre propre objet,
  // mais vous pourriez ne pas tre capable d'empcher cela si
  // vous recevez l'objet d'une source externe
  propertyIsEnumerable() {
    return false;
  },
};

obj.propertyIsEnumerable("foo"); // false ; rsultat inattendu
Object.prototype.propertyIsEnumerable.call(obj, "foo"); // true ; rsultat attendu

Suppression d'une proprit d'un objet

Il n'existe pas de mthode dans un objet lui-mme pour supprimer ses propres proprits (comme Map.prototype.delete()). Pour ce faire, vous devez utiliser l'oprateur delete.

Objets avec prototype null

Presque tous les objets en JavaScript hritent finalement de Object.prototype (voir hritage et chane de prototypes). Cependant, vous pouvez crer des objets avec prototype null en utilisant Object.create(null) ou la syntaxe d'initialisation d'objet avec __proto__: null (remarque : la cl __proto__ dans les littraux d'objet est diffrente de la proprit dprcie Object.prototype.__proto__). Vous pouvez galement modifier le prototype d'un objet existant en null en appelant Object.setPrototypeOf(obj, null).

const obj = Object.create(null);
const obj2 = { __proto__: null };

Un objet avec un prototype null peut se comporter de manires inattendues, car il n'hrite d'aucune mthode d'objet de Object.prototype. C'est particulirement vrai lors du dbogage, car les fonctions utilitaires courantes de conversion/dtection de proprit d'objet peuvent gnrer des erreurs ou perdre des informations (en particulier si vous utilisez des piges d'erreur silencieux qui ignorent les erreurs).

Par exemple, l'absence de Object.prototype.toString() rend souvent le dbogage impossible :

const normalObj = {}; // crer un objet normal
const nullProtoObj = Object.create(null); // crer un objet avec prototype "null"

console.log(`normalObj is: ${normalObj}`); // affiche "normalObj is: [object Object]"
console.log(`nullProtoObj is: ${nullProtoObj}`); // lve une erreur : Cannot convert object to primitive value

alert(normalObj); // affiche [object Object]
alert(nullProtoObj); // lve une erreur : Cannot convert object to primitive value

D'autres mthodes choueront galement.

normalObj.valueOf(); // affiche {}
nullProtoObj.valueOf(); // lve une erreur : nullProtoObj.valueOf is not a function

normalObj.hasOwnProperty("p"); // affiche "true"
nullProtoObj.hasOwnProperty("p"); // lve une erreur : nullProtoObj.hasOwnProperty is not a function

normalObj.constructor; // affiche "Object() { [native code] }"
nullProtoObj.constructor; // affiche "undefined"

Nous pouvons rajouter la mthode toString l'objet avec prototype null en en assignant une :

nullProtoObj.toString = Object.prototype.toString; // puisque le nouvel objet n'a pas toString, rajouter l'objet gnrique original

console.log(nullProtoObj.toString()); // affiche "[object Object]"
console.log(`nullProtoObj is: ${nullProtoObj}`); // affiche "nullProtoObj is: [object Object]"

Contrairement aux objets normaux, dans lesquels toString() se trouve sur le prototype de l'objet, la mthode toString() ici est une proprit propre de nullProtoObj. C'est parce que nullProtoObj n'a pas de prototype (null).

Vous pouvez aussi revenir un objet ordinaire depuis un objet avec prototype null en utilisant Object.setPrototypeOf(nullProtoObj, Object.prototype).

En pratique, les objets avec prototype null sont gnralement utiliss comme substitut bon march pour les cartes (maps). La prsence de proprits Object.prototype causera quelques bogues :

const ages = { alice: 18, bob: 27 };

function hasPerson(name) {
  return name in ages;
}

function getAge(name) {
  return ages[name];
}

hasPerson("hasOwnProperty"); // true
getAge("toString"); // [Function: toString]

L'utilisation d'un objet avec prototype null supprime ce risque sans ajouter trop de complexit aux fonctions hasPerson et getAge :

const ages = Object.create(null, {
  alice: { value: 18, enumerable: true },
  bob: { value: 27, enumerable: true },
});

hasPerson("hasOwnProperty"); // false
getAge("toString"); // undefined

Dans un tel cas, l'ajout de toute mthode doit tre fait prudemment, car elles peuvent tre confondues avec les autres paires cl-valeur stockes en tant que donnes.

Faire en sorte que votre objet n'hrite pas de Object.prototype prvient aussi les attaques par pollution de prototype. Si un script malveillant ajoute une proprit Object.prototype, elle sera accessible sur chaque objet de votre programme, sauf sur les objets qui ont un prototype null.

const user = {};

// Un script malveillant :
Object.prototype.authenticated = true;

// Permettant inopinment  une utilisateurice non authentifie de passer
if (user.authenticated) {
  // accder aux donnes confidentielles
}

JavaScript a aussi des API intgres qui produisent des objets avec prototype null, particulirement celles qui utilisent des objets comme collections ad hoc cl-valeur. Par exemple :

• La valeur de retour de Object.groupBy()
• Les proprits groups et indices.groups du rsultat de RegExp.prototype.exec()
• Array.prototype[Symbol.unscopables] (tous les objets [Symbol.unscopables] devraient avoir un prototype null)
• import.meta
• Les objets d'espace de noms de module, obtenus via import * as ns from "module"; ou import()

Le terme  objet avec prototype null  inclut souvent aussi tout objet sans Object.prototype dans sa chane de prototypes. De tels objets peuvent tre crs avec extends null quand on utilise des classes.

Coercition d'objet

Beaucoup d'oprations intgres qui attendent des objets convertissent d'abord leurs arguments en objets. L'opration (angl.) peut tre rsume comme suit :

• Les objets sont retourns tels quels.
• undefined et null lvent une TypeError.
• Les primitives Number, String, Boolean, Symbol, BigInt sont enveloppes dans leurs enveloppes d'objet correspondantes.

Il y a deux faons d'obtenir presque le mme effet en JavaScript.

• Object.prototype.valueOf() : Object.prototype.valueOf.call(x) fait exactement les tapes de coercition d'objet expliques ci-dessus pour convertir x.
• La fonction Object() : Object(x) utilise le mme algorithme pour convertir x, sauf que undefined et null ne lvent pas une TypeError, mais retournent un objet ordinaire.

Les endroits qui utilisent la coercition d'objet incluent :

• Le paramtre object des boucles for...in.
• La valeur this des mthodes Array.
• Les paramtres des mthodes Object telles que Object.keys().
• L'encapsulation automatique quand on accde une proprit sur une valeur primitive, puisque les primitives n'ont pas de proprits.
• La valeur this quand on appelle une fonction non-stricte. Les primitives sont encapsules tandis que null et undefined sont remplacs par l'objet global.

Contrairement la conversion en primitives, le processus de coercition d'objet lui-mme n'est observable en aucune faon, puisqu'il n'invoque pas de code personnalis comme les mthodes toString ou valueOf.

Constructeur

Object()

Convertit l'entre en un objet.

Mthodes statiques

Object.assign()

Copie les valeurs de toutes les proprits numrables propres d'un ou plusieurs objets source vers un objet cible.

Object.create()

Cre un nouvel objet avec l'objet prototype dfini et les proprits.

Object.defineProperties()

Ajoute un objet les proprits nommes dcrites par les descripteurs donns.

Object.defineProperty()

Ajoute un objet la proprit nomme dcrite par un descripteur donn.

Object.entries()

Retourne un tableau contenant toutes les paires [cl, valeur] des proprits de chane numrables propres d'un objet donn.

Object.freeze()

Gle un objet. Le code tiers ne peut pas supprimer ou modifier ses proprits.

Object.fromEntries()

Retourne un nouvel objet partir d'un itrable de paires [cl, valeur]. (C'est l'inverse de Object.entries).

Object.getOwnPropertyDescriptor()

Retourne le descripteur de proprit pour une proprit nomme sur un objet.

Object.getOwnPropertyDescriptors()

Retourne un objet contenant tous les descripteurs de proprit propres d'un objet.

Object.getOwnPropertyNames()

Retourne un tableau contenant les noms de toutes les proprits numrables et non-numrables propres de l'objet donn.

Object.getOwnPropertySymbols()

Retourne un tableau de tous les symboles de proprit trouvs directement sur un objet donn.

Object.getPrototypeOf()

Retourne le prototype (la proprit interne [[Prototype]]) de l'objet dfini.

Object.groupBy()

Regroupe les lments d'un itrable donn selon les valeurs de chane retournes par une fonction de rappel fournie. L'objet retourn a des proprits spares pour chaque groupe, contenant des tableaux avec les lments du groupe.

Object.hasOwn()

Retourne true si l'objet dfini possde la proprit indique comme sa proprit propre, ou false si la proprit est hrite ou n'existe pas.

Object.is()

Compare si deux valeurs sont la mme valeur. quivaut toutes les valeurs NaN (ce qui diffre la fois de IsLooselyEqual utilise par == et IsStrictlyEqual utilise par ===).

Object.isExtensible()

Dtermine si l'extension d'un objet est autorise.

Object.isFrozen()

Dtermine si un objet a t gel.

Object.isSealed()

Dtermine si un objet est scell.

Object.keys()

Retourne un tableau contenant les noms de toutes les proprits de chane numrables propres de l'objet donn.

Object.preventExtensions()

Empche toute extension d'un objet.

Object.seal()

Empche le code tiers de supprimer les proprits d'un objet.

Object.setPrototypeOf()

Dfinit le prototype de l'objet (sa proprit interne [[Prototype]]).

Object.values()

Retourne un tableau contenant les valeurs qui correspondent toutes les proprits de chane numrables propres d'un objet donn.

Proprits d'instance

Ces proprits sont dfinies sur Object.prototype et partages par tous les instances d'Object.

Object.prototype.__proto__

Pointe vers l'objet qui a t utilis comme prototype quand l'objet a t instanci.

Object.prototype.constructor

La fonction constructeur qui a cr l'objet instance. Pour les instances d'Object ordinaires, la valeur initiale est le constructeur Object. Les instances d'autres constructeurs hritent chacune de la proprit constructor de l'objet Constructor.prototype respectif.

Mthodes d'instance

Object.prototype.__defineGetter__()

Associe une fonction une proprit qui, quand elle est accde, excute cette fonction et retourne sa valeur de retour.

Object.prototype.__defineSetter__()

Associe une fonction une proprit qui, quand elle est dfinie, excute cette fonction qui modifie la proprit.

Object.prototype.__lookupGetter__()

Retourne la fonction lie comme accesseur la proprit dfinie.

Object.prototype.__lookupSetter__()

Retourne la fonction lie comme mutateur la proprit dfinie.

Object.prototype.hasOwnProperty()

Retourne un boolen indiquant si un objet contient la proprit dfinie comme proprit directe de cet objet et non hrite via la chane de prototypes.

Object.prototype.isPrototypeOf()

Retourne un boolen indiquant si l'objet sur lequel cette mthode est appele est dans la chane de prototypes de l'objet dfini.

Object.prototype.propertyIsEnumerable()

Retourne un boolen indiquant si la proprit dfinie est la propre proprit numrable de l'objet.

Object.prototype.toLocaleString()

Appelle toString().

Object.prototype.toString()

Returns a string representation of the object.

Object.prototype.valueOf()

Retourne la valeur primitive de l'objet dfini.

Exemples

Construction d'objets vides

L'exemple suivant cre des objets vides en utilisant le mot-cl new avec diffrents arguments :

const o1 = new Object();
const o2 = new Object(undefined);
const o3 = new Object(null);

Utiliser le constructeur Object() pour convertir les primitives en un Object de leur type respectif

Vous pouvez utiliser le constructeur Object() pour crer une enveloppe d'objet d'une valeur primitive.

Les exemples suivants crent les variables o1 et o2 qui sont des objets stockant des valeurs Boolean et BigInt:

// quivalent  const o1 = new Boolean(true)
const o1 = new Object(true);

// Pas d'quivalent parce que BigInt() ne peut pas tre appel comme constructeur,
// et l'appeler comme une fonction ordinaire ne cre pas d'objet
const o2 = new Object(1n);

Prototypes d'objets

Quand on modifie le comportement de mthodes Object.prototype existantes, envisagez d'injecter du code en enveloppant votre extension avant ou aprs la logique existante. Par exemple, ce code (non test) excutera conditionnellement la logique personnalise avant l'excution de la logique intgre ou de l'extension de quelqu'un d'autre.

Quand on modifie les prototypes avec des crochets, passer this et les arguments (l'tat de l'appel) au comportement actuel en appelant apply() sur la fonction. Ce motif peut tre utilis pour tout prototype, tel que Node.prototype, Function.prototype, etc.

const current = Object.prototype.valueOf;

// Puisque ma proprit "-prop-value" est transversale et n'est pas toujours
// sur la mme chane de prototypes, je veux modifier Object.prototype :
Object.prototype.valueOf = function (...args) {
  if (Object.hasOwn(this, "-prop-value")) {
    return this["-prop-value"];
  }
  // Cela ne ressemble pas  l'un de mes objets, donc retomber
  // au comportement par dfaut en reproduisant le comportement actuel au mieux.
  // L'apply se comporte comme "super" dans d'autres langages.
  // Bien que valueOf() ne prenne pas d'arguments, un autre crochet peut le faire.
  return current.apply(this, args);
};

Vous pouvez lire plus sur les prototypes dans Hritage et chane de prototypes.

Spcifications

Compatibilit des navigateurs

Voir aussi

• Initialisation d'objet
• Attaque par pollution de prototype