mozilla
Vos résultats de recherche

    Object.create()

    La méthode Object.create() crée un nouvel objet avec un prototype donné et des propriétés données.

    Syntaxe

    Object.create(proto[, objetPropriétés])

    Paramètres

    proto
    L'objet qui sera le prototype du nouvel objet créé.
    propriétés
    Paramètre optionnel. S'il est fourni et qu'il ne vaut pas undefined, il sera utilisé comme un objet dont les propriétés propres (celles qui ne sont pas héritées par la chaîne de prototypes) et énumérables définiront des descripteurs pour les propriétés à ajouter au nouvel objet, avec les mêmes noms. Ces propriétés correspondent au deuxième argument de Object.defineProperties().

    Exceptions

    Cette méthode lève une exception TypeError si le paramètre proto ne vaut pas null ou s'il n'est pas un objet.

    Exemples

    L'héritage classique avec Object.create()

    Dans l'exemple ci-dessous, on utilise Object.create() afin de réaliser un héritage de classe. Ce modèle ne supporte que l'héritage unique (un objet hérite directement uniquement d'un autre objet) car JavaScript ne gère pas l'héritage multiple.

    // Forme, la classe parente
    function Forme() {
      this.x = 0;
      this.y = 0;
    }
    
    // Méthode de la classe parente
    Forme.prototype.déplacer = function(x, y) {
      this.x += x;
      this.y += y;
      console.info('Forme déplacée.');
    };
    
    // Rectangle - classe fille
    function Rectangle() {
      Forme.call(this); // on appelle le constructeur parent
    }
    
    // La classe fille surcharge la classe parente
    Rectangle.prototype = Object.create(Forme.prototype);
    Rectangle.prototype.constructor = Rectangle;
    
    var rect = new Rectangle();
    
    console.log('rect est-il une instance de Rectangle ? ' + (rect instanceof Rectangle)); // true
    console.log('rect est-il une instance de Forme ? ' + (rect instanceof Forme)); // true
    rect.déplacer(1, 1); // Outputs, 'Forme déplacée.'
    

    Si on souhaite hériter de plusieurs objets, on peut utiliser des mixins.

    function MaClasse() {
      ClasseParente1.call(this);
      ClasseParente2.call(this);
    }
    
    MaClasse.prototype = Object.create(ClasseParente1.prototype); // héritage
    mixin(MaClasse.prototype, ClasseParente2.prototype); // mixin
    
    MaClasse.prototype.maMéthode = function() {
      // faire quelque chose
    };
    

    Ici, la fonction mixin devrait copier les fonctions du prototype de la classe parente sur le prototype de la classe fille. La fonction mixin doit être définie par l'utilisateur et ne fait pas partie de JavaScript. Un exemple de mixin peut être jQuery.extend().

    Utiliser l'argument objetPropriétés avec Object.create()

    var o;
    
    // on crée un objet avec null comme prototype
    o = Object.create(null);
    
    
    o = {};
    // est équivalent à :
    o = Object.create(Object.prototype);
    
    
    // Exemple où on crée un objet avec quelques propriétés
    // (On voit ici que le second paramètres fait correspondre les clés
    // avec des descripteurs de propriétés.)
    o = Object.create(Object.prototype, {
      // toto est une propriété de donnée
      toto: { writable: true, configurable: true, value: 'hello' },
      // truc est une propriété d'accesseur/mutateur
      truc: {
        configurable: false,
        get: function() { return 10; },
        set: function(value) { console.log('Définir `o.truc` à', value); }
    /* avec les accesseurs ES5n on aura :
        get function() { return 10; },
        set function(value) { console.log('Définir `o.truc` à', value); } */
      }
    });
    
    
    function Constructeur() {}
    o = new Constructeur();
    // est équivalent à :
    o = Object.create(Constructeur.prototype);
    // Bien entendu, si la fonction Constructeur possède des instructions
    // pour l'initialisation, Object.create() ne pourra pas le reproduire
    
    
    // on crée un nouvel objet dont le prototype est un nouvel objet vide
    // et on y ajoute une propriété 'p' qui vaut 42
    o = Object.create({}, { p: { value: 42 } });
    
    // par défaut, les propriétés ne sont PAS
    // écrivables, énumérables ou configurables
    o.p = 24;
    o.p;
    // 42
    
    o.q = 12;
    for (var prop in o) {
      console.log(prop);
    }
    // 'q'
    
    delete o.p;
    // false
    
    // Pour définir une propriété selon ES3
    o2 = Object.create({}, {
      p: {
        value: 42,
        writable: true,
        enumerable: true,
        configurable: true
      }
    });
    

    Prothèse d'émulation (polyfill)

    Ce fragment de code permet d'émuler cette méthode, sous réserve que Object.prototype.hasOwnProperty fonctionne correctement.

    if (typeof Object.create != 'function') {
      // Production steps of ECMA-262, Edition 5, 15.2.3.5
      // Reference: http://es5.github.io/#x15.2.3.5
      Object.create = (function() {
        // To save on memory, use a shared constructor
        function Temp() {}
    
        // make a safe reference to Object.prototype.hasOwnProperty
        var hasOwn = Object.prototype.hasOwnProperty;
    
        return function (O) {
          // 1. If Type(O) is not Object or Null throw a TypeError exception.
          if (typeof O != 'object') {
            throw TypeError('Object prototype may only be an Object or null');
          }
    
          // 2. Let obj be the result of creating a new object as if by the
          //    expression new Object() where Object is the standard built-in
          //    constructor with that name
          // 3. Set the [[Prototype]] internal property of obj to O.
          Temp.prototype = O;
          var obj = new Temp();
          Temp.prototype = null; // Let's not keep a stray reference to O...
    
          // 4. If the argument Properties is present and not undefined, add
          //    own properties to obj as if by calling the standard built-in
          //    function Object.defineProperties with arguments obj and
          //    Properties.
          if (arguments.length > 1) {
            // Object.defineProperties does ToObject on its first argument.
            var Properties = Object(arguments[1]);
            for (var prop in Properties) {
              if (hasOwn.call(Properties, prop)) {
                obj[prop] = Properties[prop];
              }
            }
          }
    
          // 5. Return obj
          return obj;
        };
      })();
    }
    

    Spécifications

    Spécification Statut Commentaires
    ECMAScript 5.1 (ECMA-262)
    La définition de 'Object.create' dans cette spécification.
    Standard Définition initiale. Implémentée avec JavaScript 1.8.5.
    ECMAScript 6 (ECMA-262)
    La définition de 'Object.create' dans cette spécification.
    En cours de validation comme recommandation  

    Compatibilité des navigateurs

    Fonctionnalité Chrome Firefox (Gecko) Internet Explorer Opera Safari
    Support simple 5 4.0 (2) 9 11.60 5
    Fonctionnalité Android Chrome pour Android Firefox Mobile (Gecko) IE Mobile Opera Mobile Safari Mobile
    Support simple (Oui) (Oui) 4.0 (2) (Oui) 11.50 (Oui)

    Tableau basé sur le tableau de compatibilité de Kangax.

    Voir aussi

    Étiquettes et contributeurs liés au document

    Contributors to this page: goofy_bz, SphinxKnight, XenonDeele, fqueze, gplanchat, teoli, benoit, Exalyon
    Dernière mise à jour par : SphinxKnight,