我写了一些Array的扩展方法，interface Array {
    /**
    * 扩展方法：用来获取集合中满足条件的所有数据（返回值是个Array）
    ** 例如：tempList.Select((item)=>item.viewObj.hashCode); 返回:[1166, 1185, 1200, 1224]
    */
    Select<U>(cvt: (item: T) => U): Array<U>;
    /**
    * 扩展方法：用来获取集合中满足条件的所有数据（返回值是个Array）
    */
    Where(predicate: (item: T) => boolean): Array<T>;
    /**
    * 扩展方法：用来获取集合中满足条件的所有数据的索引值（返回值是个Array，包含了符合条件元素的索引）
    */
    WhereIndex(predicate: (item: T) => boolean): Array<number>;
    /**
   * 扩展方法：用来获取集合中是否有某个数据。
   */
    Any(predicate: (item: T) => boolean): boolean;
    /**
    * 扩展方法：用来向集合中添加数据，等同于push操作,但是不提供任何返回值
    */
    Add(item: T): number;
    /**
     * 扩展方法：清空数组中的数据 如果数据是从PoolSystem中创建的则尝试放回缓存队列中去
     */
    Clear(): void
    /**
     * 扩展方法：数组拷贝.  先清空当前数组，然后从target数组中把所有数据拷贝到当前数组中，注意这里是直接赋值的。
     */
    CopyFrom(targetArray: Array<T>): Array<T>;
    /**
     * 扩展方法：查找第一个满足某个条件的元素。并返回这个元素
     */
    First(predicate: (item: T) => boolean): T;
    /**
     * 扩展方法：查找第一个满足某个条件的元素。并返回这个元素的索引，找不到返回-1
     */
    FirstIndex(predicate: (item: T) => boolean): number;
    /**
     * 扩展方法：查找第一个满足某个条件的元素并将其从数组中删除, 返回是否删除成功
     */
    RemoveFirstFind(predicate: (item: T) => boolean): boolean;
    /**
     * 扩展方法：删除数组中指定的某个元素, 返回是否删除成功, 这个删除操作效率要低于RemoveByIndex。
     */
    RemoveByItem(item: T): boolean;
    /**
     * 扩展方法：在数组中找到要删除的元素所在位置，然后将数组中最后一个元素放到这个位置，最后删除数组的最后一个元素的位置，返回是否删除成功
     ** 注意：此操作会修改数组中元素顺序，请谨慎使用
     */
    RemoveByItemAndInsertEndItemHere(item: T): boolean;
    /**
     * 扩展方法：删除数组中指定索引位置的某个元素, 返回是否删除成功
     */
    RemoveByIndex(item: number): boolean;
    /**
     * 扩展方法：克隆一份数据出去   
     ** 注意：是浅拷贝，浅拷贝，浅拷贝
     */
    Clone(): Array<T>;

    /**
     * 扩展方法：从后向前遍历数组,回调的boolean返回值如果是true则停止后续遍历操作,返回false继续遍历
     ** 可以再遍历过程中对数组进行删除操作
     */
    ForEachFromEnd(action: (item: T, index?: number) => boolean): void;
    /** 数据是否脏了(注意此标记只在扩展方法Add和remove等接口中进行了设置，push，shift等默认数据操作接口没有设置，所以，此标记不准确，使用时需要注意) */
    IsDirty: boolean;

}



Array.prototype.CopyFrom = function <T>(targetArray: Array<T>): Array<T> {
    if (targetArray == null) return [];
    this.splice(0, this.length);
    let len: number = targetArray.length;
    for (let i = 0; i < len; ++i) {
        this.Add(targetArray[i]);
    }
    this.IsDirty = true;
    return this;
}


Array.prototype.Clear = function (): void {
    for (var i = 0; i < this.length; i++) {
        var item = this[i];
        if (item[Game.PoolSystem.IsCreateFromPoolSystem] === true)
            Game.PoolSystem.Inst.PushObj(item);
    }
    this.splice(0, this.length);
    this.IsDirty = true;
}

Array.prototype.Add = function <T>(item: T): number {
    let len = this.length;
    this.push(item);
    this.IsDirty = true;
    return len;
}

Array.prototype.Any = function <T>(predicate: (item: T) => boolean): boolean {
    for (var i = 0; i < this.length; i++) {
        var item = this[i];
        if (predicate(item))
            return true;
    }
    return false;
};

/** return a subset of an array matching a predicate */
Array.prototype.Where = function <T>(predicate: (item: T) => boolean): Array<T> {
    let result: Array<T> = [];
    for (var i = 0; i < this.length; i++) {
        var item = this[i];
        if (predicate(item))
            result.push(item);
    }
    return result;
};


Array.prototype.WhereIndex = function <T>(predicate: (item: T) => boolean): Array<number> {
    let result: Array<number> = [];
    for (var i = 0; i < this.length; i++) {
        var item = this[i];
        if (predicate(item))
            result.push(i);
    }
    return result;
}

/** convert an array to another one */
Array.prototype.Select = function <T, U>(cvt: (item: T) => U): Array<U> {
    var result = [];
    for (var i = 0; i < this.length; i++) {
        var item = this[i];
        var ci = cvt(item);
        result.push(ci);
    }
    return result;
};

Array.prototype.First = function <T>(predicate: (item: T) => boolean): T {
    for (var i = 0; i < this.length; ++i) {
        var item = this[i];
        if (predicate(item)) {
            return item;
        }
    }
    return null;
}

Array.prototype.FirstIndex = function <T>(predicate: (item: T) => boolean): number {
    for (var i = 0; i < this.length; ++i) {
        var item = this[i];
        if (predicate(item)) {
            return i;
        }
    }
    return -1;
}

Array.prototype.RemoveFirstFind = function <T>(predicate: (item: T) => boolean): boolean {
    for (var i = 0; i < this.length; ++i) {
        var item = this[i];
        if (predicate(item)) {
            this.splice(i, 1);
            this.IsDirty = true;
            return true;
        }
    }
    return false;
}

Array.prototype.RemoveByItem = function <T>(removeItem: T): boolean {
    for (var i = 0; i < this.length; ++i) {
        var item = this[i];
        if (item === removeItem) {
            this.splice(i, 1);
            this.IsDirty = true;
            return true;
        }
    }
    return false;
}
Array.prototype.RemoveByItemAndInsertEndItemHere = function <T>(removeItem: T): boolean {
    let len = this.length;
    let endindex = len - 1;
    for (var i = 0; i < len; ++i) {
        var item = this[i];
        if (item === removeItem) {
            if (i != endindex) {
                this[i] = this[endindex];
                this[endindex] = null;
            }
            this.splice(endindex, 1);
            this.IsDirty = true;
            return true;
        }
    }
    return false;
}


Array.prototype.RemoveByIndex = function <T>(index: number): boolean {
    if (index >= this.length)
        return false;
    else
        this.splice(index, 1);
    this.IsDirty = true;
    return true;

}
Array.prototype.ForEachFromEnd = function <T>(action: (item: T, index?: number) => boolean): void {
    if (!action) return;
    if (this.length == 0) return;
    let len = this.length - 1;
    for (var i = len; i >= 0; --i) {
        if (action(this[i], i) == true)
            break;
    }
}




Array.prototype.Clone = function <T>(): Array<T> {
    return [...this];
}
我发现只要我在外部引入该文件例如import '../Utils/Extensions/ArrayEx.ts'就会报错Uncaught TypeError: Cannot read properties of undefined (reading 'destroyed')，有大佬知道为什么吗