ES3 en détail

Les constructeurs et les prototypes en JavaScript

Bruno Lesieur

Ce tutoriel va traiter de deux points importants de l'implémentation de la programmation orientée objet du point de vue de JavaScript, les fonctions constructeurs et la chaîne des prototypes.

Commentez ♪

- Titre : ES3 en détail

- Auteur : Bruno Lesieur

- Parution : 24 janvier 2019

- Licence : Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2019 Bruno Lesieur. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Voir également :

- ES3 en détail - les contextes d'exécution en JavaScript

- ES3 en détail - l'objet des variables en JavaScript

- ES3 en détail - la valeur de this en JavaScript

- ES3 en détail - la chaîne des portées en JavaScript

- ES3 en détail - les fonctions

- ES3 en détail - Les fermetures en JavaScript

- ES3 en détail - Les types en JavaScript

Sommaire

- I. Introduction

- II. Constructeur

- II-A. Algorithme de création d'objets

- II-B. Résumons

- III. Prototype

- III-A. Propriété constructor

- III-B. Propriétés explicites prototype vs. propriétés implicite [[Prototype]]

- III-C. La propriété non standard __proto__

- III-D. L'objet est indépendant de son constructeur

- III-E. L'opérateur instanceof

- III-F. Stockage via prototype pour partager des méthodes et propriétés

- IV. Lire et écrire des propriétés

- IV-A. La méthode [[Get]]

- IV-B. La méthode [[Put]]

- IV-C. Accesseurs de propriété

- V. Héritage

- V-A. Chaîne de prototype

- VI. Conclusion

- VII. Remerciements

I - Introduction

Le JavaScript est un langage de programmation orienté objet supportant l'héritage par délégation basé sur les prototypes. À ce titre donc, il existe des fonctions constructeurs en rapport avec l'utilisation du mot-clé new pour la création d'objets d'une part, et il existe d'autre part un mécanisme appelé chaîne des prototypes s'occupant de gérer l'héritage. Nous allons étudier ces deux aspects dans ce tutoriel. En complément nous en profiterons pour étudier les méthodes d'accès à un objet qui font appel à la chaîne des prototypes et d'où la notion d'héritage découle.

II - Constructeur

Les objets en JavaScript sont créés à l'aide de ce que l'on appelle : les constructeurs.

Un constructeur est une fonction qui crée et initialise l'objet nouvellement créé.

Pour la création (allocation de mémoire) de l'objet, une méthode interne [[Construct]] est utilisée. Le comportement de cette méthode interne est défini par l'implémentation. Tous les constructeurs de fonctions utilisent cette méthode pour allouer de la mémoire aux nouveaux objets.

Pour l'initialisation de l'objet, c'est cette fois la méthode interne [[Call]] qui s'en occupe en appelant une fonction dédiée dans le contexte de l'objet nouvellement créé.

Notez que d'un point de vue utilisateur, seule la phase d'initialisation est accessible et programmable. Cet objet nouvellement créé est accessible dans cette fonction d'initialisation via this. C'est cet objet this qui sera implicitement retourné. Nous pouvons, puisque nous avons la main sur cette phase d'initialisation, retourner autre chose que cet objet nouvellement créé, si l'envie nous en prend avec return :

1. // Cette fonction est un constructeur...

2. function Character() {

3. // mettre à jour l'objet nouvellement créé

4. this.level = 10;

5. //, mais retourner un objet différent

6. return [1, 2, 3];

7. }

8. // ...si elle est appelée avec le mot-clé `new`

9. var tiz = new Character();

10. console.log(tiz.level, tiz); `undefined`, `[1, 2, 3]`

En faisant référence à l'algorithme de création de fonction dont nous avons discuté dans ce tutoriel, nous voyons que cette fonction est un objet natif se trouvant parmi d'autres propriétés internes, comme [[Construct]] et [[Call]] ou propriétés explicites comme prototype, la référence au prototype des futurs objets.

Pseudo-code

1. F = new NativeObject() // objet natif inaccessible

3. F.[[Class]] = "Function"

5. .... // autres propriétés

7. F.[[Call]] = <réference à la fonction> // la fonction elle-même

9. F.[[Construct]] = internalConstructor // constructeur interne général pour l'allocation mémoire

11. .... // autres propriétés

13. // prototype de l'objet créé par le constructeur de F

14. __objectPrototype = new Object()

15. __objectPrototype.constructor = F // `{DontEnum}`

16. F.prototype = __objectPrototype

Ainsi, un objet qui peut être activé par l'appel des parenthèses ( et ) est appelé une fonction, et possède donc cette propriété [[Call]]. Il y a également la propriété [[Class]] qui est responsable de la distinction entre un objet simple et un objet activable puisque, dans le cas d'une fonction, celui-ci vaut "Function". L'opérateur typeof, sur ces objets, retourne la valeur function. Cependant, cela est vrai pour des objets natifs. Dans le cas d'objets hôtes activables, l'opérateur typeof peut retourner d'autres valeurs. Exemple avec window.console.log(...) dans IE :

1. // dans IE : "Object", "object", dans d'autres : "Function", "function"

2. console.log(Object.prototype.toString.call(window.console.log));

3. console.log(typeof window.console.log); // "Object"

La méthode interne [[Construct]] est activée avec l'opérateur new appliqué à la fonction dite constructeur. Comme nous l'avons vu, c'est cette méthode qui est responsable de l'allocation mémoire et de la création des objets. S'il n'y a aucun argument, l'appel entre parenthèses peut être omis :

