Introduction aux modèles de conception de base courants dans Node.js

La première chose à laquelle tout le monde pense lorsqu'on parle de modèles de conception, ce sont les singletons, les observateurs (observateurs) ou les usines (méthodes d'usine). Cet article se concentre sur la présentation 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 House pour apprendre ensemble

Quand il s'agit de modèles de conception, vous pouvez penser à. singletons et observateurs (observateurs) ou usines (méthodes d'usine). Cet article ne les aborde pas spécifiquement. Explorez simplement l'implémentation de certains modèles de base dans Node.JS, comme l'injection de dépendances ou le middleware.

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 une "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');

Usines (méthode d'usine)

Le modèle d'usine est un modèle de créateur, nous sommes Il n'est pas nécessaire d'utiliser un constructeur, 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 consiste à injecter une ou plusieurs dépendances (ou services) dans le modèle de conception pour les objets dépendants.

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, nous 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 la sortie de la prochaine entrée du unité fonctionnelle. 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 supprimé dans une file d'attente du 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);
});

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!