typescript - 将Typescript泛型中的类型限制为几种类型之一

Question

我试图将泛型的输入限制为几种类型之一。我发现最接近的表示法是使用联合类型。这是一个简单的例子:

interface IDict<TKey extends string | number, TVal> { 
    // Error! An index signature parameter type must be 
    // a 'string' or a 'number'
    [key: TKey]: TVal; 
}

declare const dictA: IDict<string, Foo>;
declare const dictB: IDict<number, Foo>;

在这个例子中，我正在寻找的是一种表示 TKey 应该是 string 或 number 的方法，但是不是他们的联合。

想法？

注意:这是一个更广泛问题的具体案例。例如，我有另一种情况，我有一个接受 text 的函数，它可以是 string 或 StructuredText (解析的 Markdown)，转换它，并准确返回相应的类型(不是子类型)。

function formatText<T extends string | StructuredText>(text: T): T {/*...*/}

从技术上讲，我可以将其写成重载，但这似乎不是正确的方法。

function formatText(text: string): string;
function formatText(text: StructuredText): StructuredText;
function formatText(text) {/*...*/}

重载也被证明是有问题的，因为它不接受联合类型:

interface StructuredText { tokens: string[] }

function formatText(txt: string): string;
function formatText(txt: StructuredText): StructuredText;
function formatText(text){return text;}

let s: string | StructuredText;
let x = formatText(s); // error

Answer 1

已于 2019-06-20 更新为 TS3.5+

问题 #1:K extends string | number对于索引签名参数:

是的，这不能以非常令人满意的方式完成。有几个问题。首先是 TypeScript 只识别两种直接索引签名类型:[k: string] , 和 [k: number] .就是这样。你不能做(编辑以下是 no longer true 自 TS4.4) strike> 或者甚至是那些的别名:(没有 [k: string | number] where [k: 'a'|'b'] )。

第二个问题是 [k: s]作为索引类型是一种奇怪的特殊情况，不能很好地泛化到 TypeScript 的其余部分。在 JavaScript 中，所有对象索引在使用之前都被转换为它们的字符串值。这意味着 type s = string和 number是同一个元素。所以，在某种意义上，a['1']作为索引的类型更像是 a[1] 的子类型.如果你愿意放弃number文字并将它们转换为 string相反，你有一个更容易的时间。

如果是这样，您可以使用 mapped types得到你想要的行为。事实上，有一个类型叫做number。那是 included in the standard library这正是我建议使用的:

type Record<K extends string, T> = {
    [P in K]: T;
};

type IDict<TKey extends string, TVal> = Record<TKey, TVal>
declare const dictString: IDict<string, Foo>; // works
declare const dictFooBar: IDict<'foo' | 'bar', Foo>; // works
declare const dict012: IDict<'0' | '1' | '2', Foo>; // works
dict012[0]; // okay, number literals work
dict012[3]; // error
declare const dict0Foo: IDict<'0' | 'foo',Foo>; // works

离工作很近了。但是:

declare const dictNumber: IDict<number, Foo>; // nope, sorry

缺失的部分得到string to work 应该是 Record<> 这样的类型定义为

type numericString = '0'|'1'|'2'|'3'|'4'|'5'|'6'|'7' // ... etc etc

然后你可以使用 number这会像你想要的那样numericString到。如果没有这样的类型，试图强制 TypeScript 这样做就没有多大意义。我建议放弃，除非您有非常引人注目的用例。

问题 #2:可以扩展为列表类型的泛型:

我想我明白你在这里想要什么。这个想法是你想要一个函数，它接受一个扩展联合的类型的参数，比如 IDict<numericString, Foo> ，但它应该返回一个类型，该类型被扩展为该联合的一个或多个元素。您正在尝试避免子类型出现问题。所以，如果参数是 IDict<number, Foo> ，您不想 promise 输出 string | number , 只是一个 1 .

在此之前，我会说只使用重载:

function zop(t: string): string; // string case
function zop(t: number): number; // number case
function zop(t: string | number): string | number; // union case
function zop(t: string | number): string | number { // impl
   return (typeof t === 'string') ? (t + "!") : (t - 2);
}

这会如您所愿:

const zopNumber = zop(1); // return type is number
const zopString = zop('a'); // return type is string 
const zopNumberOrString = zop(
  Math.random()<0.5 ? 1 : 'a'); // return type is string | number

如果您的工会中只有两种类型，这就是我的建议。但对于较大的联合(例如 1 )，这可能会变得笨拙，因为您需要为联合中的每个非空元素子集包含一个重载签名。

我们可以使用 conditional types 而不是重载:

// OneOf<T, V> is the main event:
// take a type T and a tuple type V, and return the type of
// T widened to relevant element(s) of V:
type OneOf<
  T,
  V extends any[],
  NK extends keyof V = Exclude<keyof V, keyof any[]>
> = { [K in NK]: T extends V[K] ? V[K] : never }[NK];

这是它的工作原理:

declare const str: OneOf<"hey", [string, number, boolean]>; // string
declare const boo: OneOf<false, [string, number, boolean]>; // boolean
declare const two: OneOf<1 | true, [string, number, boolean]>; // number | boolean

下面是声明函数的方法:

function zop<T extends string | number>(t: T): OneOf<T, [string, number]>;
function zop(t: string | number): string | number { // impl
   return (typeof t === 'string') ? (t + "!") : (t - 2);
}

它的行为和以前一样:

const zopNumber = zop(1); // 1 -> number
const zopString = zop('a'); // 'a' -> string
const zopNumberOrString = zop(
  Math.random()<0.5 ? 1 : 'a'); // 1 | 'a' -> string | number

哇哦。希望有所帮助；祝你好运!

Link to code