1. function Character(level) { // constructeur `Character`

2. this.level = level || 10;

3. }

5. // sans arguments, l'appel

6. // avec les parenthèses peut être omis

7. var agnes = new Character; // ou `new Character()`;

8. console.log(agnes.level); // `10`

10. // passage explicite

11. // de la valeur de l'argument `level`

12. var edea = new Character(20);

13. console.log(edea.level); // `20`

Et comme nous le savons également la valeur de this à l'intérieur du constructeur (lors de la phase d'initialisation) est affectée d'un nouvel objet.

II-A - Algorithme de création d'objets

Le comportement de la méthode [[Construct]] peut être décrit ainsi :

Pseudo-code

1. O = new NativeObject()

3. // la propriété `[[Class]]` est mise à `"Object"`,

4. // c.-à-d. représente un simple objet

5. O.[[Class]] = "Object"

7. // Prend comme référence de prototype

8. // la valeur de `F.prototype` de la fonction

9. var __objectPrototype = F.prototype

11. // on associe le prototype `O.[[Prototype]]` de l'objet créé

12. if (isAnObject(__objectPrototype)) {

13. O.[[Prototype]] = __objectPrototype

14. } else {

15. O.[[Prototype]] = Object.prototype

16. }

18. // initialisation du nouvel objet créé

19. // utilisation de `F.[[Call]]`;

20. // affectation à la valeur de `this` de l'objet `O`

21. // `initialParameters` sont les arguments passés au constructeur

22. R = F.[[Call]].apply(O, initialParameters)

24. if (isAnObject(R)) {

25. // on retourne ce que l'utilisateur demande avec `return`

26. return R

27. } else {

28. // sinon on retourne l'objet nouvellement créé

29. return O

30. }

Notez deux fonctionnalités majeures :

- premièrement, le [[Prototype]] de l'objet créé est défini à partir de la propriété prototype d'une fonction au moment courant (cela signifie que le prototype de deux objets créés depuis un même constructeur peut varier si la propriété prototype de la fonction change ensuite) ;

- deuxièmement, comme nous l'avons mentionné plus haut, si lors de l'initialisation de l'objet, [[Call]] retourne un objet, c'est cet objet qui sera utilisé comme le résultat de l'expression avec mot clé new :

1. function Character() {}

2. Character.prototype.level = 10;

4. var ringabel = new Character();

5. console.log(a.level); // `10` par délégation, depuis le prototype

7. // affectons a la propriété `prototype` un nouvel objet

8. // qui va explicitement définir la propriété `constructeur`

9. Character.prototype = {

10. constructor: Character,

11. hp: 100

12. };

14. var yew = new Character();

15. // objet `yew` a un nouveau prototype

16. console.log(yew.level); // `undefined`

17. console.log(yew.hp); // `100` par délégation, depuis le prototype

19. // cependant, le prototype de l'objet `ringabel`

20. // est toujours l'ancien (nous allons voir pourquoi plus bas)

21. console.log(ringabel.level); // `10` par délégation, depuis le prototype

23. function Asterisk() {

24. this.power = 10;

25. return new Array();

26. }

28. // si le constructeur de `Asterisk` n'a pas de `return`

29. // (ou retourne `this`), et bien l'objet `this`

30. // sera utilisé, sinon ça sera le tableau

31. var knight = new Asterisk();

32. console.log(knight.power); // `undefined`

33. console.log(Object.prototype.toString.call(knight)); // `[object Array]`

II-B - Résumons

Tout objet activable (appelable ou exécutable) est une fonction. Les fonctions activées avec le mot clé new sont dites des fonctions constructeurs (toute fonction est donc possiblement un constructeur dès lors qu'elle ne retourne rien, ou qu'elle retourne this). C'est ce mécanisme qui crée de nouveaux objets en mémoire basés sur un prototype.

Regardons maintenant ce prototype plus en détail.

III - Prototype

Tous les objets ont un prototype (exception faite de certains objets systèmes). La communication avec le prototype est organisée via la propriété interne, implicite et inaccessible [[Prototype]]. Un prototype peut être aussi bien un _objet que la valeur null.

III-A - Propriété constructor

Dans l'exemple ci-dessus, il y a deux points importants. Le premier concerne la propriété constructor de la propriété prototype.

Comme nous l'avons vu dans l'algorithme de la fonction de création d'objets, la propriété constructor est affectée à la propriété prototype lors de la phase de création de la fonction. La valeur de cette propriété est une référence circulaire à la fonction elle-même :

1. function Character() {}

2. var magnolia = new Character();

3. console.log(magnolia.constructor); // `function Character() {}` par délégation

4. console.log(magnolia.constructor === Character); // `true`

Souvent dans ce cas il y a un malentendu. La propriété constructor est incorrectement traitée comme une propriété appartenant à l'objet créé. Alors que, comme nous venons de le voir, cette propriété appartient au prototype de la fonction constructeur (ici Character) et est accessible par héritage.

Via la propriété constructor héritée, les objets créés peuvent indirectement obtenir une référence sur l'objet prototype du constructeur :

1. function Character() {}

2. Character.prototype.level = new Number(10);

4. var janne = new Character();

5. console.log(janne.constructor.prototype); // `[object Object]`

7. console.log(janne.level); // `10`, par délégation

