gcl/src/coooders/module/tool.js

码农村nodejs类库，完成解决回调陷阱，配置框架，IOC框架，统一多DB访问框架，可扩展日志框架和io/db/net/thread/pool 克隆表达式，加解密算法等等一系列基础类库和算法的实现

import V from "../common/tool";
import { setServers } from "dns";

/**
 * gcd 使用辗转相除法获取最大公约数 http://blog.jobbole.com/106315/
 */
export const gcd = function (a, b) {
  if (a == b) return a;
  else if (a < b) return gcd(b, a);
  else {
    if ((a & 1) == 0 && (b & 1) == 0) {
      //偶数
      return gcd(a >> 1, b >> 1) << 1;
    } else if ((a & 1) == 0 && (b & 1) == 1) return gcd(a >> 1, b);
    else if ((a & 1) == 1 && (b & 1) == 0) return gcd(a, b >> 1);
    else return gcd(a - b, b);
  }
};
/**
 * tcd 使用辗转相除法获取用最大公约数求最小公倍数
 */
export const tcd = function (a, b) {
  return (a / gcd(a, b)) * b;
};

export const Spliter = class {
  constructor(strs = []) {
    const that = this;
    const { _, __ } = pri(that, { buffer: [], isComplete: false, root: {} });
    if (strs && strs.length > 0) {
      strs.forEach((v) => {
        var ds = new Buffer.from(v).toJSON().data;
        var start = __.root;
        ds.forEach((v2) => {
          if (start[v2]) {
            start[v2].length++;
          } else start[v2] = { length: 1 };
          start = start[v2];
        });
        if (start.length > 1)
          throw new Error("分隔符之间不能存在包含或者重复关系");
        start.end = v;
      });
      __.now = __.root;
    } else throw new Error("构造函数必须输入字符值");
  }
  next(data) {
    const { _, __ } = pri(that);
    if (__.now[data]) {
      __.buffer.push(data);
      if (__.now[data].end) {
        __.isComplete = true;
        __.buffer = __.now[data].end;
      }
      __.now = __.now[data];
      return true;
    } else return false;
  }
  get isComplete() {
    return __.isComplete;
  }
  get rest() {
    return __.buffer;
  }
  reset() {
    const { _, __ } = pri(that);
    __.buffer = [];
    __.isComplete = false;
    __.now = __.root;
  }
};

/**
 * 取ID交集 数组复制最快是.concat()
 * @param  {...any} args
 */
export const intersect = function (...args) {
  var ret = {};
  try {
    //数组排序
    args.sort((a, b) => (a.length || 0) - (b.length || 0));
    args.shift().map((v) => (ret[v] = 1));
    args.forEach((v) => {
      var _ret = {};
      v.forEach((v) => {
        if (ret[v]) _ret[v] = 1;
      });
      ret = null;
      ret = _ret;
    });
    return Object.keys(ret);
  } finally {
    ret = null;
  }
};

export const insec = intersect;

/**
 * 取ID并集
 * @param  {...any} args
 */
export const union = function (...args) {
  var ret = {};
  try {
    //数组排序
    args.forEach((v) => {
      v.forEach((v) => (ret[v] = 1));
    });
    return Object.keys(ret);
  } finally {
    ret = null;
  }
};

export const unsec = union;

/**
 * 取ID补集
 * @param  {...any} args
 */
export const subtract = function (...args) {
  var ret = {};
  try {
    //数组排序
    args.shift().map((v) => (ret[v] = 1));
    args.forEach((v) => {
      v.forEach((v) => {
        delete ret[v];
      });
    });
    return Object.keys(ret);
  } finally {
    ret = null;
  }
};

/**
 * 取ID差集
 * @param  {...any} args
 */
export const exclusiveOr = function (...args) {
  var ret = {};
  try {
    //数组排序
    args.shift().map((v) => (ret[v] = 1));
    args.forEach((v) => {
      var _ret = {};
      v.forEach((v) => {
        if (ret[v] || _ret[v]) {
          _ret[v] = 1;
          delete ret[v];
        } else ret[v] = 1;
      });
    });
    return Object.keys(ret);
  } finally {
    ret = null;
  }
};

export default {
  gcd,
  tcd,
  Spliter,
  intersect,
  union,
  subtract,
  exclusiveOr,
  insec,
  unsec,
};
const pri = V.pris();