How to use chain calls in JS design pattern

This time I will show you how to use chain calls in JS design mode. What are the precautions for using chain calls in JS design mode? The following is a practical case. Let’s take a look.

Anyone who has written jquery may know that the following code can be easily used in jquery:

// 不使用链式调用
const element = $(ele);
element.addClass('red');
element.removeClass('green');
element.show();
// 链式调用
$(ele)
 .addClass('red')
 .removeClass('green')
 .show();

The calling method of jquery is a chain call. We can see from the above code that if we do not use chain calls, we will add a lot of repeated code, and it will be particularly redundant. By chaining calls, we can save a lot of code, and the code looks more elegant and neat. So, next, let's discuss how to implement a library that supports chain calls.

Anyone who knows the prototype chain knows that the instance generated by the constructor can access the properties and methods of its prototype object. Therefore, we let the definition in the prototype object The method finally returns this (the instance in which the method is called), and the prototype method can be called in a chain.

// 通过立即执行函数，声明了一个_$函数，并且将一个$函数挂载到window上，并且每次调用$()的时候，返回的其实是个_$实例，由于原型对象方法里，执行最后都会返回一个this,因此就可以执行链式调用。
(function () {
 // 构造函数
 function _$(selector) {
  // ...
 }
 _$.prototype = {
  addClass: function (className) {
   // ...
   return this;
  },
  removeClass: function (className) {
   // ...
   return this;
  },
  show: function () {
   // ...
   return this;
  }
 };
 _$.prototype.constructor = _$;
 // 每次调用$()的时候，返回的其实是个_$实例
 window.$ = function () {
  return new _$(arguments);
 }
})();
// 通过这种方式，我们就可以直接使用$的链式调用
$(ele)
 .addClass('red')
 .removeClass('green')
 .show();

Of course, the above code can actually be optimized, because assuming that someone has already defined the $ function in the library you introduced, then you will face the problem of naming conflicts. So, we can add an installer for it

(function () {
 // 构造函数
 function _$(selector) {
  // ...
 }
 _$.prototype = {
  addClass: function (className) {
   // ...
   return this;
  },
  removeClass: function (className) {
   // ...
   return this;
  },
  show: function () {
   // ...
   return this;
  }
 };
 _$.prototype.constructor = _$;
 // 增加一个安装器
 window.installHelper = function (scope, interface) {
  scope[interface] = function () {
   return new _$(arguments);
  }
 }
})();
// 而用户就可以这样使用它来自定义挂载对象以及其命名
installHelper(window, '$');
$(ele).show();

Of course, sometimes chain calls are not a good idea. Chained calls are suitable for assignor methods, but are not very friendly for getter methods. Because sometimes we want the method to return some data instead of returning this. For this situation, there are two main solutions. One is to not return this for the value getter method, but to directly return the data. The other method is to process data through callback methods:

// 第一种方法，当遇到取值器，则直接返回数据
(function () {
 // 构造函数
 function _$(selector) {
  this.ele = document.querySelector(selector);
  // ...
 }
 _$.prototype = {
  addClass: function (className) {
   // ...
   return this;
  },
  // 取值器
  getClass: function () {
   // ...
   return this.ele.className;
  }
 };
 _$.prototype.constructor = _$;
})();
// 第二种方式，通过回调的方式来处理数据
(function () {
 // 构造函数
 function _$(selector) {
  this.ele = document.querySelector(selector);
  // ...
 }
 _$.prototype = {
  addClass: function (className) {
   // ...
   return this;
  },
  getClass: function (cb) {
   // ...
   cb.call(this, this.ele.className);
   return this;
  }
 };
 _$.prototype.constructor = _$;
})();

Through chain calls, we can simplify our code and make it more concise and easier to read. And we only need to make all methods of the class return this value, so that the class can be transformed into a class that supports method chain calling. And if you want the valuer method to also support chained calls, you can use callbacks in the valuer to solve this problem.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

How to use Vue to achieve drag-and-drop effect

Node.js console output log file example analysis

The above is the detailed content of How to use chain calls in JS design pattern. For more information, please follow other related articles on the PHP Chinese website!