8. // la même chose que `janne.[[Prototype]].level`

9. console.log(janne.constructor.prototype.level); // `10`

11. console.log(janne.constructor.prototype.level === janne.level); // `true`

Notez que les propriétés constuctor et prototype peuvent être redéfinies après que l'objet soit créé. Dans ce cas l'objet perd la référence mise en place par le mécanisme ci-dessus.

Cependant, si nous changeons la propriété prototype de la fonction complètement (en assignant un nouvel objet), la référence au constructeur original (ainsi que le prototype original) sont perdu.

1. function Character() {}

2. Character.prototype = {

3. level: 10

4. };

6. var nikolai = new Character();

7. console.log(nikolai.level); // `10`

8. console.log(nikolai.constructor === Character); // `false` !

Et donc c'est pourquoi il est intéressant de restaurer la référence manuellement :

1. function Character() {}

2. Character.prototype = {

3. constructor: Character,

4. level: 10

5. };

7. var nikolai = new Character();

8. console.log(nikolai.x); // `10`

9. console.log(nikolai.constructor === Character); // `true`

Notons cependant que la propriété constructor manuellement restaurée, par contraste avec l'originale perdue, n'a pas d'attribut {DontEnum} et, par conséquent, est énumérable dans une boucle for..in sur le Character.prototype.

ES5 introduit la possibilité de contrôler l'état de l'énumération des propriétés avec l'attribut [[Enumerable]].

1. var airy = { level: 10 };

3. Object.defineProperty(airy, "advice", {

4. value: 20,

5. enumerable: false // aka `{DontEnum} = true`

6. });

8. console.log(airy.level, airy.advice); // `10`, `20`

10. for (var k in airy) {

11. console.log(k); // only `level`

12. }

14. var levelDesc = Object.getOwnPropertyDescriptor(airy, "level");

15. var adviceDesc = Object.getOwnPropertyDescriptor(airy, "advice");

17. console.log(

18. levelDesc.enumerable, // `true`

19. adviceDesc.enumerable  // `false`

20. );

III-B - Propriétés explicites prototype vs. propriétés implicite [[Prototype]]

Souvent, le prototype [[Prototype]] d'un objet, qui est interne à l'objet et inaccessible, est incorrectement confondu avec la référence explicite prototype de la fonction constructeur à ce prototype. Oui, effectivement, ils font référence au même objet, mais ce sont deux propriétés différentes :

1. a.[[Prototype]] ----> Prototype <---- A.prototype

De plus, le [[Prototype]] d'un objet créé par un constructeur donne la valeur que possédait la propriété prototype du constructeur lors de la phase de création de l'objet.

Cependant, remplacer la propriété prototype du constructeur n'affecte pas la référence [[Prototype]] des objets déjà créés. Ce sera uniquement la propriété prototype du constructeur qui changera ! Cela signifie que des nouveaux objets auront ce nouveau prototype, mais les objets déjà créés (avant que la propriété prototype ne change), auront une référence vers le vieux prototype. Cette référence ne pourra plus être changée :

Pseudo-code

1. // Création de `anne`

2. anne = new Character

4. // État avant le changement de `A.prototype`

5. anne.[[Prototype]] // ----> Prototype

6. Character.prototype // ----> Prototype

8. // Changement de prototype

9. Character.prototype = newPrototype

11. // Création de `airy`

12. airy = new Character

14. // État après changement

15. Character.prototype ----> newPrototype

16. anne.[[Prototype]] ----> Prototype // les objets déjà créés ont une référence à l'ancien prototype

17. airy.prototype ----> newPrototype // les nouveaux objets auront une référence au nouveau prototype

Par exemple :

1. function Character() {}

2. Character.prototype.level = 10;

4. var tiz = new Character();

5. console.log(tiz.level); // `10`

7. Character.prototype = {

8. constructor: Character,

9. level: 20,

10. hp: 30

11. };

13. // l'objet `tiz` utilise l'ancien

14. // prototype via sa référence

15. // implicite `[[Prototype]]`

16. console.log(tiz.level); // `10`

17. console.log(tiz.hp) // `undefined`

19. var yew = new Character();

21. //, mais les nouveaux objets, à la création,

22. // ont bien une référence au nouveau prototype

23. console.log(yew.level); // `20`

24. console.log(yew.hp); // `30`

Parfois on peut lire des articles sur le JavaScript disant que « le changement dynamique de l'objet du prototype va affecter tous les objets qui auront ce nouveau prototype » ; cela est incorrect. Un nouveau prototype réaffecté sera utilisé uniquement sur les nouveaux objets créés après le changement.

La règle principale ici c'est : le prototype d'un objet est assigné au moment de la création et ne peut pas être réassigné par celui que les nouveaux objets auront. En utilisant la référence explicite prototype depuis le constructeur, il est uniquement possible de muter l'objet, c.-à-d. d'ajouter, de modifier ou de supprimer des propriétés existantes dans le prototype de l'objet afin de répercuter les changements dans les objets déjà créés.

III-C - La propriété non standard __proto__

Cependant, certaines implémentations, par exemple, SpiderMonkey, fournissent une référence explicite vers l'objet du prototype via la propriété non standard __proto__ :

1. function Character() {}

2. Character.prototype.level = 10;

4. var agnes = new Character();

5. console.log(agnes.level); // `10`

7. var __newPrototype = {

8. constructor: Character,

9. level: 20,

10. hp: 30

11. };

