Object.create()

const person = {
  isHuman: false,
  printIntroduction: function () {
    console.log(`My name is ${this.name}. Am I human? ${this.isHuman}`);
  },
};

const me = Object.create(person);

me.name = "Matthew"; // "name" is a property set on "me", but not on "person"
me.isHuman = true; // Inherited properties can be overwritten

me.printIntroduction();
// Expected output: "My name is Matthew. Am I human? true"

Object.create(proto);
Object.create(proto, objetProprits);

// Forme, la classe parente
function Forme() {
  this.x = 0;
  this.y = 0;
}

// Mthode de la classe parente
Forme.prototype.dplacer = function (x, y) {
  this.x += x;
  this.y += y;
  console.info("Forme dplace.");
};

// Rectangle - classe fille
function Rectangle() {
  // on appelle le constructeur parent
  Forme.call(this);
}

// La classe fille surcharge la classe parente
Rectangle.prototype = Object.create(Forme.prototype);

// Si on ne dfinit pas le constructeur avec Rectangle, il rcuprera le constructeur
// Forme (le parent).
Rectangle.prototype.constructor = Rectangle;

var rect = new Rectangle();

console.log("instance de Rectangle ? ", rect instanceof Rectangle);
// true
console.log("une instance de Forme ? ", rect instanceof Forme);
// true
rect.dplacer(1, 1);
// Affiche 'Forme dplace.'

function MaClasse() {
  ClasseParente1.call(this);
  ClasseParente2.call(this);
}

MaClasse.prototype = Object.create(ClasseParente1.prototype); // hritage d'une classe
Object.assign(MaClasse.prototype, ClasseParente2.prototype); // mixin pour une autre
MaClasse.prototype.constructor = MaClasse; // On raffecte le constructeur

MaClasse.prototype.maMthode = function () {
  // faire quelque chose
};

var o;

// on cre un objet avec null
// comme prototype
o = Object.create(null);

o = {};
// est quivalent  :
o = Object.create(Object.prototype);

// Exemple o on cre un objet avec quelques proprits
// (On voit ici que le second paramtres fait correspondre les cls
// avec des descripteurs de proprits.)
o = Object.create(Object.prototype, {
  // toto est une proprit de donne
  toto: { writable: true, configurable: true, value: "hello" },
  // truc est une proprit d'accesseur/mutateur
  truc: {
    configurable: false,
    get: function () {
      return 10;
    },
    set: function (value) {
      console.log("Dfinir `o.truc` ", value);
    },
    /* avec les accesseurs ES2015 on aura :
    get() { return 10; },
    set(value) { console.log('Dfinir `o.truc` ', value); } */
  },
});

function Constructeur() {}
o = new Constructeur();
// est quivalent  :
o = Object.create(Constructeur.prototype);
// Bien entendu, si la fonction Constructeur
// possde des instructions pour l'initialisation,
// Object.create() ne pourra pas le reproduire

// on cre un nouvel objet dont le prototype est
// un nouvel objet vide et on y ajoute une proprit
// 'p' qui vaut 42
o = Object.create({}, { p: { value: 42 } });

// par dfaut, les proprits ne sont PAS
// crivables, numrables 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 dfinir une proprit selon ES3
o2 = Object.create(
  {},
  {
    p: {
      value: 42,
      writable: true,
      enumerable: true,
      configurable: true,
    },
  },
);

// quivalent 
// o2 = Object.create({p: 42});