Le typeObject représente l'un destypes de données de JavaScript. Il est utilisé pour stocker diverses collections à clés et des entités plus complexes. Les objets peuvent être créés en utilisant le constructeurObject() ou lasyntaxe d'initialisation / littérale d'objet.

Description

Presque tous lesobjets en JavaScript sont des instances deObject ; un objet typique hérite de propriétés (y compris des méthodes) deObject.prototype, bien que ces propriétés puissent être masquées (c'est-à-dire remplacées). Les seuls objets qui n'héritent pas deObject.prototype sont ceux avec unprototypenull, ou qui en descendent.

Les modifications apportées à l'objetObject.prototype sont visibles partous les objets via la chaîne de prototypes, sauf si les propriétés et méthodes soumises à ces modifications sont remplacées ailleurs dans la chaîne de prototypes. Cela fournit un mécanisme très puissant, bien quepotentiellement dangereux, pour remplacer ou étendre le comportement des objets. Pour plus de sécurité,Object.prototype est le seul objet du langage JavaScript de base qui possède unprototype immuable — le prototype deObject.prototype est toujoursnull et ne peut pas être modifié.

Propriétés de prototype d'Object

Vous devez éviter d'appeler directement les méthodes deObject.prototype à partir de l'instance, en particulier celles qui ne sont pas destinées à être polymorphes (c'est-à-dire que seul son comportement initial a du sens et aucun objet descendant ne pourrait le remplacer de manière significative). Tous les objets descendant deObject.prototype peuvent définir une propriété propre personnalisée qui porte le même nom, mais avec une sémantique entièrement différente de ce que vous attendez. De plus, ces propriétés ne sont pas héritées par lesobjets avec prototypenull. Tous les utilitaires JavaScript modernes pour travailler avec des objets sontstatiques. Plus précisément :

• valueOf(),toString(), ettoLocaleString() existent pour être polymorphes et vous devez vous attendre à ce que l'objet définisse sa propre implémentation avec des comportements sensibles, de sorte que vous pouvez les appeler comme des méthodes d'instance. Cependant,valueOf() ettoString() sont généralement appelées implicitement viala conversion de type et vous n'avez pas besoin de les appeler vous-même dans votre code.
• __defineGetter__(),__defineSetter__(),__lookupGetter__(), et__lookupSetter__() sont dépréciées et ne doivent pas être utilisées. Utilisez plutôt les alternatives statiquesObject.defineProperty() etObject.getOwnPropertyDescriptor().
• La propriété__proto__ est dépréciée et ne doit pas être utilisée. Les alternativesObject.getPrototypeOf() etObject.setPrototypeOf() sont des méthodes statiques.
• Les méthodespropertyIsEnumerable() ethasOwnProperty() peuvent être remplacées respectivement par les méthodes statiquesObject.getOwnPropertyDescriptor() etObject.hasOwn().
• La méthodeisPrototypeOf() peut généralement être remplacée parinstanceof, si vous vérifiez la propriétéprototype d'un constructeur.

Au cas où une méthode statique sémantiquement équivalente n'existe pas, ou si vous voulez vraiment utiliser la méthodeObject.prototype, vous devez appeler directementcall() la méthodeObject.prototype sur votre objet cible au lieu de cela, pour empêcher l'objet d'avoir une propriété de remplacement qui produit des résultats inattendus.

const obj = {  foo: 1,  // Vous ne devez pas définir une telle méthode sur votre propre objet,  // mais vous pourriez ne pas être capable d'empêcher cela si  // vous recevez l'objet d'une source externe  propertyIsEnumerable() {    return false;  },};obj.propertyIsEnumerable("foo"); // false ; résultat inattenduObject.prototype.propertyIsEnumerable.call(obj, "foo"); // true ; résultat attendu

Suppression d'une propriété d'un objet

Il n'existe pas de méthode dans un objet lui-même pour supprimer ses propres propriétés (commeMap.prototype.delete()). Pour ce faire, vous devez utiliser l'opérateurdelete.

Objets avec prototypenull

Presque tous les objets en JavaScript héritent finalement deObject.prototype (voirhéritage et chaîne de prototypes). Cependant, vous pouvez créer des objets avec prototypenull en utilisantObject.create(null) ou lasyntaxe d'initialisation d'objet avec__proto__: null (remarque : la clé__proto__ dans les littéraux d'objet est différente de la propriété dépréciéeObject.prototype.__proto__). Vous pouvez également modifier le prototype d'un objet existant ennull en appelantObject.setPrototypeOf(obj, null).

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

Un objet avec un prototypenull peut se comporter de manières inattendues, car il n'hérite d'aucune méthode d'objet deObject.prototype. C'est particulièrement vrai lors du débogage, car les fonctions utilitaires courantes de conversion/détection de propriété d'objet peuvent générer des erreurs ou perdre des informations (en particulier si vous utilisez des pièges d'erreur silencieux qui ignorent les erreurs).

Par exemple, l'absence deObject.prototype.toString() rend souvent le débogage impossible :

const normalObj = {}; // créer un objet normalconst nullProtoObj = Object.create(null); // créer un objet avec prototype "null"console.log(`normalObj is: ${normalObj}`); // affiche "normalObj is: [object Object]"console.log(`nullProtoObj is: ${nullProtoObj}`); // lève une erreur : Cannot convert object to primitive valuealert(normalObj); // affiche [object Object]alert(nullProtoObj); // lève une erreur : Cannot convert object to primitive value

D'autres méthodes échoueront également.

normalObj.valueOf(); // affiche {}nullProtoObj.valueOf(); // lève une erreur : nullProtoObj.valueOf is not a functionnormalObj.hasOwnProperty("p"); // affiche "true"nullProtoObj.hasOwnProperty("p"); // lève une erreur : nullProtoObj.hasOwnProperty is not a functionnormalObj.constructor; // affiche "Object() { [native code] }"nullProtoObj.constructor; // affiche "undefined"

Nous pouvons rajouter la méthodetoString à 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 générique originalconsole.log(nullProtoObj.toString()); // affiche "[object Object]"console.log(`nullProtoObj is: ${nullProtoObj}`); // affiche "nullProtoObj is: [object Object]"

Contrairement aux objets normaux, dans lesquelstoString() se trouve sur le prototype de l'objet, la méthodetoString() ici est une propriété propre denullProtoObj. C'est parce quenullProtoObj n'a pas de prototype (null).

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

En pratique, les objets avec prototypenull sont généralement utilisés comme substitut bon marché pour lescartes (maps). La présence de propriétésObject.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"); // truegetAge("toString"); // [Function: toString]

L'utilisation d'un objet avec prototype null supprime ce risque sans ajouter trop de complexité aux fonctionshasPerson etgetAge :

const ages = Object.create(null, {  alice: { value: 18, enumerable: true },  bob: { value: 27, enumerable: true },});hasPerson("hasOwnProperty"); // falsegetAge("toString"); // undefined

Dans un tel cas, l'ajout de toute méthode doit être fait prudemment, car elles peuvent être confondues avec les autres paires clé-valeur stockées en tant que données.

Faire en sorte que votre objet n'hérite pas deObject.prototype prévient aussi lesattaques par pollution de prototype. Si un script malveillant ajoute une propriété à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 inopinément à un·e utilisateur·ice non authentifié·e de passerif (user.authenticated) {  // accéder aux données confidentielles}

JavaScript a aussi des API intégrées qui produisent des objets avec prototypenull, particulièrement celles qui utilisent des objets comme collections ad hoc clé-valeur. Par exemple :

• La valeur de retour deObject.groupBy()
• Les propriétésgroups etindices.groups du résultat deRegExp.prototype.exec()
• Array.prototype[Symbol.unscopables] (tous les objets[Symbol.unscopables] devraient avoir un prototypenull)
• import.meta
• Les objets d'espace de noms de module, obtenus viaimport * as ns from "module"; ouimport()

Le terme « objet avec prototypenull » inclut souvent aussi tout objet sansObject.prototype dans sa chaîne de prototypes. De tels objets peuvent être créés avecextends null quand on utilise des classes.

Coercition d'objet

Beaucoup d'opérations intégrées qui attendent des objets convertissent d'abord leurs arguments en objets.L'opération^(angl.) peut être résumée comme suit :

• Les objets sont retournés tels quels.
• undefined etnull lèvent uneTypeError.
• Les primitivesNumber,String,Boolean,Symbol,BigInt sont enveloppées dans leurs enveloppes d'objet correspondantes.

Il y a deux façons d'obtenir presque le même effet en JavaScript.

• Object.prototype.valueOf() :Object.prototype.valueOf.call(x) fait exactement les étapes de coercition d'objet expliquées ci-dessus pour convertirx.
• La fonctionObject() :Object(x) utilise le même algorithme pour convertirx, sauf queundefined etnull ne lèvent pas uneTypeError, mais retournent un objet ordinaire.

Les endroits qui utilisent la coercition d'objet incluent :

• Le paramètreobject des bouclesfor...in.
• La valeurthis des méthodesArray.
• Les paramètres des méthodesObject telles queObject.keys().
• L'encapsulation automatique quand on accède à une propriété sur une valeur primitive, puisque les primitives n'ont pas de propriétés.
• La valeurthis quand on appelle une fonction non-stricte. Les primitives sont encapsulées tandis quenull etundefined sont remplacés par l'objet global.

Contrairement à laconversion en primitives, le processus de coercition d'objet lui-même n'est observable en aucune façon, puisqu'il n'invoque pas de code personnalisé comme les méthodestoString ouvalueOf.

Constructeur

Object()

Convertit l'entrée en un objet.

Méthodes statiques

Object.assign()

Copie les valeurs de toutes les propriétés énumérables propres d'un ou plusieurs objets source vers un objet cible.

Object.create()

Crée un nouvel objet avec l'objet prototype défini et les propriétés.

Object.defineProperties()

Ajoute à un objet les propriétés nommées décrites par les descripteurs donnés.

Object.defineProperty()

Ajoute à un objet la propriété nommée décrite par un descripteur donné.

Object.entries()

Retourne un tableau contenant toutes les paires[clé, valeur] des propriétés de chaîne énumérablespropres d'un objet donné.

Object.freeze()

Gèle un objet. Le code tiers ne peut pas supprimer ou modifier ses propriétés.

Object.fromEntries()

Retourne un nouvel objet à partir d'un itérable de paires[clé, valeur]. (C'est l'inverse deObject.entries).

Object.getOwnPropertyDescriptor()

Retourne le descripteur de propriété pour une propriété nommée sur un objet.

Object.getOwnPropertyDescriptors()

Retourne un objet contenant tous les descripteurs de propriété propres d'un objet.

Object.getOwnPropertyNames()

Retourne un tableau contenant les noms de toutes les propriétés énumérables et non-énumérablespropres de l'objet donné.

Object.getOwnPropertySymbols()

Retourne un tableau de tous les symboles de propriété trouvés directement sur un objet donné.

Object.getPrototypeOf()

Retourne le prototype (la propriété interne[[Prototype]]) de l'objet défini.

Object.groupBy()

Regroupe les éléments d'un itérable donné selon les valeurs de chaîne retournées par une fonction de rappel fournie. L'objet retourné a des propriétés séparées pour chaque groupe, contenant des tableaux avec les éléments du groupe.

Object.hasOwn()

Retournetrue si l'objet défini possède la propriété indiquée comme sa propriétépropre, oufalse si la propriété est héritée ou n'existe pas.

Object.is()

Compare si deux valeurs sont la même valeur. Équivaut toutes les valeursNaN (ce qui diffère à la fois deIsLooselyEqual utilisée par== etIsStrictlyEqual utilisée par===).

Object.isExtensible()

Détermine si l'extension d'un objet est autorisée.

Object.isFrozen()

Détermine si un objet a été gelé.

Object.isSealed()

Détermine si un objet est scellé.

Object.keys()

Retourne un tableau contenant les noms de toutes les propriétés de chaîne énumérablespropres de l'objet donné.

Object.preventExtensions()

Empêche toute extension d'un objet.

Object.seal()

Empêche le code tiers de supprimer les propriétés d'un objet.

Object.setPrototypeOf()

Définit le prototype de l'objet (sa propriété interne[[Prototype]]).

Object.values()

Retourne un tableau contenant les valeurs qui correspondent à toutes les propriétés de chaîne énumérablespropres d'un objet donné.

Propriétés d'instance

Ces propriétés sont définies surObject.prototype et partagées par tous les instances d'Object.

Object.prototype.__proto__Obsolète

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 constructeurObject. Les instances d'autres constructeurs héritent chacune de la propriétéconstructor de l'objetConstructor.prototype respectif.

Méthodes d'instance

Object.prototype.__defineGetter__()Obsolète

Associe une fonction à une propriété qui, quand elle est accédée, exécute cette fonction et retourne sa valeur de retour.

Object.prototype.__defineSetter__()Obsolète

Associe une fonction à une propriété qui, quand elle est définie, exécute cette fonction qui modifie la propriété.

Object.prototype.__lookupGetter__()Obsolète

Retourne la fonction liée comme accesseur à la propriété définie.

Object.prototype.__lookupSetter__()Obsolète

Retourne la fonction liée comme mutateur à la propriété définie.

Object.prototype.hasOwnProperty()

Retourne un booléen indiquant si un objet contient la propriété définie comme propriété directe de cet objet et non héritée via la chaîne de prototypes.

Object.prototype.isPrototypeOf()

Retourne un booléen indiquant si l'objet sur lequel cette méthode est appelée est dans la chaîne de prototypes de l'objet défini.

Object.prototype.propertyIsEnumerable()

Retourne un booléen indiquant si la propriété définie est lapropre propriété énumérable de l'objet.

Object.prototype.toLocaleString()

AppelletoString().

Object.prototype.toString()

Returns a string representation of the object.

Object.prototype.valueOf()

Retourne la valeur primitive de l'objet défini.

Exemples

Construction d'objets vides

L'exemple suivant crée des objets vides en utilisant le mot-clénew avec différents arguments :

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

Utiliser le constructeurObject() pour convertir les primitives en unObject de leur type respectif

Vous pouvez utiliser le constructeurObject() pour créer une enveloppe d'objet d'une valeur primitive.

Les exemples suivants créent les variableso1 eto2 qui sont des objets stockant des valeursBoolean etBigInt:

// É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 crée pas d'objetconst o2 = new Object(1n);

Prototypes d'objets

Quand on modifie le comportement de méthodesObject.prototype existantes, envisagez d'injecter du code en enveloppant votre extension avant ou après la logique existante. Par exemple, ce code (non testé) exécutera conditionnellement la logique personnalisée avant l'exécution de la logique intégrée ou de l'extension de quelqu'un d'autre.

Quand on modifie les prototypes avec des crochets, passerthis et les arguments (l'état de l'appel) au comportement actuel en appelantapply() sur la fonction. Ce motif peut être utilisé pour tout prototype, tel queNode.prototype,Function.prototype, etc.

const current = Object.prototype.valueOf;// Puisque ma propriété "-prop-value" est transversale et n'est pas toujours// sur la même chaîne 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 défaut 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 dansHéritage et chaîne de prototypes.

Spécifications

Compatibilité des navigateurs

Voir aussi

• Initialisation d'objet
• Attaque par pollution de prototype