13. // référence au nouvel objet

14. Character.prototype = __newPrototype;

16. var ringabel = new Character();

17. console.log(ringabel.level); // `20`

18. console.log(ringabel.hp); // `30`

20. // `agnes` utilise toujours une référence

21. // sur l'ancien objet

22. console.log(agnes.level); // `10`

23. console.log(agnes.hp); // `undefined`

25. // changeons explicitement le prototype de `agnes`

26. agnes.__proto__ = __newPrototype;

28. // maintenant `agnes` fait également

29. // référence au nouvel objet

30. console.log(agnes.level); // `20`

31. console.log(agnes.hp); // `30`

Notez que ES5 a introduit la méthode Object.getPrototypeOf qui retourne directement la valeur de la propriété [[Prototype]] d'un objet, le prototype original de l'instance. Cependant, à la différence de __proto__, cela ne fournit qu'un accesseur, et ne permet en aucun cas de changer le prototype.

1. var luxendarc = {};

2. Object.getPrototypeOf(luxendarc) == Object.prototype; // `true`

III-D - L'objet est indépendant de son constructeur

Comme le prototype de l'objet créé est indépendant du constructeur et de la propriété prototype du constructeur, cela permet la chose suivante : l'objet du prototype de la phase de création peut être supprimé. Le prototype de l'objet créé va continuer d'exister, toujours référencé par la propriété [[Prototype]] :

1. function Asterisk() {}

2. Asterisk.prototype.power = 10;

4. var whiteMage = new Asterisk();

5. console.log(whiteMage.power); // `10`

7. // mise explicite de la référence

8. // du constructeur `Asterisk` à `null`

9. Asterisk = null;

11. //, mais, il est toujours possible de créer

12. // des objets via la référence indirecte

13. // depuis les autres objets si

14. // la propriété `constructor` n'a pas été changée

15. var blackMage = new whiteMage.constructor();

16. console.log(blackMage.power); // `10`

18. // suppression de la référence implicite,

19. // après ça, `whiteMage.constructor` ainsi que `blackMage.constructor`

20. // feront référence à la fonction `Object`

21. // par défaut, mais plus à `Asterisk`

22. delete whiteMage.constructor.prototype.constructor;

24. // il ne sera plus possible de créer des objets

25. // du constructeur `Asterisk`

26. //, mais ces deux objets auront toujours

27. // une référence à leur prototype dans `[[Prototype]]`

28. console.log(whiteMage.power); // `10`

29. console.log(blackMage.power); // `10`

III-E - L'opérateur instanceof

Il y a un lien entre la référence explicite au prototype, via la propriété prototype du constructeur et l'opérateur instanceof.

Cet opérateur fonctionne de pair avec la chaîne des prototypes d'un objet et pas uniquement avec son constructeur lui-même. Prenez ça en compte, car il y a souvent des incompréhensions à ce niveau. Quand on fait cette vérification :

1. if (tiz instanceof Character) {

2. /* ... */

3. }

cela ne veut pas dire que l'objet tiz a été créé par le constructeur Character !

Tout ce que fait l'opérateur instanceof c'est de prendre la valeur de Character.prototype et vérifier sa présence dans la chaîne des prototypes de tiz, en commençant par tiz.[[Prototype]]. L'opérateur instanceof est activé par la méthode interne [[HasInstance]] du constructeur.

Regardons un exemple :

1. function Character() {}

2. Character.prototype.level = 10;

4. var magnolia = new Character();

5. console.log(magnolia.level); // `10`

7. console.log(level instanceof Character); // `true`

9. // Si maintenant on met `Character.prototype`

10. // à `null`...

11. Character.prototype = null;

13. // ...et bien l'objet `magnolia` a

14. // toujours accès à son

15. // prototype, via `magnolia.[[Prototype]]`

16. console.log(magnolia.level); // `10`

18. // cependant, l'opérateur `instanceof`

19. // ne pourra plus fonctionner, car

20. // il commence son examen depuis la

21. // propriété `prototype` du constructeur.

22. console.log(magnolia instanceof Character); // `Character.prototype` n'est pas défini`

Il est également possible de créer soit même le constructeur d'un objet, et instanceof retournera true en vérifiant l'instance d'un autre objet. Tout ce qu'il faut faire c'est définir soi- même la propriété d'objet [[Prototype]] et la propriété prototype du constructeur avec le même objet :

1. function Asterisk() {}

2. var thief = new Asterisk();

4. console.log(thief instanceof Asterisk); // `true`

6. function Weapon() {}

8. var __proto = {

9. constructor: Weapon

10. };

12. Weapon.prototype = __proto;

13. thief.__proto__ = __proto;

15. console.log(thief instanceof Weapon); // `true`

16. console.log(thief instanceof Asterisk); // `false`

III-F - Stockage via prototype pour partager des méthodes et propriétés

L'application la plus utile des prototypes en JavaScript est le stockage des méthodes, des états par défaut et des propriétés partagées des objets.

En effet, les objets peuvent avoir leur propre état, mais les méthodes sont habituellement les mêmes. C'est pourquoi, pour une optimisation de la mémoire, les méthodes sont habituellement définies dans le prototype. Cela signifie que tous les objets créés par un constructeur partagent toujours les mêmes méthodes.

1. function Character(stat) {

2. this.stat = stat || 100;

3. }

