Typescript 泛型类型，引用其具有不同类型的属性之一

所以你有一个像type SubgridColumn<T, N> = ⋯这样的类型，你想写下

type ColumnDefinition<T> = SomeSubgridColumn<T> | Column<T>;

其中，SomeSubgridColumn<T>是你不知道或不关心的some类型N的SubgridColumn<T, N>.

当你发现自己需要一个像F<N>这样的类型来代替你不知道的some类型N，那么你就可以 Select 所谓的existentially quantified generics(也称为existential types).您想要说"有exists个类型N，因此结果类型是F<N>".但是，像大多数有generics的语言一样，TypeScrip只有universally-quantified generics个字符，这意味着F<N>必须使用for all个字符N.在microsoft/TypeScript#14466有一个长期开放的针对存在词类型的功能请求，但目前还不直接支持它们.

因此，如果你想要一个存在主义类型，你需要想办法绕过它.

最简单的方法是只使用the any type作为类型参数来替换存在泛型:

type SomeSubgridColumn<T> = SubgridColumn<T, any>

这与您最初的SubgridColumn版本相同.正如我所说，这是非常容易的.但它不能准确地表示存在类型，而且它也不是类型安全的.

在另一端，你可以使用通用泛型类型，通过一个类似Promise的 struct ，encode个存在泛型类型. 这个 idea 是，你得到的不是F<N>，而是一个接受F<N>回调的函数.你不能直接访问F<N>值，只有一个包含它的黑盒子.因为你不知道N是什么，所以你必须确保你的回调对all N有效. 当你改变数据流的方向时，共通性和共通性是彼此的，就像unions和intersections是彼此的共通性一样. (事实上，你可以把存在看作是一个"无限的联合"，而普遍是一个"无限的交叉".

下面是它看起来的样子:

type SomeSubgridColumn<T> =
    <R>(cb: <N>(sc: SubgridColumn<T, N>) => R) => R;

所以如果我给你一个SomeSubgridColumn<T>，你可以给它一个回调，对于所有可能的N，它必须接受SubgridColumn<T, N>，它返回任何你想要的类型.当你这样做的时候，你会得到一个R类型的值.因此，您将回调放入黑框中，对隐藏的值运行回调，然后将结果传递给您.

把SubgridColumn<T, N>放进SomeSubgridColumn<T>的盒子里很容易:

const someSubgridColumn = <T, N>(
    sc: SubgridColumn<T, N>
): SomeSubgridColumn<T> => cb => cb(sc);

并且您需要相应地包装您的数据:

const columns: Columns<Cargo> = [
    { render: cargo => cargo.locationFrom },
    someSubgridColumn({
        subgridItems: cargo => cargo.models,
        subgridColumns: [
            { render: model => model.modelName },
            someSubgridColumn({
                subgridItems: model => model.parts,
                subgridColumns: [
                    { render: part => part.partName },
                    { render: part => part.partPrice }],
            }),
            someSubgridColumn({
                subgridItems: model => (
                    model.modelName === 'Subaru' ? countries : []
                ),
                subgridColumns: [
                    {
                        render: country => country.countryName,
                    },
                ],
            }),
        ],
    }),
];

另一方面，消费SomeSubgridColumn<T>有点复杂，就像消费Promise一样.它在一个盒子里，你必须给它一个回调.例如:假设您想要取一个Columns<Cargo>，并将每个元素映射到它所具有的数字subgridColumns.用你原来的 struct ，你可能会写下

columns.map(cd => "render" in cd ? 0 : cd.subgridColumns.length);

但你不能这样做，因为cd不能直接得到subgridColumns.它在盒子里.所以你必须写下:

columns.map(cd => "render" in cd ? 0 : cd(sc => sc.subgridColumns.length));

这很管用.

这种方法比any的版本更复杂，但它的优点是实际上是类型安全的.

最后，重要的是要注意，如果事实证明你不关心的N只可能是一个相当小的有限类型集合中的一个，那么你可以省go 存在式而使用联合. 如果N只能是A或B或C，那么你通常可以只写A | B | C. 在您的用例中，您提到了N可能只是T的属性类型，它们是array. 你可以计算这些:

type ArrayElements<T> = {
    [K in keyof T]: T[K] extends readonly (infer U)[] ? U : never
}[keyof T];

type AEC = ArrayElements<Cargo>;
// type AEC = Model

N可以用这个来代替:

type SomeSubgridColumn<T> = SubgridColumn<T, ArrayElements<T>>

虽然你可能希望它是ArrayElements<T>:distributed over unions:

type SomeSubgridColumn<T> = 
  ArrayElements<T> extends infer N ? N extends any ?
    SubgridColumn<T, N> : never : never;

我不会离题进一步解释那么多，但假设如果N对于给定的T可以是A | B | C，你希望SomeSubgridColumn<T>是SubgridColumn<T, A> | SubgridColumn<T, B> | SubgridColumn<T, C>而不是SubgridColumn<T, A | B | C>. 对于给定的用例，这可能足够，也可能不足够.它比any更复杂，但没有编码存在句那么奇怪的反转.

Playground link to code个