function Queue() {
  let items = [];
  this.enqueue = function(element) {  //向队列尾部添加新的项
    items.push(element);
  }

//移除队列的第一（即排在队列最前面的）项，并返回被移除的元素。

  this.dequeue = function() {
    return items.shift();
  }

//返回队列中第一个元素——最先被添加，也将是最先被移除的元素

  this.front = function() {
    return items[0];
  }

  this.isEmpty = function() {
    return items.length == 0;
  }

  this.size = function() {
    return items.length;
  }
  this.print = function() {
    console.log(items.toString())
  }
}

enqueue() ：向队列尾部添加一个（或多个）新的项。

dequeue() ：移除队列的第一（即排在队列最前面的）项，并返回被移除的元素。

front() ：返回队列中第一个元素——最先被添加，也将是最先被移除的元素。队列不

做任何变动（不移除元素，只返回元素信息——与 Stack 类的 peek 方法非常类似）。

isEmpty() ：如果队列中不包含任何元素，返回 true ，否则返回 false 。

size() ：返回队列包含的元素个数，与数组的 length 属性类似。

function Queue() {

  let items = [];

  this.enqueue = function(element) {

    items.push(element);

  }

  this.dequeue = function() {

    return items.shift();

  }

  this.front = function() {

    return items[0];

  }

  this.isEmpty = function() {

    return items.length == 0;

  }

  this.size = function() {

    return items.length;

  }

  this.print = function() {

    console.log(items.toString())

  }

}

//这里写了一个发布订阅模式

(function(window){

    function Subscribe(){

        this.pond = [];

    }

    Subscribe.prototype = {

        constructor:Subscribe,

        add:function(fn){

            var pond = this.pond,

                isExit = false;

            pond.forEach(function(item){

                item === fn?isExit=true:null;

            });

            !isExit?pond.push(fn):null;

        },

        remove:function(fn){

            var pond = this.pond;

            pond.forEach(function(item,index){

                if(fn === item){

                    pond[index] = null;

                }

            });

        },

        fire:function(){

            var pond = this.pond;

            for (var i = 0; i < pond.length; i++) {

                var curFn = pond[i];

                if(curFn===null){

                    pond.splice(i,1);

                    i--;

                    continue;

                }

                curFn.apply(this,Array.prototype.slice.call(arguments));

            }

        }

    };

    window.Subscribe = Subscribe;

})(window);

//我们下边去使用

var subscribe1 = new Subscribe();

 function ff1(num1){

        console.log(1,num1);

    }

    function ff2(num1,num2){

        console.log(2,num1,num2);

        

    }

    function ff3(num1,num2,num3){

        console.log(3,num1,num2,num3);

        

    }

    function ff4(num1,num2,num3){

        console.log(4,num1,num2,num3);

        subscribe1.remove(ff3);  //删除

    }

    //增加

    subscribe1.add(ff1);

    subscribe1.add(ff2);

    subscribe1.add(ff3);

    subscribe1.add(ff4);

  //触发

    subscribe1.fire();

    subscribe1.fire(1,2,3);

enqueue 从队列尾部添加一个元素

dequeue 从队列头部删除一个元素

head 返回头部的元素，注意，不是删除

size 返回队列大小

clear 清空队列

isEmpty 判断队列是否为空

tail 返回队列尾节点

然后我们逐一实现

let Queue = (function () {

  let items = new WeakMap() 

  // WeakMap结构与Map结构基本类似。区别是它只接受对象作为键名，

  // 不接受其他类型的值作为键名。键名是对象的弱引用，当对象被回收后，

  // WeakMap自动移除对应的键值对，WeakMap结构有助于防止内存泄漏。 

  class Queue {

    constructor() {

      items.set(this, [])

    }

    // 入队列

    enqueue(item) {

      let queue = items.get(this)

      queue.push(item)

    }

    // 出队列

    dequeue() {

      return items.get(this).shift()

    }

    // 返回队列头

    head() {

      let queue = items.get(this)

      return queue[0]

    }

    // 返回队列大小

    size() {

      let queue = items.get(this)

      return queue.length

    }

    // 清空队列

    clear() {

      items.set(this, [])

    }

    // 判断队列是否为空

    isEmpty() {

      let queue = items.get(this)

      return queue.length === 0

    }

    // 返回队尾

    tail() {

      let queue = items.get(this)

      return queue[queue.length - 1]

    }

  }

  return Queue

})