5. Character.prototype = (function () {

7. // initialisation du contexte,

8. // utilisation d'un objet additionnel

10. var sharedStat = 500;

12. function helper() {

13. console.log('stat partagée : ' + sharedStat);

14. }

16. function attack() {

17. console.log('attaque : ' + this.stat);

18. }

20. function defence() {

21. console.log('défense : ' + this.stat);

22. helper();

23. }

25. // le prototype lui-même.

26. return {

27. constructor: Character,

28. attack: attack,

29. defence: defence

30. };

32. })();

34. var tiz = new Character(10);

35. var agnes = new Character(20);

37. tiz.attack(); // `attaque : 10`

38. tiz.defence(); // `défense : 10`, `stat partagée : 500`

40. agnes.attack(); // `attaque : 20`

41. agnes.defence(); // `défense : 20`, `stat partagée : 500`

43. // les deux objets utilisent

44. // la même méthode

45. // le même prototype

46. console.log(tiz.attack === agnes.attack); // `true`

47. console.log(tiz.defence === agnes.defence); // `true`

IV - Lire et écrire des propriétés

Comme nous l'avons déjà mentionné, lire et écrire des propriétés se fait grâce à l'aide des méthodes internes [[Get]] et [[Put]]. La méthode est activée grâce à l'accesseur de propriété que ce soit via la notation par point ou par crochet droit :

1. // écrire

2. yew.level = 10; // `[[Put]]` est appelée

4. console.log(yew.level); // `10`, `[[Get]]` est appelée

5. console.log(yew['level']); // la même chose

IV-A - La méthode [[Get]]

La méthode [[Get]] considère les propriétés venant de la chaîne des prototypes comme des objets aussi. Ainsi, les propriétés d'un prototype sont accessibles depuis l'objet lui-même. Ainsi pour O.[[Get]](P) avec O comme objet et P comme propriété réclamée, nous avons le mécanisme suivant :

1. // si c'est sa propre propriété,

2. // on la retourne

3. if (O.hasOwnProperty(P)) {

4. return O.P

5. }

7. // sinon, on analyse le prototype

8. var __proto = O.[[Prototype]]

10. // s'il n'y a pas de prototype (cela est possible dans le dernier maillon de la chaîne pour `Object.prototype.[[Prototype]]`,

11. // qui est égale à `null`),

12. // on retourne `undefined`

13. if (__proto === null) {

14. return undefined

15. }

17. // sinon, on appelle la méthode `[[Get]]` récursivement

18. // maintenant pour le prochain prototype ; c.-à-d.

19. // que l'on traverse la chaîne des prototypes: et on essaye de trouver

20. // la propriété, puis ensuite dans le prototype de prototype

21. // et ainsi de suite jusqu'à ce que le prototype soit égal à `null`

22. return __proto.[[Get]](P)

Notez que, puisque la méthode [[Get]] dans un des cas retourne undefined, il est possible de vérifier la présence d'une variable comme ceci :

1. if (window.someObject) {

2. /* ... */

3. }

Ici, la propriété someObject n'est pas trouvée dans window, ni dans le prototype, ni dans le prototype du prototype, et l'algorithme retourne alors undefined.

Notez que c'est exactement le test de présence dont est responsable l'opérateur in. Il va également fouiller dans la chaîne des prototypes :

1. if ('someObject' in window) {

2. /* ... */

3. }

Cela aide a éviter les cas où, par exemple, someObject serait égale à false et ou le première vérification aurait échouée malgré l'existence de la propriété.

IV-B - La méthode [[Put]]

La méthode [[Put]] quand a elle, met à jour sa propre propriété d'objet et masque les propriétés du même nom venant d'un prototype plus haut. Voyons cela avec l'algorithme de O.[[Put]](P, V) ou O est l'objet, P la propriété et V la valeur.

1. O.[[Put]](P, V):

3. // s'il n'est pas possible d'écrire

4. // dans cette propriété

5. // alors on ne fait rien.

6. if (!O.[[CanPut]](P)) {

7. return

8. }

10. // si l'objet ne possède pas cette propriété,

11. // alors on la crée; tous les attributs

12. // de propriété étant placés à `false`.

13. if (!O.hasOwnProperty(P)) {

14. createNewProperty(O, P, attributes: {

15. ReadOnly: false,

16. DontEnum: false,

17. DontDelete: false,

18. Internal: false

19. })

20. }

22. // changer la valeur.

23. // si la propriété existait déjà, ses

24. // attributs restent inchangés, seule la valeur

25. // change

26. O.P = V

28. return

Par exemple :

1. Object.prototype.level = 100;

3. var edea = {};

4. console.log(edea.level); // `100`, hérité

6. edea.level = 10; // `[[Put]]`

7. console.log(edea.level); // `10`, possédé

9. delete edea.level;

10. console.log(edea.level); // again `100`, hérité

Notez qu'il n'est pas possible de masquer des propriétés héritées en lecture seule. Le résultat de l'affectation est simplement ignoré. Ceci est contrôlé par la méthode interne [[CanPut]].

1. // Par exemple, la propriété `length`

2. // de l'objet `String` est en lecture seule ; faisons de

3. // `String` le prototype de notre objet et essayons

4. // de masquer la propriété `length`

6. function SuperString() {

7. /* rien */

8. }

10. SuperString.prototype = new String("abc");

12. var luxendarc = new SuperString();

14. console.log(luxendarc.length); // `3`, la longueur de `abc`

