@zwa73/utils 1.0.1 → 1.0.3

package/src/UtilClass.ts

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