@zwa73/utils 1.0.1 → 1.0.2

package/dist/UtilClass.d.ts

@@ -0,0 +1,324 @@
+type struct = number | string;
+export declare class SList<T> {
+    private _arr;
+    constructor(obj?: Array<T> | number);
+    /**返回数组长度*/
+    size(): number;
+    /**获取指定下标的元素
+     * @param index 下标
+     */
+    get(index: number): T;
+    /**设置指定下标的元素
+     * 返回自身 改变自身
+     * @param index 下标
+     * @param value 值
+     * @returns 自身
+     */
+    set(index: number, value: T): SList<T>;
+    /**连接两个数组
+     * @param list 目标数组
+     * @returns 新数组
+     */
+    concat(list: SList<T>): SList<T>;
+    /**在数组末尾添加一个元素
+     * 返回自身 改变自身
+     * @param value 值
+     */
+    push(value: T): SList<T>;
+    /**在数组末尾添加一个数组
+     * 改变自身
+     * @param list 目标数组
+     * @returns 自身
+     */
+    pushArr(list: SList<T>): this;
+    /**截取从起始点到结束点之前的一段数组
+     * @param strat 开始点
+     * @param end 结束点
+     * @returns 新数组
+     */
+    slice(strat: number, end: number): SList<T>;
+    /**翻转数组
+     * 改变自身
+     * @returns 自身
+     */
+    reverse(): SList<T>;
+    /**将SList转换为数组 */
+    toArray(): T[];
+    /**返回指定元素在数组中首次出现的位置
+     * @param value 目标元素
+     */
+    indexOf(value: T): number;
+    /**返回指定元素在数组中最后一次出现的位置
+     * @param value 目标元素
+     */
+    lastIndexOf(value: T): number;
+    /**判断数组中是否包含指定元素
+     * @param value 目标元素
+     */
+    contains(value: T): boolean;
+    /**获取迭代器 */
+    iterator(): SIterator<T>;
+    /**从index开始删除count个元素
+     * 改变自身
+     * @param index 起始点
+     * @param count 数量
+     * @returns 自身
+     */
+    removeRange(index: number, count: number): SList<T>;
+    /**删除对应下标下的元素
+     * 改变自身
+     * @param i 下标
+     * @returns 自身
+     */
+    remove(i: number): SList<T>;
+    /**删除第一个匹配的项目(改变长度)
+     * 改变自身
+     * @param obj 需删除目标
+     * @returns 自身
+     */
+    removeMember(obj: T): SList<T>;
+    /**删除所有匹配的项目
+     * 改变自身
+     * @param obj 需删除目标
+     * @returns 自身
+     */
+    removeAllMember(obj: T): SList<T>;
+    /**在这个下标对应的元素前添加一个元素
+     * 改变自身
+     * @param index 下标
+     * @param obj 添加对象
+     * @returns 自身
+     */
+    insert(index: number, obj: T): SList<T>;
+    /**在这个下标对应的元素前添加一组元素
+     * 改变自身
+     * @param index 下标
+     * @param obj 添加对象
+     * @returns 自身
+     */
+    insertRange(index: number, obj: SList<T>): SList<T>;
+    /**克隆数组
+     * @returns 新数组
+     */
+    clone(): SList<T>;
+    /**判断数组是否为空
+     */
+    isEmpty(): boolean;
+    /**删除数组中的重复元素
+     * 改变自身
+     * @returns 自身
+     */
+    removeDuplicates(): SList<T>;
+    /**交集
+     * @param lists 数组列表
+     * @returns 新数组
+     */
+    intersection(...lists: SList<T>[]): SList<T>;
+    /**并集
+     * @param lists 数组列表
+     * @returns 新数组
+     */
+    union(...lists: SList<T>[]): SList<T>;
+    /**返回符合条件的成员组成的新数组
+     * @param func 条件函数
+     * @returns 新数组
+     */
+    filt(func: (value: T) => boolean): SList<T>;
+    /**遍历数组的每一个元素
+     * @param func 处理函数
+     * @returns 自身
+     */
+    each(func: (value: T) => void): SList<T>;
+    /**对数组的每一个元素进行加工，返回加工完成的成员组成的新数组
+     * @param func 加工函数
+     * @returns 新数组
+     */
+    map<O>(func: (value: T) => O): SList<O>;
+    /**对数组进行排序
+     * 如函数返回值大于 0 则将 x 排在 y 后面，小于 0 则将 x 排在 y 前面
+     * 改变自身
+     * @param func 比较函数
+     * @returns 自身
+     */
+    sort(func: (a: T, b: T) => number): SList<T>;
+    /**对数组进行统计
+     * @param init 初始值
+     * @param func 统计函数
+     * @returns 结果
+     */
+    stat<O>(init: O, func: (accumulator: O, currentValue: T) => O): O;
+    [Symbol.iterator](): {
+        next(): {
+            value: T | null;
+            done: boolean;
+        };
+    };
+}
+export declare class SIterator<T> {
+    _index: number;
+    _list: SList<T>;
+    constructor(list: SList<T>);
+    /**判断还有没有下一个元素
+     */
+    hasNext(): boolean;
+    /**判断当前下标有无元素
+     */
+    hasCurr(): boolean;
+    /**判断还有没有上一个元素
+     */
+    hasPre(): boolean;
+    /**返回下一个下标指向的数组内成员,然后下标自加1
+     */
+    next(): T;
+    /**返回上一个下标指向的数组内成员,然后下标自减1
+     */
+    pre(): T;
+    /**返回当前下标指向的数组内成员
+     */
+    curr(): T;
+    /**返回遍历长度
+     * @returns 遍历长度
+     */
+    size(): number;
+    /**获取下个下标
+     * @returns 下个下标
+     */
+    nextIndex(): number;
+    /**获取当前下标
+     * @returns 当前下标
+     */
+    currIndex(): number;
+    /**获取上个下标
+     * @returns 上个下标
+     */
+    preIndex(): number;
+    /**判断是否是最后一个
+     * @returns 是否是最后一个
+     */
+    isLast(): boolean;
+    /**设置数组在迭代器当前下标中的内容
+     * @param val 要设置的值
+     */
+    set(val: T): void;
+    /**删除数组在当前下标的内容，然后将下标移至上一位，改变数组长度
+     */
+    remove(): void;
+    /**在当前下标前插入元素，然后将下标移至原元素，即下一位，改变数组长度
+     * @param obj 要插入的元素
+     */
+    addPre(obj: T): void;
+    /**在当前下标后插入元素，然后将下标移至新元素，即下一位，改变数组长度
+     * @param obj 要插入的元素
+     */
+    addNext(obj: T): void;
+}
+export declare class SEntry<K extends struct, V> {
+    _key: K;
+    _value: V;
+    constructor(key: K, value: V);
+    getKey(): K;
+    getValue(): V;
+}
+export declare class SHashMap<K extends struct, V> {
+    _obj: Record<K, V>;
+    constructor();
+    /**添加一个键值对
+     * @param entry 键值对
+     * @returns 自身
+     */
+    putEntry(entry: SEntry<K, V>): SHashMap<K, V>;
+    /**获取指定键的值
+     * @param key 键
+     * @returns 值
+     */
+    get(key: K): V | null;
+    /**添加一个键值对
+     * @param key 键
+     * @param value 值
+     * @returns 自身
+     */
+    put(key: K, value: V): SHashMap<K, V>;
+    /**判断是否存在指定键
+     * @param key 键
+     * @returns 是否存在
+     */
+    has(key: K): boolean;
+    /**获取所有键值对
+     * @returns 键值对列表
+     */
+    entrys(): SList<SEntry<K, V>>;
+    /**获取所有键
+     * @returns 键列表
+     */
+    keys(): SList<K>;
+    /**获取所有值
+     * @returns 值列表
+     */
+    values(): SList<V>;
+    /**获取迭代器
+     * @returns 迭代器
+     */
+    iterator(): SIterator<SEntry<K, V>>;
+    /**删除指定键的键值对
+     * @param key 键
+     * @returns 删除的值
+     */
+    remove(key: K): V;
+    /**清空哈希表
+     * @returns 自身
+     */
+    clear(): SHashMap<K, V>;
+    /**判断哈希表是否为空
+     * @returns 是否为空
+     */
+    isEmpty(): boolean;
+    /**判断是否存在指定值
+     * @param val 值
+     * @returns 是否存在
+     */
+    containsValue(val: V): boolean;
+    /**判断是否存在指定键
+     * @param key 键
+     * @returns 是否存在
+     */
+    containsKey(key: K): boolean;
+    /**加载指定键的值，若不存在则添加默认值并返回默认值
+     * @param key 键
+     * @param def 默认值
+     * @returns 值或默认值
+     */
+    load(key: K, def: V): V;
+    /**合并另一个哈希表，可选择是否覆盖已有键值对
+     * @param nmap 另一个哈希表
+     * @param isCover 是否覆盖已有键值对，默认为 true
+     * @returns 自身
+     */
+    merge(nmap: SHashMap<K, V>, isCover?: boolean): SHashMap<K, V>;
+    /**获取哈希表大小（键的数量）
+     * @returns 大小（键的数量）
+     */
+    size(): number;
+    /**对哈希表的每一个键值对进行加工，返回加工完成的键值对组成的新哈希表
+     * @param func 加工函数
+     * @returns 新哈希表
+     */
+    map<OK extends struct, OV>(func: (entry: SEntry<K, V>) => SEntry<OK, OV>): SHashMap<OK, OV>;
+    /**返回符合条件的键值对组成的新哈希表
+     * @param func 条件函数
+     * @returns 新哈希表
+     */
+    filt(func: (entry: SEntry<K, V>) => boolean): SHashMap<K, V>;
+    /**遍历哈希表的每一个键值对
+     * @param func 处理函数
+     * @returns 自身
+     */
+    each(func: (entry: SEntry<K, V>) => void): SHashMap<K, V>;
+    /**
+     * 对哈希表进行统计
+     * @param init 初始值
+     * @param func 统计函数
+     * @returns 结果
+     */
+    stat<O>(init: O, func: (accumulator: O, entry: SEntry<K, V>) => O): O;
+}
+export {};