arayts
Version:
让 TypeScript 开发如丝般顺滑。ArayTS 提供了一套高效、优雅的算法工具集，包含常用的数据结构与算法实现，帮助开发者轻松构建可靠的应用程序。
444 lines (443 loc) • 14.9 kB
JavaScript
;
var __assign = (this && this.__assign) || function () {
__assign = Object.assign || function(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
if (ar || !(i in from)) {
if (!ar) ar = Array.prototype.slice.call(from, 0, i);
ar[i] = from[i];
}
}
return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
var ArrayUtils = /** @class */ (function () {
function ArrayUtils() {
}
/**
* 数组去重
*/
ArrayUtils.unique = function (arr) {
return Array.from(new Set(arr));
};
/**
* 数组扁平化
*/
ArrayUtils.flatten = function (arr) {
return arr.reduce(function (flat, toFlat) {
return flat.concat(Array.isArray(toFlat) ? ArrayUtils.flatten(toFlat) : toFlat);
}, []);
};
/**
* 数组分组
*/
ArrayUtils.groupBy = function (arr, key) {
return arr.reduce(function (groups, item) {
var groupKey = String(item[key]);
groups[groupKey] = groups[groupKey] || [];
groups[groupKey].push(item);
return groups;
}, {});
};
/**
* 数组排序（支持多字段）
*/
ArrayUtils.sortBy = function (arr) {
var keys = [];
for (var _i = 1; _i < arguments.length; _i++) {
keys[_i - 1] = arguments[_i];
}
return __spreadArray([], arr, true).sort(function (a, b) {
for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
var key = keys_1[_i];
if (a[key] < b[key])
return -1;
if (a[key] > b[key])
return 1;
}
return 0;
});
};
/**
* 数组交集
*/
ArrayUtils.intersection = function () {
var arrays = [];
for (var _i = 0; _i < arguments.length; _i++) {
arrays[_i] = arguments[_i];
}
return arrays.reduce(function (a, b) { return a.filter(function (c) { return b.includes(c); }); });
};
/**
* 数组差集
*/
ArrayUtils.difference = function (arr1, arr2) {
return arr1.filter(function (x) { return !arr2.includes(x); });
};
/**
* 数组分块
*/
ArrayUtils.chunk = function (arr, size) {
return Array.from({ length: Math.ceil(arr.length / size) }, function (_, i) {
return arr.slice(i * size, i * size + size);
});
};
/**
* 移除数组中的假值
*/
ArrayUtils.compact = function (arr) {
return arr.filter(Boolean);
};
/**
* 获取数组中指定属性的值
*/
ArrayUtils.pluck = function (arr, key) {
return arr.map(function (item) { return item[key]; });
};
/**
* 数组随机打乱
*/
ArrayUtils.shuffle = function (arr) {
var _a;
var result = __spreadArray([], arr, true);
for (var i = result.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
_a = [result[j], result[i]], result[i] = _a[0], result[j] = _a[1];
}
return result;
};
/**
* 数组去重并按照指定字段排序
*/
ArrayUtils.uniqueAndSort = function (arr, key) {
// 使用 Map 来存储唯一项
var uniqueMap = new Map();
// 遍历数组，将每个项按照指定的 key 存储
for (var _i = 0, arr_1 = arr; _i < arr_1.length; _i++) {
var item = arr_1[_i];
var keyValue = item[key];
if (!uniqueMap.has(keyValue)) {
uniqueMap.set(keyValue, item);
}
}
// 转换为数组并排序
return Array.from(uniqueMap.values()).sort(function (a, b) {
if (a[key] < b[key])
return -1;
if (a[key] > b[key])
return 1;
return 0;
});
};
/**
* 查找数组中出现次数最多的元素
*/
ArrayUtils.mostFrequent = function (arr) {
if (arr.length === 0)
return null;
var frequency = arr.reduce(function (acc, curr) {
acc[String(curr)] = (acc[String(curr)] || 0) + 1;
return acc;
}, {});
var maxFreq = Math.max.apply(Math, Object.values(frequency));
var element = Object.keys(frequency).find(function (key) { return frequency[key] === maxFreq; });
return { element: element, count: maxFreq };
};
/**
* 数组分页
*/
ArrayUtils.paginate = function (arr, page, pageSize) {
var total = arr.length;
var totalPages = Math.ceil(total / pageSize);
var currentPage = Math.max(1, Math.min(page, totalPages));
var start = (currentPage - 1) * pageSize;
var data = arr.slice(start, start + pageSize);
return {
data: data,
total: total,
currentPage: currentPage,
totalPages: totalPages
};
};
/**
* 数组深度比较
*/
ArrayUtils.isEqual = function (arr1, arr2) {
if (arr1.length !== arr2.length)
return false;
return JSON.stringify(arr1.sort()) === JSON.stringify(arr2.sort());
};
/**
* 数组元素统计
*/
ArrayUtils.countBy = function (arr, key) {
return arr.reduce(function (acc, curr) {
var value = String(curr[key]);
acc[value] = (acc[value] || 0) + 1;
return acc;
}, {});
};
/**
* 数组窗口滑动
*/
ArrayUtils.sliding = function (arr, windowSize, step) {
if (step === void 0) { step = 1; }
var windows = [];
for (var i = 0; i <= arr.length - windowSize; i += step) {
windows.push(arr.slice(i, i + windowSize));
}
return windows;
};
/**
* 数组交叉合并
*/
ArrayUtils.zip = function (arr1, arr2) {
var length = Math.min(arr1.length, arr2.length);
return Array.from({ length: length }, function (_, i) { return [arr1[i], arr2[i]]; });
};
/**
* 数组求并集
*/
ArrayUtils.union = function () {
var arrays = [];
for (var _i = 0; _i < arguments.length; _i++) {
arrays[_i] = arguments[_i];
}
return ArrayUtils.unique(arrays.flat());
};
/**
* 数组元素位置交换
*/
ArrayUtils.swap = function (arr, index1, index2) {
var _a;
var result = __spreadArray([], arr, true);
_a = [result[index2], result[index1]], result[index1] = _a[0], result[index2] = _a[1];
return result;
};
/**
* 数组转树形结构
*/
ArrayUtils.toTree = function (arr, parentId) {
if (parentId === void 0) { parentId = null; }
return arr
.filter(function (item) { return item.parentId === parentId; })
.map(function (item) { return (__assign(__assign({}, item), { children: ArrayUtils.toTree(arr, item.id) })); });
};
/**
* 带权重的随机选择
* @param arr 源数组
* @param weights 权重数组
* @returns 根据权重随机选择的元素
*/
ArrayUtils.weightedRandom = function (arr, weights) {
if (arr.length !== weights.length) {
throw new Error('数组长度与权重数组长度不匹配');
}
var totalWeight = weights.reduce(function (sum, weight) { return sum + weight; }, 0);
var random = Math.random() * totalWeight;
for (var i = 0; i < arr.length; i++) {
random -= weights[i];
if (random <= 0) {
return arr[i];
}
}
return arr[arr.length - 1];
};
/**
* 查找最长连续序列
* @param arr 数字数组
* @returns 最长连续序列的长度
*/
ArrayUtils.longestConsecutive = function (arr) {
if (arr.length === 0)
return 0;
var numSet = new Set(arr);
var longest = 0;
Array.from(numSet).forEach(function (num) {
if (!numSet.has(num - 1)) {
var currentNum = num;
var currentStreak = 1;
while (numSet.has(currentNum + 1)) {
currentNum += 1;
currentStreak += 1;
}
longest = Math.max(longest, currentStreak);
}
});
return longest;
};
/**
* 获取滑动窗口最大值
* @param arr 数字数组
* @param k 窗口大小
* @returns 每个窗口的最大值数组
*/
ArrayUtils.maxSlidingWindow = function (arr, k) {
var result = [];
var deque = [];
for (var i = 0; i < arr.length; i++) {
// 移除超出窗口范围的索引
while (deque.length > 0 && deque[0] <= i - k) {
deque.shift();
}
// 移除所有小于当前元素的值
while (deque.length > 0 && arr[deque[deque.length - 1]] < arr[i]) {
deque.pop();
}
deque.push(i);
// 当窗口完全形成后，记录最大值
if (i >= k - 1) {
result.push(arr[deque[0]]);
}
}
return result;
};
/**
* 带条件的分组聚合
* @param arr 源数组
* @param groupKey 分组键
* @param aggregates 聚合函数配置
*/
ArrayUtils.groupByWithAggregates = function (arr, groupKey, aggregates) {
var groups = ArrayUtils.groupBy(arr, groupKey);
var result = {};
for (var _i = 0, _a = Object.entries(groups); _i < _a.length; _i++) {
var _b = _a[_i], key = _b[0], group = _b[1];
result[key] = {};
var _loop_1 = function (aggKey, field, operation) {
switch (operation) {
case 'sum':
result[key][aggKey] = group.reduce(function (sum, item) { return sum + Number(item[field]); }, 0);
break;
case 'avg':
result[key][aggKey] = group.reduce(function (sum, item) { return sum + Number(item[field]); }, 0) / group.length;
break;
case 'max':
result[key][aggKey] = Math.max.apply(Math, group.map(function (item) { return Number(item[field]); }));
break;
case 'min':
result[key][aggKey] = Math.min.apply(Math, group.map(function (item) { return Number(item[field]); }));
break;
case 'count':
result[key][aggKey] = group.length;
break;
}
};
for (var _c = 0, _d = Object.entries(aggregates); _c < _d.length; _c++) {
var _e = _d[_c], aggKey = _e[0], _f = _e[1], field = _f.field, operation = _f.operation;
_loop_1(aggKey, field, operation);
}
}
return result;
};
/**
* 计算多个数组的笛卡尔积
* @param arrays 多个数组
* @returns 笛卡尔积结果
*/
ArrayUtils.cartesianProduct = function () {
var arrays = [];
for (var _i = 0; _i < arguments.length; _i++) {
arrays[_i] = arguments[_i];
}
if (arrays.length === 0)
return [[]];
return arrays.reduce(function (acc, curr) {
return acc.flatMap(function (x) { return curr.map(function (y) { return __spreadArray(__spreadArray([], x, true), [y], false); }); });
}, [[]]);
};
/**
* 数组环形旋转
*/
ArrayUtils.rotate = function (arr, k) {
var len = arr.length;
k = k % len;
var result = __spreadArray([], arr, true);
var temp = result.splice(-k);
return __spreadArray(__spreadArray([], temp, true), result, true);
};
/**
* 计算数组中位数
*/
ArrayUtils.median = function (arr) {
var sorted = __spreadArray([], arr, true).sort(function (a, b) { return a - b; });
var mid = Math.floor(sorted.length / 2);
return sorted.length % 2 === 0
? (sorted[mid - 1] + sorted[mid]) / 2
: sorted[mid];
};
/**
* 动态过滤数组
*/
ArrayUtils.filterDynamic = function (arr, conditions) {
return arr.filter(function (item) {
return conditions.every(function (condition) {
var value = item[condition.field];
switch (condition.operator) {
case '==': return value === condition.value;
case '!=': return value !== condition.value;
case '>': return value > condition.value;
case '<': return value < condition.value;
case '>=': return value >= condition.value;
case '<=': return value <= condition.value;
default: return true;
}
});
});
};
/**
* 数组移动元素
*/
ArrayUtils.move = function (arr, fromIndex, toIndex) {
var result = __spreadArray([], arr, true);
var element = result.splice(fromIndex, 1)[0];
result.splice(toIndex, 0, element);
return result;
};
/**
* 查找数组中的峰值元素索引
*/
ArrayUtils.findPeakElement = function (arr) {
var left = 0;
var right = arr.length - 1;
while (left < right) {
var mid = Math.floor((left + right) / 2);
if (arr[mid] > arr[mid + 1]) {
right = mid;
}
else {
left = mid + 1;
}
}
return left;
};
/**
* 数组的运行时累加
*/
ArrayUtils.runningSum = function (arr) {
var result = __spreadArray([], arr, true);
for (var i = 1; i < result.length; i++) {
result[i] += result[i - 1];
}
return result;
};
/**
* 查找最接近目标值的元素
*/
ArrayUtils.findClosest = function (arr, target) {
return arr.reduce(function (prev, curr) {
return Math.abs(curr - target) < Math.abs(prev - target) ? curr : prev;
});
};
return ArrayUtils;
}());
exports.default = ArrayUtils;