Typescript 会丢弃未知[] 还是永远不会？

Question

我正在尝试创建 A 和 B 的元组，或者如果 A 未知[]（或者从不），则仅创建 B

type X<A, B> = A extends unknown[] ? [B] : [A, B];
type Y = X<unknown[], {}>; // should be [{}] but isn't

变化：

type X<A, B> = A extends never ? [B] : [A, B];
type Y = X<never, {}>; // should be [{}] but isn't

这仅有效：

type X<A, B> = A extends null ? [B] : [A, B];
type Y = X<null, {}>; // it is [{}]

Answer 1

看看unknown和never类型相对于其他类型的行为方式：

type ExtendsUnknown<X> = X extends unknown ? true : false;
type YesUnknown = ExtendsUnknown<number>; // true
type YesUnknown2 = ExtendsUnknown<object>; // true
type YesUnknown3 = ExtendsUnknown<[number]>; // true
type YesUnknown4 = ExtendsUnknown<unknown>; // true

type ExtendsNever<X> = X extends never ? true : false;
type NoNever = ExtendsNever<number>; // false
type NoNever2 = ExtendsNever<object>; // false
type NoNever3 = ExtendsNever<[number]>; // false
type OhMyGodNever = ExtendsNever<never>; // we get never och man!

像这样的类型any never unknown是不健全的类型。这意味着它们的行为方式与标准类型不同，它们的行为可能违反派生其他类型的逻辑。我的这个逻辑的意思是例如：

如果 A 扩展 B 扩展 C 意味着 A 扩展 C

如果 A 扩展 B 并且 B 扩展 A 则意味着 A 等于 B

上述规则仅保证声音类型

这就是为什么对于你的情况，你应该使用声音类型，我会建议这里undefined类型。

// undefined behaves correctly
type ExtendsUndefined<X> = X extends undefined ? true : false;
type NoUndefined = ExtendsUndefined<number>; // false
type NoUndefined2 = ExtendsUndefined<object>; // false
type NoUndefined3 = ExtendsUndefined<number>; // false
type YesUndefined4 = ExtendsUndefined<undefined>; // true - yep that works

type X<A, B> = A extends undefined ? [B] : [A, B];
type Y = X<undefined, {}>;