Vous savez sans doute que l'on peut faire de l'objet avec JavaScript. Mais la syntaxe révèle quelques subtilités, qui sont révélatrices de la manière dont JavaScript implémente l'objet.

C'est ce qui fera l'objet ( ) de ce quiz JavaScript et des quelques uns qui suivront.

Soit la "classe" Personne, avec deux attributs nom et age et une opération booléenne isMajeur. On peut implémenter ceci comme suit :

function Personne(nom, age) {
  this.nom      = nom;
  this.age      = age;
  this.isMajeur = Personne_isMajeur;
}
 
function Personne_isMajeur() {
  return (this.age >= 18);
}

Gros problème : on peut appeler directement Personne_isMajeur() comme une fonction, au lieu de l'invoquer sur un objet Personne.

Certains vont alors réécrire ce qui précède comme suit :

function Personne(nom, age) {
  this.nom = nom;
  this.age = age;
 
  this.isMajeur = function() {
    return (this.age >= 18);
  }
}

Mais d'autres auront plutôt tendance à le réécrire comme ceci :

function Personne(nom, age) {
  this.nom = nom;
  this.age = age;
}
 
Personne.prototype.isMajeur = function() {
  return (this.age >= 18);
}

Quelle différence y a-t-il entre ces deux dernières écritures ?

Y a-t-il vraiment une différence ? Pas sûr !

Pour s'en assurer, ajoutons à chacune des définitions de la classe Personne le code suivant :

var jean = new Personne("Jean", 43);
var alex = new Personne("Alex", 21);
 
alert(String(jean.isMajeur) == String(alex.isMajeur));
alert(jean.isMajeur == alex.isMajeur);

Avec la seconde définition de Personne, ce bloc JavaScript supplémentaire affiche true puis true. Avec la première définition, il affiche true puis false. Il y a donc bien une différence !

Qu'affichent vraiment ces deux alertes ?

La première alerte compare le code des opérations isMajeur de jean et alex, puisque convertir en String une fonction permet d'obtenir son code ; la seconde alerte compare la référence vers les opérations isMajeur de jean et alex, comme le ferait une comparaison entre deux objets Java avec l'opérateur ==.

Autrement dit, quelle que soit la manière de définir isMajeur, tous les objets Personne auront une opération isMajeur avec le même code. Par contre, avec la première écriture, une nouvelle opération isMajeur sera définie (et compilée) pour chaque nouvel objet, alors qu'avec la seconde écriture, l'opération isMajeur est définie une fois pour toutes, et commune à tous les objets Personne.

Recréer ou non une nouvelle fonction à chaque création d'instance de la classe, cela fait une sacrée différence de consommation mémoire et de rapidité d'exécution, en effet !