Srob Blabla et trucs techniques.

 Pseudo-classes javascript

 Exemple

/**
 * Doc de la classe.
 */
var MyClass = function(myFirstConstructorParam, mySecondConstructorParam) {

    // Stockage d'une référence à l'instance de l'objet dans le scope de MyClass.
    // "this" ne peut être utilisé de façon fiable dans les méthodes publiques déclarées ici,
    // car en javascript "this" peut être modifié dynamiquement de plusieurs façon différentes...
    var that = this;

    /** 
     * Propriété privée, accessible uniquement dans le scope courant.
     */
    var myPrivateProperty = 'foo';

    /**
     * Propriété publique.
     */
    this.myPublicProperty = 'bar';

    /**
     * Méthode privée, accessible uniquement dans le scope courant.
     */
    var myPrivateMethod = function(foo) {
        // Code
    };

    /**
     * Méthode publique.
     */
    this.myPublicMethod = function(foo, bar) {
        // Utilisation d'une variable privée.
        // Ca fonctionne car myPrivateProperty est déclarée dans le scope parent.
        console.log(myPrivateProperty);
        // L'utilisation de this n'est pas fiable ici, car selon la façon dont l'appel à
        // myPublicMethod() est effectué, this peut faire référence à autre chose que l'objet courant.
        // C'est parfaitement contre-intuitif si vous venez du Java, PHP...
        // C'est pour cela qu'on garde une référence locale du this d'origine (= celui du constructeur).
        console.log(that.myPublicProperty);
    };

    // Placer ici le code que vous placeriez dans la méthode constructeur de votre classe.
    console.log("Code executé à l'instanciation de l'objet");
};

// Instanciation d'un objet de type MyClass
var myObject = new MyClass('foo', 'bar');
// Utilisation des méthodes & propriétés publiques
myObject.myPublicMethod('test', 'test2');
console.log(myObject.myPublicProperty);

Explications

Le langage Javascript ne comporte pas de notion de classe d'objets. Bien que toutes les entités manipulées par le langage soient des objets, ceux-ci possèdent un type mais pas de classe. En fait, Javascript utilise la notion de protoypage. Pour ceux qui viennent de Java, on peut voir les objets javascripts comme des HashMap, munis de clés de type String et de valeurs de n'importe quel type. Y compris Function, qui est également un type en js.

var monObjet = {
    maPropriete: 1,
    maMethode: function() {
        // Code...
    }
};

En javascript, une fonction est une valeur pouvant être affectée à une variable, ce qui permet de construire un objet sur lequel on peut appeler une méthode, qui est en réalité une propriété. Ou un élément de la collection, si l'on compare les objets à des Map.

Mais du coup, l'opérateur new, qui existe en javascript, n'a pas vraiment le comportement auquel on pourrait s'attendre en connaissant d'autres languages orientés objets. Pour schématiser, le code suivant :

var MaClasse = function(foo, bar) {
    this.plop = foo;
    console.log(bar);
};

var monObjet = new MaClasse('foo', 'bar');

est fonctionnellement équivalent au code suivant :

var monObjet = {
    plop: 'foo'
};

console.log('bar');

à une petite différence près :

L'objet MaClasse est donc le constructeur de la pseudo-classe MaClasse.

Pour approcher encore plus le formalisme d'une classe, il est possible de créer une méthode privée "construct" (par exemple), appellée sur la dernière ligne de la fonction MyClass, qui aura le même rôle que le constructeur de classe d'un langage objet classique.

 Avantages

La construction ci-dessus a l'avantage d'encapsuler le code correspondant à une classe dans un seul bloc de code, qui pourra être instancié à l'aide de l'opérateur new. On se rapproche donc du formalisme classique des langages objets.

On dispose également de notions d'attributs privés et publique, via l'utilisation respective de var xxx = ... et this.xxx = ...

Inconvénients

Une telle construction a plusieurs inconvénients :