2.0 模块化规范-止水

let、const、var的区别，作用：

在Es6中引入let,const定义变量是解决访问变量的全局作用域问题,从而引入块级作用域,解决命名冲突,同名全局污染,安全等问题

区别：

• var声明的变量属于函数作用域；let 和 const 声明的变量属于块级作用域，不能跨函数访问；
• var存在变量提升现象，而 let 和 const 没有；
• var变量可以重复声明，值可改变；在同一个块级作用域下：let变量不能重新声明；const定义是常量，即不可变量，声明时必须赋值，但不允许重复赋值，如果定义的是引用类型，可以修改数据内部结构。

为什么需要模块化？

程序开发可以通过模块化进行解耦，组件化开发可以进一步推动项目程序的工程化进度 使用阈值控制 promise 链条同时执行的数目

class limitPromise{
    constructor(max){
    this.max = max;
    this._count = 0;
    this._pendingTaskQueue = [];
  }
   /**
   * 调用器，将异步任务函数和它的参数传入
   * @param caller 异步任务函数，返回Promise的函数
   * @param args 异步任务函数的参数列表
   * @returns {Promise<unknown>} 返回一个新的Promise
   */
  call = (caller, ...arg) => {
    return new Promise((resolve, reject) => {
        if(this._count <= this.max) {
          let task = this._createTask(caller, arg, resolve, reject);
          task();
        }
      });
    }

   /**
   * 创建一个任务
   * @param caller 实际执行的函数
   * @param args 执行函数的参数
   * @param resolve
   * @param reject
   * @returns {Function} 返回一个任务函数
   * @private
   */
     _createTask = (caller, arg, resolve, reject)=> {
     return () => {
       // 当前请求数量加一
       this._count++;
       // 实际上是在这里调用了异步任务，并将异步任务的返回（resolve和reject）抛给了上层
       caller(...arg)
         .then(resolve)
         .catch(reject)
         .finally(() => {
                // 任务队列的消费区，利用Promise的finally方法，在异步任务结束后，取出下一个任务执行
                this._count--;
                if(this._pendingTaskQueue.length){
                let task = this._pendingTaskQueue.shift();
                task();
             } 
        })
     }
   }
}

使用

const LimitPromise = require('limit-promise')
const request = require('./request')
// 请求上限
const MAX = 10
// 核心控制器
const limitP = new LimitPromise(MAX)

// 利用核心控制器包装request中的函数
function get (url, params) {
  return limitP.call(request.get, url, params)
}
function post (url, params) {
  return limitP.call(request.post, url, params)
}
// 导出
module.exports = {get, post}