arayts/dist/src/array/array.d.ts

让 TypeScript 开发如丝般顺滑。ArayTS 提供了一套高效、优雅的算法工具集，包含常用的数据结构与算法实现，帮助开发者轻松构建可靠的应用程序。

declare class ArrayUtils {
    /**
     * 数组去重
     */
    static unique<T>(arr: T[]): T[];
    /**
     * 数组扁平化
     */
    static flatten<T>(arr: any[]): T[];
    /**
     * 数组分组
     */
    static groupBy<T>(arr: T[], key: keyof T): {
        [key: string]: T[];
    };
    /**
     * 数组排序（支持多字段）
     */
    static sortBy<T>(arr: T[], ...keys: (keyof T)[]): T[];
    /**
     * 数组交集
     */
    static intersection<T>(...arrays: T[][]): T[];
    /**
     * 数组差集
     */
    static difference<T>(arr1: T[], arr2: T[]): T[];
    /**
     * 数组分块
     */
    static chunk<T>(arr: T[], size: number): T[][];
    /**
     * 移除数组中的假值
     */
    static compact<T>(arr: T[]): T[];
    /**
     * 获取数组中指定属性的值
     */
    static pluck<T, K extends keyof T>(arr: T[], key: K): T[K][];
    /**
     * 数组随机打乱
     */
    static shuffle<T>(arr: T[]): T[];
    /**
    * 数组去重并按照指定字段排序
    */
    static uniqueAndSort<T extends Record<string, any>>(arr: T[], key: keyof T): T[];
    /**
     * 查找数组中出现次数最多的元素
     */
    static mostFrequent<T>(arr: T[]): {
        element: T;
        count: number;
    } | null;
    /**
     * 数组分页
     */
    static paginate<T>(arr: T[], page: number, pageSize: number): {
        data: T[];
        total: number;
        currentPage: number;
        totalPages: number;
    };
    /**
     * 数组深度比较
     */
    static isEqual<T>(arr1: T[], arr2: T[]): boolean;
    /**
     * 数组元素统计
     */
    static countBy<T>(arr: T[], key: keyof T): {
        [key: string]: number;
    };
    /**
     * 数组窗口滑动
     */
    static sliding<T>(arr: T[], windowSize: number, step?: number): T[][];
    /**
     * 数组交叉合并
     */
    static zip<T, U>(arr1: T[], arr2: U[]): [T, U][];
    /**
     * 数组求并集
     */
    static union<T>(...arrays: T[][]): T[];
    /**
     * 数组元素位置交换
     */
    static swap<T>(arr: T[], index1: number, index2: number): T[];
    /**
     * 数组转树形结构
     */
    static toTree<T extends {
        id: number | string;
        parentId: number | string | null;
    }>(arr: T[], parentId?: number | string | null): (T & {
        children: T[];
    })[];
    /**
     * 带权重的随机选择
     * @param arr 源数组
     * @param weights 权重数组
     * @returns 根据权重随机选择的元素
     */
    static weightedRandom<T>(arr: T[], weights: number[]): T;
    /**
     * 查找最长连续序列
     * @param arr 数字数组
     * @returns 最长连续序列的长度
     */
    static longestConsecutive(arr: number[]): number;
    /**
     * 获取滑动窗口最大值
     * @param arr 数字数组
     * @param k 窗口大小
     * @returns 每个窗口的最大值数组
     */
    static maxSlidingWindow(arr: number[], k: number): number[];
    /**
     * 带条件的分组聚合
     * @param arr 源数组
     * @param groupKey 分组键
     * @param aggregates 聚合函数配置
     */
    static groupByWithAggregates<T extends Record<string, any>>(arr: T[], groupKey: keyof T, aggregates: {
        [key: string]: {
            field: keyof T;
            operation: 'sum' | 'avg' | 'max' | 'min' | 'count';
        };
    }): Record<string, Record<string, number>>;
    /**
     * 计算多个数组的笛卡尔积
     * @param arrays 多个数组
     * @returns 笛卡尔积结果
     */
    static cartesianProduct<T>(...arrays: T[][]): T[][];
    /**
     * 数组环形旋转
     */
    static rotate<T>(arr: T[], k: number): T[];
    /**
     * 计算数组中位数
     */
    static median(arr: number[]): number;
    /**
     * 动态过滤数组
     */
    static filterDynamic<T>(arr: T[], conditions: Array<{
        field: keyof T;
        operator: '==' | '!=' | '>' | '<' | '>=' | '<=';
        value: any;
    }>): T[];
    /**
     * 数组移动元素
     */
    static move<T>(arr: T[], fromIndex: number, toIndex: number): T[];
    /**
     * 查找数组中的峰值元素索引
     */
    static findPeakElement(arr: number[]): number;
    /**
     * 数组的运行时累加
     */
    static runningSum(arr: number[]): number[];
    /**
     * 查找最接近目标值的元素
     */
    static findClosest<T extends number>(arr: T[], target: number): T;
}
export default ArrayUtils;
//# sourceMappingURL=array.d.ts.map