Ajouter des propriétés aux classes en utilisant les fonctions extend() et include()

Question

Quelqu'un peut-il m'expliquer s'il vous plaît ce qui se passe dans le code suivant? J'ai compris la signification de include() et exclude() mais quand et pourquoi utilisons-nous la fonction spécifique?

var Class = function() { 
    var klass = function() { 
     this.init.apply(this, arguments); 
    }; 

    klass.prototype.init = function() {}; 

    klass.fn = klass.prototype; 
    //shortcut to access class 
    klass.fn.parent = klass; //where do we use it? 

    //adding class properties 
    klass.extend = function (obj) { 
     var extended = obj.extended; //what is happening here? 
     for (var i in obj) { 
      klass[i] = obj[i]; 
     } 
     if (extended) extended(klass) //didn't understand this part 
    }; 
    //adding instance properties 
    klass.include = function (obj) { 
     var included = obj.included; //?? 
     for (var i in obj) { 
      klass.fn[i] = obj[i]; //?? 
     } 
     if (included) included(klass) //?? 
    }; 
    return klass; 
}; 
var Person = new Class; // is this same as: var Person = new Class(); 

Answer 1

Il l'a obtenu à partir de Javascript Web Applications by Alex MacCaw. Le but est de démontrer l'implémentation de classes Javascript, et d'utiliser la modularité et l'héritage appropriés. L'auteur est très abstrait dans ses explications et ne spécifie pas si des bibliothèques telles que Prototype.js sont utilisées.

Je pense un bon ajout à cette question serait:

• Est-ce que tout cela ressembler Javascript natif?
• Sont étendre/étendu et inclure/inclus des méthodes natives de Javascript?

Answer 2

Après votre question auteur-bloc nous donner cette partie:

Person.extend({ 
    extended: function(klass) { 
     console.log(klass, " was extended"); 
    } 
}); 

Donc, si nous avons une propriété « étendu » dans un objet argument - nous l'appelons.

Answer 3

Je voudrais offrir comment je l'ai compris. Je diviserais cela en deux parties: la définition et la mise en œuvre (ou l'utilisation). Suite à la définition que vous avez cité ci-dessus, je voudrais ajouter que l'utilisation de ce code:

var Person = new Class; 

Person.extend({ 
    find: function(id) { /* definition */ 
    }, 
    exists: function(id) { /* definition */ 
    } 
}); 
Person.include({ 
    save: function(id) { /* definition */ 
    }, 
    destroy: function(id) { /* definition */ 
    } 
}); 

var person_e = Person.find(1); 
var person_e = Person.exists(2); 

var person = new Person; 
person.save(); 
person.destroy(2); 

Voir ce code en continuité avec le code précédent. Je vais essayer d'énumérer ce qui se passe:

1. La classe est définie pour contenir la définition de la fonction. Il n'est pas encore exécuté - donc la classe pointe vers ce bloc dans la mémoire où la définition de la fonction est écrite.
2. var Personne = new Classe -> Ceci est équivalent à 'new Class()' - donc l'exécution de Class arrive et le résultat est assigné à Person. Comme il est appelé avec le mot clé 'new', 'this' est assigné à la nouvelle instance de Class.
3. Maintenant, que se passe-t-il dans Class()? (i) klass est mis à fonctionner (le travail dont initialise 'this' lorsqu'il est appelé) - mais pas encore exécuté. (ii) Une propriété init est définie sur le prototype de klass; La propriété init est définie sur une fonction vide (que nous écraserons plus tard en fonction de la classe que nous définirions). (iii) Quelques trucs plus fantaisistes avec les propriétés extend et include sur klass (iv) Et klass est retourné -> klass point dans le temps. Par conséquent, appeler 'new Class()' renvoie une fonction appelée 'klass' qui, lorsqu'elle est appelée, effectue l'initialisation sur 'this'. Personne à ce stade, en termes simples, peut être considéré comme tenant la fonction 'klass()'. Donc, Person.extend peut être pensé pour aller à la partie klass.extend du code. klass.extend est une fonction qui attend un objet. Cet objet a des paires de valeurs clés, la clé étant les noms des utilitaires/fonctions et les valeurs étant des définitions de fonctions. Dans l'instruction 'for', nous faisons (var i dans obj) - donc 'i' contient les clés - quand nous faisons 'klass.fn [i]' nous voulons dire klass.prototype.save ou klass.prototype.destroy - puisque l'indice [i] est identique à la notation par points (namespacing). Et nous savons que les méthodes ajoutées à klass.prototype sont disponibles pour les instances de Person, plutôt que d'être ajoutées à Person en tant que propriétés.

4. Nous appelons new Person() - en effet, nous sommes en train d'exécuter klass, puisque Person contient klass à ce moment, et comme new est attaché, 'this' est passé.Maintenant, l'initialisation de 'klass' se passe sur la propriété init de 'this' (par le formulaire d'application) -> Et cette propriété 'init' que nous venons d'écraser.

   klass.fn.parent = klass; // où l'utilisons-nous? //nulle part.