Forums : Xul, Xbl, JS...

MyView.prototype = new GenericView();

Ici, en utilisant l'operateur new pour instancier GenericView, javascript affecte implicitement la propriete --proto-- au prototype de l'objet MyView.
--proto-- aide a retrouver quelles proprietes utiliser dans la chaine de prototypes.

MyView.prototype = GenericView.prototype;

Dans ce cas, la propriete --proto-- n'est pas utilisee. Je n'ai jamais teste via cette semantique, mais cela ne me semble pas correct.
Le prototype de MyView maintien une reference directe sur le prototype de GenericView.
Pas de chaine, pas d'heritage.

Quand tu appelles MyView.propriete, appelles-tu la propriete de MyView ou de GenericView?

Quand tu appelles MyView.propriete, appelles-tu la propriete de MyView ou de GenericView?

C'est justement pour ça que je pose la question car j'ai le même résultat dans les 2 cas: c'est bien la méthode de GenericView qui est appelée (sauf, bien sur, si je la redéfinis dans MyView)

Exemple

function A()
  {
  }

A.prototype =
  {
  test: function()
    {
    alert("A.test()");
    }
  }

function B()
  {
  }

B.prototype = new A(); // ou B.prototype = A.prototype;

var b = new B();

b.test();

Là j'appelle bien la méthode de A avec les 2 versions.

Le chainage me semble correct aussi, que ce soit avec new ou prototype, car même si je redéfinis une méthode de A après la création d'une instance de B j'appelle bien la méthode redéfinie.

var b = new B();

A.prototype.test = function()
  {
  alert("A.test() redéfini");
  }

b.test(); // Appel correct de A.test() redéfini

Bref je ne vois pas vraiment de différence entre les deux.

Merci

Je ne vois pas ou est definie dans l'exemple ci dessus la fonction test() pour l'objet B.

Une fois definie, reste a tester dans les 2 cas, si test() est bien appelee pour B (et pas pour A).

Je ne vois pas ou est definie dans l'exemple ci dessus la fonction test() pour l'objet B.

Elle n'est pas définie car je ne veux pas la définir je veux utiliser celle de A, mais si je définis test() pour B j'ai toujours le même comportement correct, appel de B.test(), avec les 2 manières (new ou prototype):

B.prototype = A.prototype; // ou new A()

B.prototype.test = function()
  {
  alert("B.test()");
  }

var b = new B();

b.test(); // Appel correct de B.test()

J'ai trouvé une différence (logique) entre les 2 manières. En copiant le prototype le constructeur n'est pas appelé et toutes les propriétés et méthodes définies dans le constructeur du parent n'existent pas dans l'héritage:

function A()
  {
  this.foo = "A.foo";
  }

function B()
  {
  }

prototype:

B.prototype = A.prototype;

var b = new B();

alert(b.foo); // = undefined car A() n'est pas appelé

new:

B.prototype = new A();

var b = new B();

alert(b.foo); // OK affiche bien "A.foo"

J'en conclu donc que c'est mieux d'hériter via new, comme me l'a suggéré souqueta.

Merci je pense que c'est résolu.