Objets

Frontend SELF FR
Niveau 36, Leçon 0
Disponible

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.

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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ême
  • writable — si la valeur peut être modifiée (false par défaut)
  • enumerable — si la propriété apparaît dans for...in et Object.keys() (false par défaut)
  • configurable — si la propriété peut être supprimée ou ses réglages modifiés (false par 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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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 :

JavaScript
    
      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) :

JavaScript
    
      let person = {
        name: 'John',
        age: 30
      };

      console.log(person.hasOwnProperty('name')); // Affichera : true
      console.log(person.hasOwnProperty('isStudent')); // Affichera : false
    
  
1
Mission
Frontend SELF FR, niveau 36, leçon 0
Bloqué
Propriétés de l'objet
Propriétés de l'objet
1
Mission
Frontend SELF FR, niveau 36, leçon 0
Bloqué
Modification des propriétés
Modification des propriétés
Commentaires
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION