Les objets sont un type de données discrètes de la même manière que chaque
primitive est un type de données, avec un élément critique
différence: contrairement aux primitives, les objets sont modifiables. Un objet peut contenir des données
associées à des identifiants, comme une variable, tout en conservant ses données object
.
sans tenir compte des données qu'il contient.
Hormis les primitives, toutes les valeurs JavaScript sont des objets. les littéraux primitifs présentent un comportement de type objet en raison héritage prototypique, c'est dit souvent que JavaScript est effectivement composé d'objets.
Un littéral d'objet est une paire d'accolades entourant zéro ou plusieurs paires clé-valeur. appelées "propriétés", qui peut contenir n'importe quelle valeur JavaScript.
{
"myProperty" : true
}
Les clés de propriété peuvent être n'importe quel symbole ou chaîne. Comme lors de l'attribution d'un identifiant à une variable, les chaînes utilisées comme clés de propriété doivent être prévisibles descriptives:
let carAttributes = {
"color" : "red"
};
carAttributes
> Object { color: "red" }
Les clés de propriété nécessitent un littéral de chaîne ('
) ou double ("
), mais pas
Un littéral de modèle:
let carAttributes = {
`keyString` : false
};
> Uncaught SyntaxError: expected property name, got template literal
Les valeurs de propriété peuvent correspondre à n'importe quel type de données. Les propriétés d'un objet peuvent elles-mêmes contiennent des objets ayant leurs propres propriétés:
let myObject = {
'key' : {
'subkey' : true,
'othersubkey' : false
}
};
myObject;
> Object { key: Object { subkey: true, othersubkey: false } }
Lorsque la valeur d'une propriété est une fonction, cette propriété est appelée "méthode".
const myObject = {
"myProperty" : true,
myMethod() {
console.log( "This is a method." );
}
}
myObject.myProperty;
> true
myObject.myMethod();
> "This is a method."
Vous pouvez également créer un objet à l'aide du mot clé new
:
let myObject = new Object();
Dans les exemples précédents, les littéraux d'objets nouvellement créés se sont vu attribuer
aux variables. Ce n'est pas obligatoire, car comme pour tout autre type de données, vous pouvez utiliser
un objet sans identifiant partout où un objet est attendu. Toutefois, une
Le littéral d'objet nécessite des parenthèses dans tous les contextes où il pourrait être confondu
pour une instruction de bloc, étant donné que les deux partagent une syntaxe avec accolades ({}
).
Cela n'est jamais nécessaire pour initialiser une variable.
{ "value" : 2 }
> Uncaught SyntaxError: unexpected token: ':'
({ "value" : 2 })
> Object { value: 2 }
let valObj = { "value" : 2 };
valObj;
> Object { value: 2 }
Contrairement aux primitives, il n'y a pas de différence significative dans les résultats de la création
un objet en utilisant new Object()
et en créant un littéral d'objet, car
Dans les deux cas, il s'agira d'un objet dont les propriétés sont héritées
Prototype Object
. Cependant, il existe une différence pratique entre les deux
ou de syntaxes spécifiques.
Le mot clé new
doit définir un objet vide qui sera ensuite rempli de données:
let myObject = new Object();
myObject.booleanValue = true;
myObject.stringValue = "My string.";
Un littéral d'objet peut être renseigné avec des données lors de sa création:
let myObject = {
'booleanValue' : true,
'stringValue' : "My string."
};
Bien qu'il n'ait que peu d'utilisation pratique, new Object()
peut être utilisé pour transformer un langage primitif
des valeurs de données dans des objets de leur type respectif, comme ceux renvoyés en utilisant
Le mot clé new
et son constructeur
. Par exemple, le code suivant est fonctionnellement équivalent à
new Number( 10 )
:
let myObject = new Object( 10 );
myObject;
> Number { 10 }
Les valeurs null
et undefined
génèrent un objet vide, fonctionnellement identique.
à l'appel de new Object()
sans fournir d'argument.
La transmission d'un littéral d'objet à new Object()
en tant qu'argument transmet l'objet
sans le modifier:
let myObject = new Object( { myValue : 10 } );
myObject;
> Object { myValue: 10 }
Comme pour l'utilisation de constructeurs pour les valeurs primitives, utilisation de constructeurs pour les objets présente rarement des avantages par rapport à l'utilisation de la notation littérale d'objet. Même lors de la création les objets vides à ajouter ultérieurement des valeurs, les développeurs ont tendance à privilégier les objets par souci de simplicité.
Testez vos connaissances
Quels types de notation pouvez-vous utiliser pour définir les propriétés d'un objet ?
Quelle est la syntaxe correcte pour obtenir la valeur
sur myProp
myObj{"myProp"};
myObj["myProp"];
myObj("myProp");