Exemple d'analyse de modèles de conception de base courants dans Node.js

En général, nous connaissons les modèles de conception (observateurs) ou les usines (méthodes d'usine) dans Node.js. Cet article se concentre sur l'introduction des méthodes d'implémentation de certains modèles de base dans Node.JS. Les amis intéressés peuvent suivre l'éditeur de Script. Maison Apprenons ensemble, cet article n’en parle pas spécifiquement. Je viens de discuter de l'implémentation de certains modèles de base dans Node.JS, tels que l'injection de dépendances ou le middleware, j'espère que cela pourra aider tout le monde.

Que sont les modèles de conception ?

Les modèles de conception sont des solutions réutilisables utilisées pour résoudre des problèmes généraux et courants.

Singletons (Singleton)

Le modèle Singletons limite la "classe" à une seule instance. Créer un singleton dans Node.js est très simple, comme le requiert ci-dessous.

//area.js
var PI = Math.PI;
function circle (radius) { 
 return radius * radius * PI;
}
module.exports.circle = circle;

Peu importe le nombre de fois que vous le référencez ; il n'existera que sous la forme d'une seule instance.

var areaCalc = require('./area');
console.log(areaCalc.circle(5));

Les singletons sont probablement le modèle de conception Node.js le plus courant dans les modules NPM en raison de cette implémentation de require .

Observateurs

Un objet qui maintient une liste d'écoute/observation et les avertit automatiquement lorsque l'état change. Afin d'implémenter le modèle d'observateur, EventEmitter est utile.

// MyFancyObservable.js
var util = require('util'); 
var EventEmitter = require('events').EventEmitter;
function MyFancyObservable() { 
 EventEmitter.call(this);
}
util.inherits(MyFancyObservable, EventEmitter);

Ça y est, nous avons implémenté un observable ! Pour l'utiliser, ajoutons quelques méthodes.

MyFancyObservable.prototype.hello = function (name) { 
 this.emit('hello', name);
};

Super, essayez d'écouter et de répondre à cet événement !

var MyFancyObservable = require('MyFancyObservable'); 
var observable = new MyFancyObservable();
observable.on('hello', function (name) { 
 console.log(name);
});
observable.hello('john');

Factory (méthode factory)

Le modèle Factory est un modèle de créateur qui ne nous oblige pas à utiliser des constructeurs. Il fournit une interface commune pour créer des objets. Ce modèle peut être utilisé pour générer des objets très complexes à créer.

function MyClass (options) { 
 this.options = options;
}
function create(options) { 
 // modify the options here if you want
 return new MyClass(options);
}
module.exports.create = create;

Les usines facilitent les tests car vous pouvez y injecter des dépendances.

Injection de dépendances

L'injection de dépendances est un modèle de conception dans lequel une ou plusieurs dépendances (ou services) sont injectées ou transmises par référence à un objet dépendant.

Dans cet exemple, nous allons créer un modèle utilisateur qui récupère les dépendances de la base de données.

function userModel (options) { 
 var db;
 if (!options.db) {
  throw new Error('Options.db is required');
 }
 db = options.db;
 return {
  create: function (done) {
   db.query('INSERT ...', done);
  }
 }
}
module.exports = userModel;

Maintenant, créons une instance en l'utilisant :

var db = require('./db');
var userModel = require('User')({ 
 db: db
});

Pourquoi est-ce utile ? Cela facilite les tests : lorsque vous écrivez des tests unitaires, vous pouvez injecter de fausses instances de base de données dans le modèle.

Middlewares/pipelines

Le middleware est un concept puissant mais simple : la sortie d'une unité fonctionnelle est l'entrée de l'unité fonctionnelle suivante. Si vous avez utilisé Express, vous avez déjà utilisé ce modèle.

Voyons comment Koa procède :

app.use = function(fn){ 
 this.middleware.push(fn);
 return this;
};

Donc, fondamentalement, lorsque vous ajoutez un middleware, il est simplement placé dans une file d'attente de middleware. Mais que se passe-t-il lorsqu'une requête arrive sur ce serveur ?

var i = middleware.length; 
while (i--) { 
 next = middleware[i].call(this, next);
}

Rien de magique, vos middlewares sont appelés les uns après les autres.

Flux

Vous pouvez traiter les flux comme des canaux spéciaux. Il est plus adapté au traitement de flux de données volumineux, c'est-à-dire qu'il s'agit d'octets et non d'objets.

process.stdin.on('readable', function () { 
  var buf = process.stdin.read(3);
  console.dir(buf);
  process.stdin.read(0);
});

Explication détaillée de l'exemple de modèle de localisateur de service du modèle de conception PHP

Explication détaillée du modèle de délégation du modèle de conception PHP

Explication détaillée du modèle de mémo du modèle de conception PHP

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!