16. // essayons de la masquer

17. luxendarc.length = 5;

18. console.log(luxendarc.length); // toujours `3`

En mode strict de ES5, tenter de modifier une propriété en lecture seule lève l'erreur TypeError.

IV-C - Accesseurs de propriété

Comme expliqué, les méthodes internes [[Get]] et [[Put]] sont activées par les accesseurs de propriété disponibles dans JavaScript via la notation avec point ou la notation avec _crochet droit. La notation avec point est utilisée quand le nom de propriété est un identifieur valide ou connu à l'avance, alors que la notation avec crochet droit permet l'utilisation de noms invalides ou dynamiques.

1. var rpg = { testProperty: 10 };

3. console.log(rpg.testProperty); // `10`, notation avec point

4. console.log(rpg['testProperty']); // `10`, notation avec crochet droit

6. var propertyName = 'Propriété';

7. console.log(rpg['test' + propertyName]); // `10`, notation dynamique avec crochet

Il y a encore une fonctionnalité importante : les accesseurs appellent toujours la conversion ToObject pour les objets placés sur la partie gauche de la propriété accession. Et du fait de cette conversion implicite, il est possible de dire « tout en JavaScript est un objet » (cependant comme nous le savons déjà, bien entendu, tout n'est pas objet, il y a également des valeurs primitives).

Si nous utilisons des accesseurs de propriété sur des valeurs primitives, nous créons juste un objet encadrant immédiat correspondant à cette valeur. Une fois le travail terminé, cet objet encadrant est supprimé.

Exemple :

1. var level = 10; // valeur primitive

3. //, mais si on le demande, il y aura

4. // accès à la méthode, comme si c'était un objet.

5. console.log(level.toString()); // `"10"`

7. // nous pouvons également

8. // (tenter de) créer une nouvelle

9. // propriété dans la primitive `level` en appelant `[[Put]]`

10. level.test = 100; // et cela semble fonctionner.

12. //, mais, `[[Get]]` ne retourne

13. // pas la valeur de cette propriété, et

14. // l'algorithme retourne `undefined`

15. console.log(level.test); // `undefined`

Alors, pourquoi, dans cet exemple, la valeur « primitive » de level à accès à la méthode toString, mais n'a pas accès à la propriété nouvellement créée test ?

La réponse est simple :

en premier lieu, comme déjà dit, après que l'accesseur de propriété ait été appliqué, on ne manipule pas une primitive, mais un objet intermédiaire. Dans ce cas, new Number(level) est utilisé, et par délégation la méthode toString de la chaîne du prototype :

Pseudo-code

1. // Algorithme d'évaluation de `level.toString()`

3. // 1.

4. wrapper = new Number(level)

5. // 2.

6. wrapper.toString() // `"10"`

7. // 3.

8. delete wrapper

Maintenant, la méthode [[Put]] crée également son propre objet intermédiaire englobant quand la propriété test est évaluée :

Pseudo-code

1. // Algorithme d'évaluation de `level.test = 100`

3. // 1.

4. wrapper = new Number(level)

5. // 2.

6. wrapper.test = 100

7. // 3.

8. delete wrapper

Nous voyons à l'étape 3 que l'objet encadrant est supprimé et que la propriété test nouvellement créée a été supprimée elle aussi à la suppression de l'objet lui-même.

Quand [[Get]] est utilisé de nouveau sur l'accesseur de propriété créé, il crée encore une fois un nouvel objet encadrant qui lui, ne sait rien à propos d'une quelconque propriété test :

Pseudo-code

1. // Algorithme d'évaluation de `level.test`

3. // 1.

4. wrapper = new Number(level)

5. // 2.

6. wrapper.test // `undefined`

7. // 3.

8. delete wrapper

Donc faire référence à une propriété ou méthode depuis une valeur primitive n'a de sens que pour la lecture des propriétés. Aussi, quand une valeur primitive accède souvent à des propriétés, pour économiser du temps de ressources, cela peut avoir du sens de directement la remplacer par sa représentation objet. Et, au contraire, si la valeur n'est utilisée que pour de petits calculs qui ne dépendent d'aucune propriété d'accès, il sera plus performant d'utiliser une valeur primitive à la place.

V - Héritage

Comme nous le savons, le JavaScript utilise l'héritage par délégation basé sur les prototypes.

Chaînage et prototype sont également souvent mentionnés en tant que chaîne de prototype.

En fait, l'intégralité de l'implémentation et l'analyse de la délégation se réduit au travail effectué par [[Get]] et déjà mentionné précédemment.

Si vous comprenez intégralement ce simple algorithme de la méthode [[Get]], la question de l'héritage en JavaScript disparaît d'elle-même et la réponse devient claire.

Souvent sur les forums, quand les discussions se tournent vers l'héritage en JavaScript, je montre, en tant qu'exemple, seulement une ligne de code JavaScript qui représente exactement la définition d'une structure d'objet du langage et montre la délégation basée sur l'héritage. La ligne de code est vraiment simple :

1. console.log(1..toString()); // `"1"`

Maintenant, comme nous connaissons l'algorithme de la méthode [[Get]] et les accesseurs de propriétés, nous pouvons voir ce qu'il se passe ici :

1. Depuis la valeur primitive 1, un objet encadrant équivalent à new Number(1) est créé ;

2. La méthode toString héritée est appelée depuis cet objet encadrant.

Pourquoi héritée ? Car les objets JavaScript peuvent avoir leurs propres propriétés, et que l'objet encadrant créé dans ce cas n'a pas sa propre méthode toString. Cependant, il en hérite par délégation via son prototype, c’est-à-dire utilise Number.prototype.

Notez la subtilité de la syntaxe. Deux points dans l'exemple précédent n'est pas une erreur. Le premier point est utilisé pour la partie fractionnée du nombre, et le second point est quant à lui l'accesseur de propriété :

1. 1.toString(); // `SyntaxError` !

3. (1).toString(); // OK

5. 1 .toString(); // OK (espace après 1)

7. 1..toString(); // OK

9. 1['toString'](); // OK

V-A - Chaîne de prototype

Montrons comment créer cette chaîne avec des objets définis par les utilisateurs. C'est très simple :

1. function Monster() {

2. console.log('Monster.[[Call]] activé');

3. this.attack = 10;

4. }

5. Monster.prototype.power = 20;

7. var monster = new Monster();

8. console.log([monster.attack, monster.power]); // `10` (possédé), `20` (délégué)

10. function Humanoid() {}

12. // la variante la plus simple du chaînage de prototype

13. // est de chaîner la valeur d'un enfant prototype

14. // a un nouvel objet créé,

15. // avec le constructeur du parent.

16. Humanoid.prototype = new Monster();

18. // fixons la propriété `constructor`, sinon elle vaudra `Monster`

19. Humanoid.prototype.constructor = Humanoid;

21. var goblin = new Humanoid();

22. console.log([goblin.attack, goblin.power]); // `10`, `20`, les deux sont délégués

24. // `[[Get]] goblin.attack` :

25. // `goblin.attack` (pas trouvé) -->

26. // `goblin.[[Prototype]].attack` (trouvé) - `10`

28. // `[[Get]] goblin.power` :

29. // `goblin.power` (pas trouvé) -->

30. // `goblin.[[Prototype]].power` (pas trouvé) -->

31. // `goblin.[[Prototype]].[[Prototype]].power` (trouvé) - `20`

33. // où `goblin.[[Prototype]] === Humanoid.prototype`,

34. // et `goblin.[[Prototype]].[[Prototype]] === Monster.prototype`

Cette approche a deux fonctionnalités.

La première, Humanoid.prototype va contenir la propriété attack. Mais cela n'est pas correct puisque la propriété attack est définie dans Monster lui-même et que même s'il pourrait être attendu que le constructeur Humanoid le possède aussi, ce n'est pas le cas.

Dans le cas d'une traversée d'héritage prototypal normal, jusqu'à l'objet descendant, personne ne possède sa propre propriété déléguée d'un prototype. L'idée derrière ça, c'est que les objets créés par le constructeur Humanoid n'_ont _pas besoin de la propriété attack. Ce qui n'est pas le cas des modèles basés sur les classes, où toute propriété est copiée dans la classe descendante.

Cependant, s'il est nécessaire que la propriété attack soit propre aux objets créés par le constructeur Humanoid, il existe certaines techniques pour cela (émulation d'une approche basée sur la classe), dont nous allons parler ci-dessous.

