@iicoding/utils/dist/esm/array/index.js

Browser 端 - 类型判断 - 类似 koa 的异步compose - sleep - 扩展对象属性 - 扩展 storage 对象功能

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
import { isNumber } from "../type-detection";
/**
 * @summary diff 两个数组 返回相同项的 数组
 * @param source 待比对的源数组
 * @param target 被比对的目标数组
 */
export var arrayDiff = function arrayDiff(source, target) {
  return source.filter(function (item) {
    return target.includes(item);
  });
};

/**
 * @summary 计算数组中 相邻两位相加的和，如果大于某一值，则 减去某一值, 结果 去重返回
 * @param datasource 目标数组
 * @param subtractionNumber 对比的值 比如大于 100
 */
export var computeNeighborTwoSum = function computeNeighborTwoSum(datasource, subtractionNumber) {
  if (!Array.isArray(datasource)) return [];
  var source = _toConsumableArray(datasource);
  var result = [];
  while (source.length > 1) {
    var _source = _slicedToArray(source, 2),
      one = _source[0],
      two = _source[1];
    var sum = one + two;
    if (isNumber(sum)) {
      result.push(subtractionNumber ? sum > subtractionNumber ? sum - subtractionNumber : sum : sum);
      source.shift();
    }
  }
  return Array.from(new Set(result)).sort(function (a, b) {
    return a - b;
  });
};

/**
 * @summary 1-80 数字中的特殊号码
 */
export var specialNumberData = function specialNumberData() {
  return [6, 15, 17, 22, 23, 29, 31, 32, 37, 40, 43, 46, 49, 52, 53, 58, 59, 60, 66, 67, 68, 69, 74, 75, 76, 77, 80];
};

/**
 * @summary 随机打乱数组 使用Fisher-Yates算法
 * @param arr 目标数组
 */
export var shuffle = function shuffle(arr) {
  for (var i = arr.length - 1; i > 0; i--) {
    var j = Math.floor(Math.random() * (i + 1));
    var _ref = [arr[j], arr[i]];
    arr[i] = _ref[0];
    arr[j] = _ref[1];
  }
  return arr;
};

/**
 * @summary 生成指定长度的顺序数组
 * @param length 指定长度
 * @param startIndex 是否从其实索引开始
 * @example generateNumberArray(3) => [1, 2, 3]
 */
export var generateNumberArray = function generateNumberArray(length) {
  var startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  return _toConsumableArray(Array.from({
    length: length
  }, function (_, i) {
    return startIndex ? i : i + 1;
  }));
};

/**
 * @summary 生成指定长度，指定每个数组项值的数组，
 * @param length 指定长度
 * @param value 指定的值
 * @example generateSpecifyValueAndLengthArray(3, '5') => ['5', '5', '5']
 */
export var generateSpecifyValueAndLengthArray = function generateSpecifyValueAndLengthArray(length, value) {
  return Array.from({
    length: length
  }, function () {
    return value;
  });
};

/**
 * @summary 获取 源数组 在 目标数组中的项 返回一个新的数组
 * @param source 源数组
 * @param target 目标数组
 * @example getSourceItemInTarget([1, 2, 3], [2,4,5]) => [2]
 */
export var getSourceItemInTarget = function getSourceItemInTarget(source, target) {
  return target.filter(function (item) {
    return source.includes(item);
  });
};

/**
 * 根据对象数组的中的某一个属性排序
 * @param source 数据源 object list
 * @param sortProperties 排序的属性
 * @param defaultValue obj[排序的属性] 的值不存在时 的 默认值
 */
export var objectSort = function objectSort(source, sortProperties, defaultValue) {
  if (Array.isArray(source)) {
    source.sort(function (a, b) {
      return (a[sortProperties] || defaultValue) - (b[sortProperties] || defaultValue);
    });
  }
};

/**
 * @summary 过滤原数组得到一个只有 number 类型的结果数组
 * @param source
 */
export var filterNumberArray = function filterNumberArray(source) {
  return Array.from(new Set(source.filter(function (item) {
    return isNumber(item) && !Number.isNaN(item);
  })));
};

/**
 * @summary 根据 C(n,k) 获取组合数
 * @description 根据数组分析所有组合的可能性
 * @param list 接收的数组
 * @param options
 */
export var getAllPossibleCompose = function getAllPossibleCompose(list, options) {
  var result = [];
  if (!Array.isArray(list)) {
    console.warn('请传入一个数字组成的数组');
    return result;
  }

  // 去掉非数字类型以及重复的数据
  var uniqList = filterNumberArray(list);
  var _ref2 = options || {},
    _ref2$max = _ref2.max,
    max = _ref2$max === void 0 ? 80 : _ref2$max,
    _ref2$minLength = _ref2.minLength,
    minLength = _ref2$minLength === void 0 ? 5 : _ref2$minLength;
  var clwArrayLen = uniqList.length;
  if (clwArrayLen > max) {
    console.warn('数组最大长度超出限制', max);
    return result;
  }
  if (clwArrayLen < minLength) {
    console.warn('数组不满足最小长度', minLength);
    return result;
  }
  var temp = [];
  function cwlBackTrack(start) {
    if (temp.length === minLength) {
      result.push([].concat(temp));
      return;
    }
    for (var i = start; i < clwArrayLen; i++) {
      // 添加当前数字到组合中
      temp.push(uniqList[i]);
      // 递归填充下一个数字
      cwlBackTrack(i + 1);
      // 回溯，为下一个组合做准备
      temp.pop();
    }
  }
  cwlBackTrack(0);
  return result;
};

/**
 * @summary 多个数组进行可能性分析之后，进行组合
 * @description 多个区域，调用 getAllPossibleCompose 在进行组合
 */
export var multiAreaPossibleCompose = function multiAreaPossibleCompose() {};