Example analysis of common basic design patterns in Node.js

Generally we are familiar with the design patterns (observers) or factories (factory methods) in Node.js. This article focuses on introducing the implementation methods of some basic patterns in Node.JS. Interested friends can follow the editor of Script House. Let’s learn together, this article does not specifically discuss them. I just discuss the implementation of some basic patterns in Node.JS, such as dependency injection or middleware. I hope it can help everyone.

What are design patterns?

Design patterns are reusable solutions used to solve general, commonly occurring problems.

Singletons (single case)

Singletons pattern limits the "class" to only one instance. Creating a singleton in Node.js is very simple, such as the require below.

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

It doesn't matter how many times you reference it; it will only exist as a single instance.

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

Due to this implementation of require, singletons are probably the most common Node.js design pattern in NPM modules.

Observers

An object that maintains a listening/observation list and automatically notifies them when the state changes. In order to implement the observer pattern, EventEmitter comes in handy.

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

That’s it; we have implemented an observable object! To use it, let's add some methods.

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

Great, try listening and responding to this event!

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

Factories (factory method)

The factory pattern is a creator pattern that does not require us to use a constructor. It provides a common interface for creating objects. This pattern can be used to generate objects that are very complex to create.

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

Factories can make testing easier because you can inject dependencies into them.

Dependency Injection Dependency Injection

Dependency injection is a design pattern in which one or more dependencies (or services) are injected or passed by reference to a dependent object.

In this example, we will create a usermodel which obtains database dependencies.

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;

Now, we create an instance using it:

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

Why is it useful? It makes testing easier - when you write unit tests, you can inject fake database instances into the model.

Middlewares/pipelines Middleware/pipelines

Middleware is a powerful yet simple concept: the output of one functional unit is the input of the next functional unit. If you've used Express then you've already used this pattern.

Let's take a look at how Koa does it:

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

So basically when you add a middleware, it's just pushed into a middleware queue. But what happens when a request arrives at this server?

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

Nothing magical - your middleware is called one after the other.

Streams

You can treat streams as special pipes. It is more suitable for processing large data streams, that is, they are bytes, not objects.

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

Detailed explanation of the service locator pattern example of PHP design pattern

Detailed explanation of the delegation pattern of PHP design pattern

Detailed explanation of the memo pattern of PHP design patterns

The above is the detailed content of Example analysis of common basic design patterns in Node.js. For more information, please follow other related articles on the PHP Chinese website!