JS生态系统加速一次一库PostCSS SVGO的重构源码和性能优化探索

function isBlockIgnored(ruleOrDeclaration) {
  const rule = ruleOrDeclaration.selector
    ? ruleOrDeclaration
    : ruleOrDeclaration.parent

  return /(!\s*)?postcss-custom-properties:\s*off\b/i.test(rule.toString())
}

/**
 * 降低路径数据中浮点数的精度
 * 保持指定数量的小数。
 * 智能四舍五入：比如 2.3491 取舍为 2.35 而不是 2.349
 */
function strongRound(data: number[]) {
 for (var i = data.length; i-- > 0; ) {
  if (data[i].toFixed(precision) != data[i]) {
   var rounded = +data[i].toFixed(precision - 1);
   data[i] =
    +Math.abs(rounded - data[i]).toFixed(precision + 1) >= error
     ? +data[i].toFixed(precision)
     : rounded;
  }
 }
 return data;
}

function strongRound(data: number[]) {
 for (var i = data.length; i-- > 0; ) {
  // string 和 number 比较 -> string 转换为 number
  if (data[i].toFixed(precision) != data[i]) {
   // 基于 number 创建 string，然后立刻转换为 number
   var rounded = +data[i].toFixed(precision - 1);
   data[i] =
    // number 转 string，然后直接转换为 number
    +Math.abs(rounded - data[i]).toFixed(precision + 1) >= error
     ? // 这和之前的 if 条件的值相同
       // 只是再次转换为 number
       +data[i].toFixed(precision)
     : rounded;
  }
 }
 return data;
}

// 类似 Number.prototype.toFixed 的功能
// 但返回值不转换为 string
function toFixed(num, precision) {
 const pow = 10 ** precision;
 return Math.round(num * pow) / pow;
}

// 重写避免 string 转换
// 调用我们自己的 toFixed() 函数
function strongRound(data: number[]) {
 for (let i = data.length; i-- > 0; ) {
  const fixed = toFixed(data[i], precision);
  // 我们可以使用严格相等比较
  if (fixed !== data[i]) {
   const rounded = toFixed(data[i], precision - 1);
   data[i] =
    toFixed(Math.abs(rounded - data[i]), precision + 1) >= error
     ? fixed // 现在这里我们可以复用之前的值
     : rounded;
  }
 }
 return data;
}

const stringifyNumber = (number: number, precision: number) => {
 // 从十进制数中删除零整数
 return number.toString().replace(/^0\./, ".").replace(/^-0\./, "-.");
};

const stringifyNumber = (number: number, precision: number) => {
  // 从十进制数中删除零整数
 const strNum = number.toString();
 // 使用简单数字检验
 if (0 < num && num < 1) {
  return strNum.replace(/^0\./, ".");
 } else if (-1 < num && num < 0) {
  return strNum.replace(/^-0\./, "-.");
 }
 return strNum;
};

const stringifyNumber = (number: number, precision: number) => {
  // 从十进制数中删除零整数
 const strNum = number.toString();
 if (0 < num && num < 1) {
  // 我们只需要简单的字符串处理
  return strNum.slice(1);
 } else if (-1 < num && num < 0) {
  // 我们只需要简单的字符串处理
  return "-" + strNum.slice(2);
 }
 return strNum;
};

function perItem(data, info, plugin, params, reverse) {
  function monkeys(items) {
    items.children = items.children.filter(function (item) {
      // 反向通过
      if (reverse && item.children) {
        monkeys(item)
      }
      // 主要过滤
      let kept = true
      if (plugin.active) {
        kept = plugin.fn(item, params, info) !== false
      }
      // 直接通过
      if (!reverse && item.children) {
        monkeys(item)
      }
      return kept
    })
    return items
  }
  return monkeys(data)
}

function perItem(items, info, plugin, params, reverse) {
  items.children = items.children.filter(function (item) {
    // 反向通过
    if (reverse && item.children) {
      perItem(item, info, plugin, params, reverse)
    }
    // 主要过滤
    let kept = true
    if (plugin.active) {
      kept = plugin.fn(item, params, info) !== false
    }
    // 直接通过
    if (!reverse && item.children) {
      perItem(item, info, plugin, params, reverse)
    }
    return kept
  })
  return items
}

class ConditionalRuleset {
  getSortedRuleset() {
    //...
    var _loop = function _loop(query, dependents) {
      doSomething()
    }

    for (var [query, dependents] of this.precedenceLookup.entries()) {
      _loop(query, dependents)
    }
    //...
  }
}

class ConditionalRuleset {
  getSortedRuleset() {
    //...
    for (var [query, dependents] of this.precedenceLookup.entries()) {
      doSomething()
    }
    //...
  }
}