0

Typescript 的条件: T extends U ? X : Y语法非常强大，但是我还没有找到一种方法来根据类的属性或函数本身的某些内容来指定返回的类型。例如，采取这个简单的类：

class X {
    members: number[] = [];
    returnRoman = false;

    first(): number|string {
        if (!this.returnRoman) {
            return members[0];
        } else {
            return numberToRomanNumeral(members[0]);
        }
    }
}

有没有办法将返回的类型缩小为简单的数字或字符串以进行类型检查？我遇到的特殊问题是我有这样的结构：

class Base {
    x: number = 0;
}

class Sub extends Base { 
    y: number = 0;
}

class FilterIterator {
    members: Base[] = [];
    filterClass: typeof Base = undefined;

    class first(): Base {
        for (const m of this.members) {
            if (this.filterClass !== undefined && !(m instanceof this.filterClass)) {
                continue;
            }
            return m;
        }
    }
}

const fi = FilterIterator();
fi.filterClass = Sub
fi.members = [new Sub(), new Sub()];

const s = fi.first();
if (s.y > 0) {
   console.log('s is moving up in the world!');
}

因为fi.first()输入为 return Base，所以该行if (s.y > 0)引发错误，因为yBase 上不存在。在这种情况下，它不会太难做到：

const s = fi.first() as Sub;

但如果我们有这样的东西：

class FilterIterator extends Base {
    ...
    filterClass = FilterIterator;  // I know, not possible simply, but there are ways...
}

然后你最终得到如下代码：

const fi = FilterIterator();
[ set up .members with nested FilterIterators ]
const firstOfFirstOfFirst = fi.first().first().first();

被改写为：

const firstOfFirstOfFirst = (((fi.first() as FilterIterator).first() 
    as FilterIterator).first() as FilterIterator);

如果我们实际上创建可以返回生成器等的生成器，情况会变得更糟，因为在for...of循环中声明类型是不可能的。它还将确定返回值应该是什么的逻辑转移到使用软件，FilterIterator 或 Base 本身应该知道可能返回哪些类。

欢迎任何解决方案或改进。

4

1 回答 1

1

您的简化示例更难正确键入，因为returnRoman它是一个实例变量，可以假定在同一实例中多次更改其值。您必须通过 setter 更新它并使用语法asserts this is this & SomeType。

您的实际用例可能会遇到在设置类型后需要转换类型的相同困难，但我们可以通过filterClass在构造函数中使用作为参数来规避这些问题。这也意味着filterClass始终可以正确推断实例的类型，因为从创建实例的那一刻起就知道它的类型。因此它成为泛型类的直接用例。

type Constructor<T> = new (...args: any[]) => T;

class FilterIterator<T> {
    members: (T | Base)[] = [];
    private filterClass: Constructor<T>;

    constructor( filterClass: Constructor<T> ) {
        this.filterClass = filterClass;
    }

    first(): T {
        for (const m of this.members) {
            if (m instanceof this.filterClass) {
                return m;
            }
        }
        // you need to either throw an error or expand your return type to include undefined
        throw new Error("no match found");
    }
}

instanceof是 typescript 中的一个自动类型保护，所以如果你用return mtypescript 打到那一行，就知道它m与T你的filterClass.

我认为您正在尝试做一些不同的事情，其中​​过滤器是某种自定义检查而不是类构造函数，但是我没有足够的信息来真正正确地键入它。您可以将过滤器定义为用户定义的类型保护。

type Filter<T> = (value: any) => value is T;

class CustomFilterIterator<T> {
    members: any[] = [];
    private filter: Filter<T>;

    constructor( filter: Filter<T> ) {
        this.filter = filter;
    }

    first(): T | undefined {
        for (const m of this.members) {
            if (this.filter(m)) {
                return m;
            }
        }
        return;
    }
}

const isNumber = (value: any): value is number => {
    return typeof value === "number"
}

const numberFilter = new CustomFilterIterator(isNumber);
numberFilter.members = [55, "55", "hello", 78.3];
numberFilter.first()?.toExponential();

打字稿游乐场链接

于 2021-02-13T05:48:46.900 回答