泛型类型获取枚举键作为联合字符串在类型脚本？

let maybeString: string | null = null;

null的第一个实例是一个类型，第二个实例是一个值。它也没有问题

let Foo = {a: 0};
type Foo = {b: string};

其中第一个 Foo是命名值，第二个 Foo是命名类型。请注意，值 Foo的类型是 {a: number}，而 Foo的类型是 {b: string}。他们不一样。

甚至 typeof操作员也过着双重生活。但 typeof x本身可以是值或类型，这取决于上下文:

let bar = {a: 0};
let TypeofBar = typeof bar; // the value "object"
type TypeofBar = typeof bar; // the type {a: number}

let TypeofBar = typeof bar;行将通过 JavaScript，它将在运行时使用 JavaScript 类型的运算符并生成一个字符串。但是 type TypeofBar = typeof bar; 被擦除，并且它正在使用 类型查询运算符检查 TypeScript 分配给名为 bar的值的静态类型。

现在，TypeScript 中引入名称的大多数语言构造都会创建命名值或命名类型。下面是一些命名值的介绍:

const value1 = 1;
let value2 = 2;
var value3 = 3;
function value4() {}

下面是一些命名类型的介绍:

interface Type1 {}
type Type2 = string;

但是有一些声明创建 都有一个命名值 还有一个命名类型，和上面的 Foo一样，命名值的类型不是命名类型。最大的是 class和 enum:

class Class { public prop = 0; }
enum Enum { A, B }

在这里，类型 Class是 Class的 例子的类型，而 价值 Class是 构造函数对象。而且 typeof Class不是 Class:

const instance = new Class();  // value instance has type (Class)
// type (Class) is essentially the same as {prop: number};


const ctor = Class; // value ctor has type (typeof Class)
// type (typeof Class) is essentially the same as new() => Class;

而且，类型Enum是枚举的 元素的类型; 是每个元素类型的并集。而 价值Enum是 对象，其键是 A和 B，其属性是枚举的元素。而 typeof Enum不是 Enum:

const element = Math.random() < 0.5 ? Enum.A : Enum.B;
// value element has type (Enum)
// type (Enum) is essentially the same as Enum.A | Enum.B
//  which is a subtype of (0 | 1)


const enumObject = Enum;
// value enumObject has type (typeof Enum)
// type (typeof Enum) is essentially the same as {A: Enum.A; B: Enum.B}
//  which is a subtype of {A:0, B:1}

现在回到你的问题。你想发明一种类型运算符，它的工作原理是这样的:

type KeysOfEnum = EnumKeysAsStrings<Enum>;  // "A" | "B"

你把 类型Enum放进去，然后把 对象Enum的钥匙拿出来。但如上所示，类型 Enum与对象 Enum不同。不幸的是，该类型对值一无所知。这有点像在说:

type KeysOfEnum = EnumKeysAsString<0 | 1>; // "A" | "B"

很明显，如果你这样写，你就会发现对于产生 "A" | "B"类型的 0 | 1类型你什么也做不了。为了使其正常工作，您需要向它传递一个知道映射的类型。这种类型是 typeof Enum..。

type KeysOfEnum = EnumKeysAsStrings<typeof Enum>;

就像

type KeysOfEnum = EnumKeysAsString<{A:0, B:1}>; // "A" | "B"

如果 type EnumKeysAsString<T> = keyof T。

因此，您必须让消费者指定 typeof Enum。有解决办法吗？也许你可以用一个函数来表示这个值？

 function enumKeysAsString<TEnum>(theEnum: TEnum): keyof TEnum {
// eliminate numeric keys
const keys = Object.keys(theEnum).filter(x =>
(+x)+"" !== x) as (keyof TEnum)[];
// return some random key
return keys[Math.floor(Math.random()*keys.length)];
}

然后你可以打电话

 const someKey = enumKeysAsString(Enum);

someKey的类型为 "A" | "B"。是的，但是如果要把它用作 类型，你必须查询它:

 type KeysOfEnum = typeof someKey;

这会迫使您再次使用 typeof，而且比您的解决方案更加冗长，特别是因为您不能这样做:

 type KeysOfEnum = typeof enumKeysAsString(Enum); // error

对不起。

回顾:

• 这是不可能的;
• 类型和价值观之类的;
• 仍然不可能;
• 抱歉。

希望你能理解，祝你好运。