无ES类的纯函数式类型系统中，如何模拟父方法调用（非super()）？

一、纯函数式系统的核心思路 #

纯函数式场景下不用依赖原型或类的继承逻辑，核心是通过显式委托调用父级函数，把数据和行为分离，避免this隐式绑定，通过参数传递来复用父级逻辑。

二、不使用ES类和super的可选方案 #

针对你提供的代码场景，以下是几种可行的实现方式：

方案1：保存父构造函数挂载的实例方法

你的Queue在构造函数里直接把enqueue挂载到实例上，在AsyncQueue中可以先调用父构造函数初始化方法，再把父级方法存下来，之后在自己的方法里调用：

function Queue() {
  this.items = [];
  this.enqueue = function enqueue(item) {
    this.items.push(item);
    return item;
  }
}

function AsyncQueue() {
  Queue.call(this);
  // 保存父构造函数初始化的enqueue方法
  const parentEnqueue = this.enqueue;
  this.awaiters = new Queue();

  this.enqueue = function enqueue(item) {
    const awaiter = this.awaiters.dequeue();
    if (awaiter !== undefined) {
      setImmediate(() => {
        awaiter(item);
      });
    } else {
      // 调用父级方法并绑定当前实例的this
      parentEnqueue.call(this, item);
    }
    return item;
  }
}

AsyncQueue.prototype = Object.create(Queue.prototype);
AsyncQueue.prototype.constructor = AsyncQueue;

方案2：基于原型的显式调用

把方法定义在构造函数的原型上，直接通过父构造函数的原型调用对应方法，同样绑定当前实例的this：

function Queue() {
  this.items = [];
}

// 父级方法定义在原型上
Queue.prototype.enqueue = function enqueue(item) {
  this.items.push(item);
  return item;
}

function AsyncQueue() {
  Queue.call(this);
  this.awaiters = new Queue();
}

// 继承父级原型
AsyncQueue.prototype = Object.create(Queue.prototype);
AsyncQueue.prototype.constructor = AsyncQueue;

// 重写原型上的enqueue方法
AsyncQueue.prototype.enqueue = function enqueue(item) {
  const awaiter = this.awaiters.dequeue();
  if (awaiter !== undefined) {
    setImmediate(() => {
      awaiter(item);
    });
  } else {
    // 直接调用父原型的enqueue方法
    Queue.prototype.enqueue.call(this, item);
  }
  return item;
}

方案3：纯函数式委托（无this、无原型）

完全剥离this和原型依赖，把队列数据和操作逻辑分开，父级逻辑作为独立函数存在，子级通过传递数据调用父级函数：

// 父级：创建队列数据结构
function createQueue() {
  return { items: [] };
}

// 父级enqueue操作函数
function enqueue(queue, item) {
  queue.items.push(item);
  return item;
}

// 父级dequeue操作函数
function dequeue(queue) {
  return queue.items.shift();
}

// 子级：创建异步队列
function createAsyncQueue() {
  const baseQueue = createQueue();
  return {
    ...baseQueue,
    awaiters: createQueue(),
    enqueue(item) {
      const awaiter = dequeue(this.awaiters);
      if (awaiter !== undefined) {
        setImmediate(() => {
          awaiter(item);
        });
      } else {
        // 调用父级enqueue函数，传递当前队列和item
        enqueue(this, item);
      }
      return item;
    },
    dequeue() {
      return dequeue(this);
    }
  };
}

内容的提问来源于stack exchange，提问作者Gary