gcl/com/coooders/module/tool.js

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

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.exclusiveOr = exports.subtract = exports.unsec = exports.union = exports.insec = exports.intersect = exports.Spliter = exports.tcd = exports.gcd = undefined;

var _keys = require("babel-runtime/core-js/object/keys");

var _keys2 = _interopRequireDefault(_keys);

var _classCallCheck2 = require("babel-runtime/helpers/classCallCheck");

var _classCallCheck3 = _interopRequireDefault(_classCallCheck2);

var _createClass2 = require("babel-runtime/helpers/createClass");

var _createClass3 = _interopRequireDefault(_createClass2);

var _tool = require("../common/tool");

var _tool2 = _interopRequireDefault(_tool);

var _dns = require("dns");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * gcd 使用辗转相除法获取最大公约数 http://blog.jobbole.com/106315/
 */
var gcd = exports.gcd = function gcd(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 使用辗转相除法获取用最大公约数求最小公倍数
 */
var tcd = exports.tcd = function tcd(a, b) {
  return a / gcd(a, b) * b;
};

var Spliter = exports.Spliter = function () {
  function Spliter() {
    var strs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
    (0, _classCallCheck3.default)(this, Spliter);

    var that = this;

    var _pri = pri(that, { buffer: [], isComplete: false, root: {} }),
        _ = _pri._,
        __ = _pri.__;

    if (strs && strs.length > 0) {
      strs.forEach(function (v) {
        var ds = new Buffer.from(v).toJSON().data;
        var start = __.root;
        ds.forEach(function (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("构造函数必须输入字符值");
  }

  (0, _createClass3.default)(Spliter, [{
    key: "next",
    value: function next(data) {
      var _pri2 = pri(that),
          _ = _pri2._,
          __ = _pri2.__;

      if (__.now[data]) {
        __.buffer.push(data);
        if (__.now[data].end) {
          __.isComplete = true;
          __.buffer = __.now[data].end;
        }
        __.now = __.now[data];
        return true;
      } else return false;
    }
  }, {
    key: "reset",
    value: function reset() {
      var _pri3 = pri(that),
          _ = _pri3._,
          __ = _pri3.__;

      __.buffer = [];
      __.isComplete = false;
      __.now = __.root;
    }
  }, {
    key: "isComplete",
    get: function get() {
      return __.isComplete;
    }
  }, {
    key: "rest",
    get: function get() {
      return __.buffer;
    }
  }]);
  return Spliter;
}();

/**
 * 取ID交集 数组复制最快是.concat()
 * @param  {...any} args
 */
var intersect = exports.intersect = function intersect() {
  var ret = {};
  try {
    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
      args[_key] = arguments[_key];
    }

    //数组排序
    args.sort(function (a, b) {
      return (a.length || 0) - (b.length || 0);
    });
    args.shift().map(function (v) {
      return ret[v] = 1;
    });
    args.forEach(function (v) {
      var _ret = {};
      v.forEach(function (v) {
        if (ret[v]) _ret[v] = 1;
      });
      ret = null;
      ret = _ret;
    });
    return (0, _keys2.default)(ret);
  } finally {
    ret = null;
  }
};

var insec = exports.insec = intersect;

/**
 * 取ID并集
 * @param  {...any} args
 */
var union = exports.union = function union() {
  var ret = {};
  try {
    for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }

    //数组排序
    args.forEach(function (v) {
      v.forEach(function (v) {
        return ret[v] = 1;
      });
    });
    return (0, _keys2.default)(ret);
  } finally {
    ret = null;
  }
};

var unsec = exports.unsec = union;

/**
 * 取ID补集
 * @param  {...any} args
 */
var subtract = exports.subtract = function subtract() {
  var ret = {};
  try {
    for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
      args[_key3] = arguments[_key3];
    }

    //数组排序
    args.shift().map(function (v) {
      return ret[v] = 1;
    });
    args.forEach(function (v) {
      v.forEach(function (v) {
        delete ret[v];
      });
    });
    return (0, _keys2.default)(ret);
  } finally {
    ret = null;
  }
};

/**
 * 取ID差集
 * @param  {...any} args
 */
var exclusiveOr = exports.exclusiveOr = function exclusiveOr() {
  var ret = {};
  try {
    for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
      args[_key4] = arguments[_key4];
    }

    //数组排序
    args.shift().map(function (v) {
      return ret[v] = 1;
    });
    args.forEach(function (v) {
      var _ret = {};
      v.forEach(function (v) {
        if (ret[v] || _ret[v]) {
          _ret[v] = 1;
          delete ret[v];
        } else ret[v] = 1;
      });
    });
    return (0, _keys2.default)(ret);
  } finally {
    ret = null;
  }
};

exports.default = {
  gcd: gcd,
  tcd: tcd,
  Spliter: Spliter,
  intersect: intersect,
  union: union,
  subtract: subtract,
  exclusiveOr: exclusiveOr,
  insec: insec,
  unsec: unsec
};

var pri = _tool2.default.pris();
//# sourceMappingURL=tool.js.map