6.1 Création d'objets
Les objets sont l'un des principaux types de données en JavaScript et sont largement utilisés pour stocker et gérer des données. Un objet est une collection de propriétés, où chaque propriété est composée d'une clé (nom) et d'une valeur. Dans cette leçon, nous allons voir comment créer des objets, ainsi que comment accéder à leurs propriétés et méthodes.
1. Littéral d'objet
Le moyen le plus courant de créer un objet en JavaScript est d'utiliser un littéral d'objet.
Dans cet exemple, nous avons créé un objet person avec quatre propriétés : name, age, isStudent et greet.
let person = {
name: 'John',
age: 30,
isStudent: false,
greet: function() {
return 'Hello!';
}
};
2. Constructeur Object
Les objets peuvent également être créés en utilisant le constructeur Object().
Ce moyen est équivalent à la création d'un objet avec un littéral d'objet, mais plus verbeux :
let person = new Object();
person.name = 'John';
person.age = 30;
person.isStudent = false;
person.greet = function() {
return 'Hello!';
};
3. Fonction constructeur
Une fonction constructeur permet de créer plusieurs instances d'objets avec les mêmes propriétés et méthodes.
Dans cet exemple, la fonction constructeur Person() est utilisée pour créer les objets john et jane avec les mêmes propriétés et méthodes :
function Person(name, age, isStudent) {
this.name = name;
this.age = age;
this.isStudent = isStudent;
this.greet = function() {
return 'Hello!';
};
}
let john = new Person('John', 30, false);
let jane = new Person('Jane', 25, true);
4. Méthode Object.create()
La méthode Object.create() crée un nouvel objet et lui attribue immédiatement un prototype — un autre objet dans lequel le nouvel objet ira chercher les propriétés et méthodes qu'il ne possède pas lui-même.
Dans cet exemple, l'objet john est créé à partir du prototype personPrototype :
let personPrototype = {
greet: function() {
return 'Hello!';
}
};
let john = Object.create(personPrototype);
john.name = 'John';
john.age = 30;
john.isStudent = false;
console.log(john.name); // Affichera : John
console.log(john.greet()); // Affichera : Hello!
Regardez la dernière ligne. L'objet john n'a pas de méthode greet à lui — nous n'y avons écrit que name, age et isStudent. Pourtant john.greet() fonctionne : lors de l'accès à une propriété, JavaScript la cherche d'abord sur l'objet lui-même, et s'il ne la trouve pas, remonte vers le prototype. Ce chemin de recherche s'appelle la chaîne de prototypes.
La différence entre une propriété propre et une propriété héritée est facile à voir :
console.log(john.hasOwnProperty('name')); // Affichera : true
console.log(john.hasOwnProperty('greet')); // Affichera : false
console.log('greet' in john); // Affichera : true
hasOwnProperty() répond à la question « l'objet possède-t-il lui-même cette propriété », tandis que l'opérateur in répond « peut-on atteindre cette propriété, ne serait-ce qu'en remontant la chaîne de prototypes ». D'où les réponses différentes pour greet.
Point important : les propriétés du prototype ne sont pas copiées dans le nouvel objet. personPrototype reste un objet distinct, et john ne fait qu'y faire référence. C'est pourquoi un même prototype peut être partagé par des centaines d'objets, greet n'étant stocké qu'une seule fois en mémoire. Comparez avec la fonction constructeur de l'exemple 3 : là, chaque objet créé recevait sa propre copie de greet.
Le second argument : des propriétés avec des réglages
Object.create() accepte un second argument, facultatif — un objet décrivant les propriétés à créer immédiatement. Elles ne sont pas définies par une simple valeur, mais par un descripteur — un ensemble de réglages :
value— la valeur de la propriété elle-mêmewritable— si la valeur peut être modifiée (falsepar défaut)enumerable— si la propriété apparaît dansfor...inetObject.keys()(falsepar défaut)configurable— si la propriété peut être supprimée ou ses réglages modifiés (falsepar défaut)get/set— un getter et un setter à la place d'une valeur ordinaire. Le getter se déclenche à la lecture, le setter à l'écriture
Rassemblons le tout :
let john = Object.create(personPrototype, {
name: {
value: 'John',
writable: true, // la valeur peut être modifiée
enumerable: true // propriété visible dans for...in
},
id: {
value: 1001,
writable: false, // lecture seule
enumerable: true
},
info: {
enumerable: true,
get: function() { // getter : se déclenche à la lecture
return this.name + ' #' + this.id;
},
set: function(value) { // setter : se déclenche à l'écriture
this.name = value;
}
}
});
console.log(john.info); // Affichera : John #1001
john.name = 'Johnny'; // fonctionne
john.id = 2002; // ne fait rien, silencieusement
console.log(john.info); // Affichera : Johnny #1001
À noter : les trois drapeaux valent false par défaut, il faut donc presque toujours les indiquer explicitement lorsqu'on utilise le second argument. Une affectation à une propriété avec writable: false échoue silencieusement en mode normal et lève une TypeError en mode strict ('use strict').
Un autre cas utile est Object.create(null). Un tel objet n'a aucun prototype : ni toString(), ni hasOwnProperty(), ni aucune autre méthode héritée. Cela en fait un « dictionnaire propre » bien pratique, où chaque clé vous appartient à coup sûr et n'est pas héritée d'Object.prototype.
6.2 Accès aux propriétés et méthodes
1. Accès via le point
Le moyen le plus courant d'accéder aux propriétés et méthodes d'un objet est par le point :
let person = {
name: 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person.name); // Affichera : John
console.log(person.age); // Affichera : 30
console.log(person.greet()); // Affichera : Hello!
2. Accès via les crochets
Les propriétés d'un objet peuvent également être accessibles via des crochets. Ce moyen est utile si le nom de la propriété est stocké dans une variable ou contient des espaces ou des caractères spéciaux :
let person = {
'first name': 'John',
age: 30,
greet: function() {
return 'Hello!';
}
};
console.log(person['first name']); // Affichera : John
console.log(person['age']); // Affichera : 30
let propertyName = 'greet';
console.log(person[propertyName]()); // Affichera : Hello!
3. Modification et ajout de propriétés
Les propriétés d'un objet peuvent être modifiées ou ajoutées à tout moment :
let person = {
name: 'John',
age: 30
};
// Modification d'une propriété existante
person.age = 31;
console.log(person.age); // Affichera : 31
// Ajout d'une nouvelle propriété
person.isStudent = false;
console.log(person.isStudent); // Affichera : false
4. Suppression de propriétés
Les propriétés d'un objet peuvent être supprimées avec l'opérateur delete :
let person = {
name: 'John',
age: 30,
isStudent: false
};
delete person.isStudent;
console.log(person.isStudent); // Affichera : undefined
6.3 Itération sur les propriétés d'un objet
1. Boucle for...in
La boucle for...in permet de parcourir toutes les propriétés énumérables d'un objet :
let person = {
name: 'John',
age: 30,
isStudent: false
};
for (let key in person) {
console.log(`${key}: ${person[key]}`);
}
// Affichera :
// name: John
// age: 30
// isStudent: false
2. Méthode Object.keys()
La méthode Object.keys() renvoie un tableau de toutes les propriétés énumérables d'un objet :
let person = {
name: 'John',
age: 30,
isStudent: false
};
let keys = Object.keys(person);
console.log(keys); // Affichera : ['name', 'age', 'isStudent']
3. Méthode Object.values()
La méthode Object.values() renvoie un tableau des valeurs de toutes les propriétés énumérables d'un objet :
let person = {
name: 'John',
age: 30,
isStudent: false
};
let values = Object.values(person);
console.log(values); // Affichera : ['John', 30, false]
4. Méthode Object.entries()
La méthode Object.entries() renvoie un tableau de paires [clé, valeur] pour toutes les propriétés énumérables d'un objet :
let person = {
name: 'John',
age: 30,
isStudent: false
};
let entries = Object.entries(person);
console.log(entries); // Affichera : [['name', 'John'], ['age', 30], ['isStudent', false]]
6.4 Vérification de l'existence de propriétés
1. Opérateur in
L'opérateur in permet de vérifier si une propriété existe dans un objet :
let person = {
name: 'John',
age: 30
};
console.log('name' in person); // Affichera : true
console.log('isStudent' in person); // Affichera : false
2. Méthode hasOwnProperty()
La méthode hasOwnProperty() vérifie si un objet a une propriété spécifiée comme étant la sienne (non héritée) :
let person = {
name: 'John',
age: 30
};
console.log(person.hasOwnProperty('name')); // Affichera : true
console.log(person.hasOwnProperty('isStudent')); // Affichera : false
GO TO FULL VERSION