La seconde n'est pas vraiment une fonctionnalité, mais un désavantage. Le code du constructeur est aussi exécuté quand le descendant du prototype est créé. Nous pouvons voir ça grâce au message "Monster.[[Call]] activé" qui apparaît deux fois, quand l'objet est créé par le constructeur Monster qui est utilisé par Humanoid.prototype et lors de la création de l'objet monster lui-même !

Un exemple plus critique est une exception lancée dans le constructeur parent : peut-être que pour un objet réellement créé par ce constructeur, une vérification est nécessaire, mais le même cas est totalement inacceptable avec l'utilisation de cet objet comme prototype parent :

1. function Monster(param) {

2. if (!param) {

3. throw 'Paramètre requis';

4. }

5. this.param = param;

6. }

7. Monster.prototype.attack = 10;

9. var monster = new Monster(20);

10. console.log([monster.attack, monster.param]); // `10`, `20`

12. function Humanoid() {}

13. Humanoid.prototype = new Monster(); // `Erreur`

En outre, des calculs lourds dans le constructeur parent peuvent également être considérés comme un désavantage avec cette approche.

Pour résoudre le problème de cette « fonctionnalité », les programmeurs actuels utilisent un motif standard pour chaîner les prototypes, comme nous allons le voir plus bas. Le principal objectif de cette astuce consiste à créer un objet constructeur encadrant intermédiaire qui chaîne les prototypes souhaités.

1. function Monster() {

2. console.log('Monster.[[Call]] activé');

3. this.attack = 10;

4. }

5. Monster.prototype.defence = 20;

7. var monster = new Monster();

8. console.log([monster.attack, monster.defence]); // `10` (possédé), `20` (hérité)

10. function Humanoid() {

11. // Ou simplement `Monster.apply(this, arguments)`

12. Humanoid.superproto.constructor.apply(this, arguments);

13. }

15. // héritage : chaînage de prototypes

16. // en créant un constructeur intermédiaire vide.

17. var F = function () {};

18. F.prototype = Monster.prototype; // référence

19. Humanoid.prototype = new F();

20. Humanoid.superproto = Monster.prototype; // référence explicite au prototype ancêtre, « sucre »

22. // fixons la propriété `constructor, sinon elle vaudra `Monster`

23. Humanoid.prototype.constructor = Humanoid;

