Question

我目前正在为我的应用程序构建一个TypeScript集合类，但很难找到一个解决方案来推断递归调用。

arrays.ts

export interface Arrayable<T> {
    toArray(): Array<T>;
}

export function isArrayable<T>(object: any): object is Arrayable<T> {
     return typeof object === "object" && 'toArray' in object;
}

collection.ts

import { Arrayable, isArrayable } from "./arrays";

export class Collection<T> implements Arrayable<T> {
    private elements: Array<T>;

    constructor(elements?: Array<T> | Arrayable<T>) {
        if (typeof elements === "undefined") return;

        this.elements = this.getElementsArray(elements);
    }

    chunk(size: number): Collection<Collection<T>> {
        let chunked = [];

        for (let i = 0, len = this.elements.length; i < len; i += size)
            chunked.push(new Collection(this.elements.slice(i, i + size)));

        return new Collection(chunked);
    }

    toArray(): any[] {
        return this.elements.map((value: T) => {
            if (isArrayable(value))
                return value.toArray();

            return value;
        });
    }

    private getElementsArray(elements: Array<T> | Arrayable<T>): Array<T> {
        if (Array.isArray(elements)) {
            return elements;
        } else if (isArrayable(elements)) {
            return elements.toArray();
        }
    }
}

app.ts

let col = new Collection([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    .chunk(3)
    .toArray();

这里col的值被输入为任何[]，这是我当前的解决方法。

有没有办法让这个推断数字[] []？我基本上想要按照要求递归地折叠集合。

如何推断递归TypeScript类型？

0 个答案: