深入出不来nodejs源码-timer模块(JS篇)

function TimersList(msecs, unrefed) {
  // 前指针
  this._idleNext = this;
  // 后指针
  this._idlePrev = this;

  // 数据
  this._unrefed = unrefed;
  this.msecs = msecs;
  // ...更多
}

function remove(item) {
  // 处理前后节点的指针指向
  if (item._idleNext) {
    item._idleNext._idlePrev = item._idlePrev;
  }

  if (item._idlePrev) {
    item._idlePrev._idleNext = item._idleNext;
  }

  // 重置节点自身指针指向
  item._idleNext = null;
  item._idlePrev = null;
}

function append(list, item) {
  // 先保证传入节点是空白节点
  if (item._idleNext || item._idlePrev) {
    remove(item);
  }

  // 处理新节点的头尾链接
  item._idleNext = list._idleNext;
  item._idlePrev = list;

  // 处理list的前指针指向
  list._idleNext._idlePrev = item;
  list._idleNext = item;
}

/**
 * 
 * @param {Function} callback 延迟触发的函数
 * @param {Number} after 延迟时间
 * @param {*} arg1 额外参数1
 * @param {*} arg2 额外参数2
 * @param {*} arg3 额外参数3
 */
function setTimeout(callback, after, arg1, arg2, arg3) {
  // 只有第一个函数参数是必须的
  if (typeof callback !== 'function') {
    throw new ERR_INVALID_CALLBACK();
  }

  var i, args;
  /**
   * 参数修正
   * 简单来说 就是将第三个以后的参数包装成数组
   */
  switch (arguments.length) {
    case 1:
    case 2:
      break;
    case 3:
      args = [arg1];
      break;
    case 4:
      args = [arg1, arg2];
      break;
    default:
      args = [arg1, arg2, arg3];
      for (i = 5; i < arguments.length; i++) {
        args[i - 2] = arguments[i];
      }
      break;
  }
  // 生成一个Timeout对象
  const timeout = new Timeout(callback, after, args, false, false);
  active(timeout);
  // 返回该对象
  return timeout;
}

/**
 * 
 * @param {Function} callback 回调函数
 * @param {Number} after 延迟时间
 * @param {Array} args 参数数组
 * @param {Boolean} isRepeat 是否重复执行(setInterval/setTimeout)
 * @param {Boolean} isUnrefed 不知道是啥玩意
 */
function Timeout(callback, after, args, isRepeat, isUnrefed) {
  /**
   * 对延迟时间参数进行数字类型转换
   * 数字类型字符串 会变成数字
   * 非数字非数字字符串 会变成NaN
   */
  after *= 1;
  if (!(after >= 1 && after <= TIMEOUT_MAX)) {
    // 最大为2147483647 官网有写
    if (after > TIMEOUT_MAX) {
      process.emitWarning(`${after} does not fit into` +
                          ' a 32-bit signed integer.' +
                          '\nTimeout duration was set to 1.',
                          'TimeoutOverflowWarning');
    }
    // 小于1、大于最大限制、非法参数均会被重置为1
    after = 1;
  }

  // 调用标记
  this._called = false;
  // 延迟时间
  this._idleTimeout = after;
  // 前后指针
  this._idlePrev = this;
  this._idleNext = this;
  this._idleStart = null;
  // V8层面的优化我也不太懂 留下英文注释自己研究吧
  // this must be set to null first to avoid function tracking
  // on the hidden class, revisit in V8 versions after 6.2
  this._onTimeout = null;
  // 回调函数
  this._onTimeout = callback;
  // 参数
  this._timerArgs = args;
  // setInterval的参数
  this._repeat = isRepeat ? after : null;
  // 摧毁标记
  this._destroyed = false;

  this[unrefedSymbol] = isUnrefed;
  // 暂时不晓得干啥的
  initAsyncResource(this, 'Timeout');
}

const refedLists = Object.create(null);
const unrefedLists = Object.create(null);

const active = exports.active = function(item) {
  insert(item, false);
};

/**
 * 
 * @param {Timeout} item 定时器对象
 * @param {Boolean} unrefed 区分内部/外部调用
 * @param {Boolean} start 不晓得干啥的
 */
function insert(item, unrefed, start) {
  // 取出延迟时间
  const msecs = item._idleTimeout;
  if (msecs < 0 || msecs === undefined) return;

  if (typeof start === 'number') {
    item._idleStart = start;
  } else {
    item._idleStart = TimerWrap.now();
  }

  // 内部使用定时器使用不同对象
  const lists = unrefed === true ? unrefedLists : refedLists;

  // 延迟时间作为键来生成一个链表类型值
  var list = lists[msecs];
  if (list === undefined) {
    debug('no %d list was found in insert, creating a new one', msecs);
    lists[msecs] = list = new TimersList(msecs, unrefed);
  }

  // 留个坑 暂时不懂这个
  if (!item[async_id_symbol] || item._destroyed) {
    item._destroyed = false;
    initAsyncResource(item, 'Timeout');
  }
  // 把当前timeout对象添加到对应的链表上
  L.append(list, item);
  assert(!L.isEmpty(list));
}

function TimersList(msecs, unrefed) {
  this._idleNext = this;
  this._idlePrev = this;
  this._unrefed = unrefed;
  this.msecs = msecs;

  // 来源于C++内置模块
  const timer = this._timer = new TimerWrap();
  timer._list = this;

  if (unrefed === true)
    timer.unref();
  // 触发
  timer.start(msecs);
}