25. var goblin = new Humanoid();

26. console.log([goblin.attack, goblin.defence]); // `10` (propre), `20` (hérité)

Notez comment nous créons notre propre propriété attack sur l'instance de defence : nous appelons la référence au constructeur parent via Humanoid.superproto.constructor dans le contexte nouvellement créé.

Nous fixons également le problème vis-à-vis de la non-nécessité d'appeler le constructeur parent pour créer le prototype descendant. Mantenant le message "Monster.[[Call]] activé" n'est affiché que si nécessaire.

Et pour ne pas avoir à répéter chaque fois les mêmes actions lors du chaînage de prototype (création d'un objet constructeur intermédiaire, créer un sucre superproto, restaurer la propriété constructor originale, etc.), ce modèle peut être encapsulé dans une fonction utilitaire, dont le but est de chaîner les prototypes indépendamment du nom concret de leurs constructeurs :

1. function inherit(child, parent) {

2. var F = function () {};

3. F.prototype = parent.prototype

4. child.prototype = new F();

5. child.prototype.constructor = child;

6. child.superproto = parent.prototype;

7. return child;

8. }

Et l'héritage pourra se faire ainsi :

1. function Monster() {}

2. Monster.prototype.attack = 10;

4. function Humanoid() {}

5. inherit(Humanoid, Monster); // chaînage de prototype

7. var goblin = new Humanoid();

8. console.log(goblin.attack); // `10`, trouver dans le `Monster.prototype`

Il y a beaucoup de variations de cet objet encadrant (au regard de la syntaxe), cependant, elles se résument toutes à effectuer les actions ci-dessus.

Par exemple, nous pouvons optimiser l'objet encadrant précédent en mettant l'objet encadrant intermédiaire à l'extérieur du constructeur (comme cela, seulement une fonction sera créée), pour ensuite la réutiliser :

1. var inherit = (function(){

2. function F() {}

3. return function (child, parent) {

4. F.prototype = parent.prototype;

5. child.prototype = new F;

6. child.prototype.constructor = child;

7. child.superproto = parent.prototype;

8. return child;

9. };

10. })();

Et puisque le vrai prototype d'un objet est la propriété [[Prototype]], cela signifie que F.prototype peut facilement être changé et réutilisé, car child.prototype, qui a été créé via new F, va être dans [[Prototype]] comme la valeur courante de child.prototype :

1. function Monster() {}

2. Monster.prototype.attack = 10;

4. function Humanoid() {}

5. inherit(Humanoid, Monster);

7. Humanoid.prototype.y = 20;

9. Humanoid.prototype.name = function () {

10. console.log("Humanoid#name");

11. };

13. var goblin = new Humanoid();

14. console.log(goblin.attack); // `10`, est trouvé dans le `Monster.prototype`

16. function Goblin() {}

17. inherit(Goblin, Humanoid);

19. // en utilisant notre sucre « superproto »

20. // nous pouvons appeler la méthode parente avec le même nom.

22. Goblin.prototype.name = function () {

23. Goblin.superproto.name.call(this);

24. console.log("Goblin#name");

25. };

27. var goblinSlasher = new Goblin();

28. console.log([goblinSlasher.attack, goblinSlasher.defence]); // `10`, `20`

30. goblinSlasher.foo(); // `"Humanoid#foo"`, `"Goblin#foo"`

Notez qu'en ES5 cette fonctionnalité a été standardisée pour des meilleurs chaînages de prototype. C'est la méthode Object.create.Une version simplifiée en tant que fonction de substitution ES3 s'implémenterait de cette manière :

1. Object.create ||

2. Object.create = function (parent, properties) {

3. function F() {}

4. F.prototype = parent;

5. var child = new F;

6. for (var k in properties) {

7. child[k] = properties[k].value;

8. }

9. return child;

10. }

pour être utilisés ainsi  :

1. var monster = { attack: 10 };

2. var kobold = Object.create(monster, { defence: { value: 20 } });

3. console.log(kobold.attack, kobold.attack); // `10`, `20`

De manière générale, toutes les limitations de « l'héritage classique en JavaScript » sont basées sur ce principe. Maintenant, nous voyons qu'en fait même si ça ressemble à « une imitation des classes basée sur l'héritage », c'est surtout une manière simple de réutiliser du code pour le chaînage de prototypes.

Notez qu'en ES6, le concept de « class » a été standardisé, et son implémentation est exactement un « sucre syntaxique » par-dessus les fonctions constructeurs décrites plus haut. De ce point de vue, le chaînage de prototype devient un détail d'implémentation de l'héritage basé sur les classes :

1. // ES6

2. class Monster {

3. constructor(name) {

4. this._name = name;

5. }

7. getName() {

8. return this._name;

9. }

10. }

12. class Humanoid extends Monster {

13. getName() {

14. return super.getName() + ' Archer';

15. }

16. }

18. var goblin = new Humanoid('Goblin');

19. console.log(goblin.getName()); // `"Goblin Archer"`

VI - Conclusion

Ce tutoriel n'a pas été avare de détails. Il pourra vous servir de référence globale pour lister la majorité des mécanismes JavaScript et retrouver rapidement des détails de fonctionnement.

VII - Remerciements

Nous remercions Bruno Lesieur qui nous a autorisés à publier ce tutoriel.

Nous remercions également Laethy pour la mise au gabarit et jacques_jean pour la correction orthographique.