Objets

Un objet est une collection de paires clé-valeur. Alors que les tableaux stockent des listes ordonnées de valeurs accessibles par index, les objets stockent des valeurs nommées accessibles par clé. Les objets sont l'une des structures de données les plus importantes en JavaScript — presque tout dans le langage est construit sur eux.

La façon la plus courante de créer un objet est avec un littéral d'objet — des accolades contenant des propriétés séparées par des virgules :

const person = {
  name: 'Alice',
  age: 30,
  city: 'Paris',
};

Chaque propriété a une clé (aussi appelée nom) et une valeur. Les clés sont des chaînes de caractères (ou des Symboles), et les valeurs peuvent être n'importe quoi — des nombres, des chaînes de caractères, des booléens, des tableaux, d'autres objets, ou même des fonctions.

Quand un nom de variable correspond au nom de la clé, tu peux utiliser la notation abrégée des propriétés :

const name = 'Bob';
const age = 25;

const person = { name, age };
// Équivalent à : { name: 'Bob', age: 25 }

Tu peux utiliser des noms de propriétés calculés quand la clé est dynamique :

const field = 'email';
const user = {
  [field]: 'bob@example.com',
};
console.log(user.email); // 'bob@example.com'

Les objets imbriqués sont des objets à l'intérieur d'objets, utiles pour représenter des données structurées :

const student = {
  name: 'Charlie',
  grades: {
    math: 92,
    english: 88,
    science: 95,
  },
};

console.log(student.grades.math); // 92

Il existe deux façons d'accéder aux propriétés d'un objet :

1. Notation par point — la façon la plus courante et la plus lisible :

const person = { name: 'Alice', age: 30 };
console.log(person.name); // 'Alice'
console.log(person.age);  // 30

2. Notation par crochets — utilise une chaîne de caractères (ou une expression) entre crochets :

console.log(person['name']); // 'Alice'
console.log(person['age']);  // 30

La notation par crochets est obligatoire dans ces situations :

• Clés dynamiques — quand le nom de la propriété est stocké dans une variable :

  javascript

  const key = 'name';
  console.log(person[key]); // 'Alice'

• Clés avec des espaces ou des caractères spéciaux :

  javascript

  const data = { 'first name': 'Alice', 'last-name': 'Smith' };
  console.log(data['first name']); // 'Alice'
  // data.first name — causerait une erreur de syntaxe !

• Clés qui sont des nombres :

  javascript

  const scores = { 1: 'gold', 2: 'silver', 3: 'bronze' };
  console.log(scores[1]); // 'gold'

Accéder à une propriété qui n'existe pas retourne undefined :

console.log(person.email); // undefined

L'enchaînement optionnel (?.) est une façon sûre d'accéder aux propriétés imbriquées sans risquer une erreur si une propriété intermédiaire est undefined ou null :

const user = { profile: { bio: 'Developer' } };
console.log(user.profile?.bio);    // 'Developer'
console.log(user.settings?.theme); // undefined (pas d'erreur)

Sans ?., accéder à user.settings.theme lancerait une TypeError car user.settings est undefined.

Les objets sont mutables — tu peux ajouter, mettre à jour et supprimer des propriétés après leur création.

Ajouter des propriétés :

const person = { name: 'Alice' };
person.age = 30;           // notation par point
person['email'] = 'a@b.c'; // notation par crochets

Mettre à jour des propriétés :

person.name = 'Bob'; // écrase la valeur existante

Supprimer des propriétés avec l'opérateur delete :

delete person.email;
console.log(person.email); // undefined

JavaScript fournit des méthodes statiques utiles sur la classe Object pour travailler avec les propriétés :

• Object.keys(obj) — retourne un tableau de tous les noms de propriétés :

  javascript

  Object.keys(person); // ['name', 'age']

• Object.values(obj) — retourne un tableau de toutes les valeurs :

  javascript

  Object.values(person); // ['Bob', 30]

• Object.entries(obj) — retourne un tableau de paires [clé, valeur] :

  javascript

  Object.entries(person); // [['name', 'Bob'], ['age', 30]]

Vérifier si une propriété existe :

• L'opérateur in vérifie la présence d'une propriété dans l'objet et sa chaîne de prototypes :

  javascript

  'name' in person; // true
  'email' in person; // false

• hasOwnProperty() vérifie uniquement l'objet lui-même (pas le prototype) :

  javascript

  person.hasOwnProperty('name'); // true

Ces outils facilitent l'inspection et l'itération sur les objets de manière dynamique.

Quand une fonction est stockée comme propriété d'un objet, elle est appelée une méthode :

const calculator = {
  result: 0,
  add: function(n) {
    this.result += n;
  },
  reset: function() {
    this.result = 0;
  },
};

calculator.add(5);
calculator.add(3);
console.log(calculator.result); // 8

Le mot-clé this à l'intérieur d'une méthode fait référence à l'objet sur lequel la méthode est appelée. Dans l'exemple ci-dessus, this.result fait référence à calculator.result.

ES6 a introduit une syntaxe abrégée de méthode qui est plus propre et plus couramment utilisée :

const calculator = {
  result: 0,
  add(n) {
    this.result += n;
  },
  reset() {
    this.result = 0;
  },
};

C'est exactement la même chose que la syntaxe plus longue add: function(n) { ... } mais plus concise.

Les méthodes peuvent aussi retourner des valeurs, tout comme les fonctions classiques :

const person = {
  firstName: 'Alice',
  lastName: 'Smith',
  fullName() {
    return this.firstName + ' ' + this.lastName;
  },
};

console.log(person.fullName()); // 'Alice Smith'

Comprendre this peut être délicat — sa valeur dépend de comment la fonction est appelée, pas de l'endroit où elle est définie. Pour l'instant, retiens simplement qu'à l'intérieur d'une méthode d'objet appelée avec la notation par point (person.fullName()), this fait référence à l'objet avant le point (person).