NodeJS singleton mode, adapter mode, decoration mode, observer mode summary

This article mainly introduces the NodeJS design pattern, and summarizes and analyzes the concepts, principles and specific implementation techniques of nodejs singleton mode, adapter mode, decoration mode, and observer mode in the form of examples. Friends in need can refer to it

The examples in this article describe the NodeJS design pattern. Share it with everyone for your reference, the details are as follows:

1. Singleton mode

As the name suggests, a singleton ensures that a class has only one instance. The implementation method is, First determine whether the instance exists. If it exists, return it directly. If it does not exist, create an instance object and save it in a static variable. When the next request is made, you can directly return this object instance. This ensures that a class There is only one instance object. For example, a school has just been built and there is no library yet. Some students asked the leader: "Hey! Brother, can you help us build a library?" (wanting an example of a library), and then The leader said: "No problem! Wait for me and I will build it for you right away" (the instance has not been created yet, so create one). A few months later, the library was built. There was a strange classmate who also wanted to go to the library, but he made a request to the leader: "Hey! Man, I want to go to the library. Can you help me build one?" Then the leader said : "No problem! There's already one built over there, can't you just go there!" (When the instance already exists, the created instance will be returned directly)

/*singleInstance.js*/
var _instance = null;//定义初始化_instance
module.exports = function(time){
   function Car(time){
     this.time = time;
   }
   this.getInstance = function(){
     if(_instance != null){
       return _instance;
     }else{
       return new Car(time);
     }
   }
}

2. Adapter pattern

If the interface of a class is converted into another interface that the customer wants, the adapter pattern can make the original interface incompatible. Those classes that work together can work together. For example~ Xiao Ming’s father, Daming, loves to drink liquor, but drinking is harmful to the body. Xiao Ming couldn’t bear it when he saw it, so he thought of a way: pour out the liquor in the liquor bottle and replace it with boiled water (heavy). write content). When Daming saw that it was still the same wine bottle, he didn't pay much attention (the interface has not changed, only the content has changed), and he drank the "wine" in one breath, and he was very happy ~ (I assume here that Da Ming has a low IQ...). Therefore, the Dominator is a good way to achieve one's own goals without offending others. The following is the specific implementation method

/*target.js*/
module.exports = function(){
  this.request = function(){//原接口
    console.log('Target::request');
  }
}

/*adapter.js*/
var util = require('util');
var Target = require('./target.js');
var Adaptee = require('./adaptee.js');
function Adapter(){
  Target.call(this);
  this.request = function(){//重写原接口
    var adapteeObj = new Adaptee();//重写的内容
    adapteeObj.specialRequest();
  }
}
util.inherits(Adapter, Target);//通过继承原模块, 获得原接口
module.exports = Adapter;

3. Decoration mode

Decoration mode can extend functions for a base class object through inheritance. For example, a Christmas tree has nothing at first. Then Amy hung a few ornaments on the tree after seeing it (extending the original base class). Then after Billy passed by, he felt that it still lacked something, so he took the Christmas tree over (inherited), and then put some other ornaments on it ( continue to expand).

/*Base.js*/
module.exports = function(){
  this.dosomething = function(){
   console.log("Nice to meet u.");
  }
}

/*Decorator.js*/
var util = require("util);
var Base = require('./Base');
function Decorator(){
  Base.call(this);
  this.dosomething = function(){
     Base.dosomething();
     console.log('I am a decorator');//拓展内容
  }
}
util.inherits(Decorator, Base);//继承
module.exports = Decorator;

4. Observer pattern

What is the observer pattern? For example, classmates Puppy and Bear fell in love with the cute Rabbit in the class at the same time. The puppy and the bear will pay attention to every move of the bunny. Only when the bunny moves, they will both know. Relatively speaking, the puppy and the bear are the "observers" of the bunny, while the bunny is the "observer". object of observation". The more important thing is: the movement of the bunny (a certain function) will be notified to the observers, the puppy and the bear, at the same time, so that they will also give corresponding feedback (respective callback functions)

/*被观察者*/
module.exports = function(){
  var m_obserSet = [];//观察者列表
  var _self = this;
  this.addObser = function(observer){
    m_obserSet.push(observer);//添加观察者
  }
  this.doAction = function(){
    console.log("Observable do some action");
    _self.notifyAllObeser();
  }
  this.notifyAllObeser = function(){//发生动作
    for(var key in m_obserSet){//逐个通知观察者
      m_obserSet[key].update();//观察者执行回调
    }
  }
}

The above is the detailed content of NodeJS singleton mode, adapter mode, decoration mode, observer mode summary. For more information, please follow other related articles on the PHP Chinese website!