Compréhension approfondie de la série JavaScript (28) : Explication détaillée du modèle d'usine des compétences en matière de modèles de conception_javascript

Présentation

Semblable au patron de création, le patron d'usine crée des objets (considérés comme des produits dans l'usine) sans préciser la classe spécifique de l'objet à créer.

Le modèle d'usine définit une interface pour créer des objets. Cette interface détermine quelle classe instancier par la sous-classe. Ce modèle diffère l'instanciation d'une classe aux sous-classes. Les sous-classes peuvent remplacer les méthodes d'interface pour spécifier leurs propres types d'objet lors de la création.

Ce mode est très utile, notamment lors de l'attribution de valeurs au processus de création d'objets, par exemple en s'appuyant sur de nombreux fichiers de paramètres. De plus, vous verrez souvent des méthodes d'usine dans les programmes, qui sont utilisées pour permettre aux sous-classes de définir les types d'objets à créer.

Texte

L'exemple suivant est une version améliorée du code du modèle de constructeur du chapitre 26 qui applique la méthode factory :

Copier le code Le code est le suivant :

var Voiture = (fonction () {
var Car = fonction (modèle, année, miles) {
This.model = modèle;
Cette.année = année ;
This.miles = miles;
};
Fonction de retour (modèle, année, miles) {
         retourner une nouvelle voiture (modèle, année, miles) ;
};
})();

var tom = new Car("Tom", 2009, 20000);
var dudu = nouvelle voiture("Dudu", 2010, 5000);

Si c'est difficile à comprendre, donnons un autre exemple :

Copier le code Le code est le suivant :

var productManager = {};

productManager.createProductA = function() {
console.log('ProductA');
>

productManager.createProductB = function() {
console.log('ProductB');
>
                             
productManager.factory = fonction (typeType) {
Retourner le nouveau productManager[typeType];
>

productManager.factory("createProductA");

Si vous ne comprenez toujours pas, entrons plus en détail. Supposons que nous souhaitions insérer certains éléments dans la page Web et que les types de ces éléments ne sont pas fixes. Il peut s'agir d'images, de liens ou même de texte. Selon Pour définir le modèle d'usine, nous devons définir la classe d'usine et la sous-classe correspondante. Définissons d'abord l'implémentation spécifique de la sous-classe (c'est-à-dire la sous-fonction) :
.

Copier le code Le code est le suivant :

var page = page || {};
page.dom = page.dom || {};
//Sous-fonction 1 : Traiter le texte
page.dom.Text = fonction () {
This.insert = fonction (où) {
        var txt = document.createTextNode(this.url);
Où.appendChild(txt);
};
};

//Sous-fonction 2 : Traitement des liens
page.dom.Link = fonction () {
This.insert = fonction (où) {
        var link = document.createElement('a');
         link.href = this.url;
         link.appendChild(document.createTextNode(this.url));
Où.appendChild(lien);
};
};

//Sous-fonction 3 : Traitement des images
page.dom.Image = fonction () {
This.insert = fonction (où) {
         var im = document.createElement('img');
          im.src = this.url;
Où.appendChild(im);
};
};

Alors, comment définissons-nous la fonction de traitement en usine ? C'est en fait très simple :

Copier le code Le code est le suivant :

page.dom.factory = fonction (type) {
Renvoie une nouvelle page.dom[type];
>

Comment utiliser :

Copier le code Le code est le suivant :

var o = page.dom.factory('Link');
o.url = 'http://www.cnblogs.com';
o.insert(document.body);

À ce stade, je pense que tout le monde a une compréhension claire de l’introduction au modèle d’usine, je ne vais donc pas développer davantage.

Résumé

Quand utiliser le modèle d'usine

Le mode Usine est particulièrement utile dans les scénarios suivants :

1. La construction d'objets est très compliquée
2. Différentes instances doivent être créées en fonction de l'environnement spécifique
3. Traitez un grand nombre de petits objets avec les mêmes propriétés

Quand ne pas utiliser le mode usine

N'abusez pas du modèle d'usine. Parfois, cela ajoute simplement une complexité inutile au code et rend difficile l'exécution du test.