如何在Typescript枚举中查找具有值的键？

我想搜索一个有值的枚举，并获取它的键。这就是我现在拥有的：

  private find(value: MyEnum): string {
    for (const key in MyEnum) {
      if (value === MyEnum[key]) {
        return key;
      }
    }
    return null;
  }

我们能不能简化一下？这似乎是一种过度的工程设计

实际上，我想要的是Java中的value.name（）

编辑：MyEnum是这样的：

export enum MyEnum {
  YES = 'x',
  NO = 'y'
}

{ YES: 'x', NO: 'y' }

type ReverseMapping<T extends Record<keyof T, keyof any>> = {
    [K in T[keyof T]]: { [P in keyof T]: K extends T[P] ? P : never }[keyof T]
}

function reverseMapping<T extends Record<keyof T, keyof any>>(t: T): ReverseMapping<T> {
    const ret = {} as ReverseMapping<T>;
    (Object.keys(t) as Array<keyof T>).forEach(k => ret[t[k]] = k as any);
    return ret;
}

// do this once
const reverseMyEnum = reverseMapping(MyEnum); // reverseMyEnum: { x: "YES", y: "NO" }

// reuse reverseMyEnum for reverse lookups:
const xKey = reverseMyEnum.x; // xKey: "YES"
const yKey = reverseMyEnum.y; // yKey: "NO"
const randKey = reverseMyEnum[Math.random() < 0.5 ? "x" : "y"]; // randKey: "YES" | "NO"

---

如果在运行时查看

MyEnum

，它本质上是一个如下所示的对象：

export enum MyEnum {
  YES = 'x',
  NO = 'y'
}

{ YES: 'x', NO: 'y' }

type ReverseMapping<T extends Record<keyof T, keyof any>> = {
    [K in T[keyof T]]: { [P in keyof T]: K extends T[P] ? P : never }[keyof T]
}

function reverseMapping<T extends Record<keyof T, keyof any>>(t: T): ReverseMapping<T> {
    const ret = {} as ReverseMapping<T>;
    (Object.keys(t) as Array<keyof T>).forEach(k => ret[t[k]] = k as any);
    return ret;
}

// do this once
const reverseMyEnum = reverseMapping(MyEnum); // reverseMyEnum: { x: "YES", y: "NO" }

// reuse reverseMyEnum for reverse lookups:
const xKey = reverseMyEnum.x; // xKey: "YES"
const yKey = reverseMyEnum.y; // yKey: "NO"
const randKey = reverseMyEnum[Math.random() < 0.5 ? "x" : "y"]; // randKey: "YES" | "NO"

JavaScript中没有自动反向查找对象的功能，因此需要编写类似于

find（）

函数的东西来执行此操作。所以我认为没有比这更简单的了，没有

如果您的枚举是，TypeScript将为您提供：

但遗憾的是，您使用的是字符串枚举，因此这里没有神奇的答案

---

如果您经常需要执行反向查找，并且不想继续迭代数组来执行此操作，则可以使用以下帮助函数提前构建反向映射对象：

export enum MyEnum {
  YES = 'x',
  NO = 'y'
}

{ YES: 'x', NO: 'y' }

type ReverseMapping<T extends Record<keyof T, keyof any>> = {
    [K in T[keyof T]]: { [P in keyof T]: K extends T[P] ? P : never }[keyof T]
}

function reverseMapping<T extends Record<keyof T, keyof any>>(t: T): ReverseMapping<T> {
    const ret = {} as ReverseMapping<T>;
    (Object.keys(t) as Array<keyof T>).forEach(k => ret[t[k]] = k as any);
    return ret;
}

// do this once
const reverseMyEnum = reverseMapping(MyEnum); // reverseMyEnum: { x: "YES", y: "NO" }

// reuse reverseMyEnum for reverse lookups:
const xKey = reverseMyEnum.x; // xKey: "YES"
const yKey = reverseMyEnum.y; // yKey: "NO"
const randKey = reverseMyEnum[Math.random() < 0.5 ? "x" : "y"]; // randKey: "YES" | "NO"

类型反向映射={
[K in T[keyof T]]：{[P in keyof T]：K扩展T[P]？P:never}[keyof T]
}
函数反向映射（t:t）：反向映射{
const ret={}作为反向映射；
（Object.keys（t）作为数组）.forEach（k=>ret[t[k]]=k作为任意数组）；
返回ret；
}

然后像这样使用它：

export enum MyEnum {
  YES = 'x',
  NO = 'y'
}

{ YES: 'x', NO: 'y' }

type ReverseMapping<T extends Record<keyof T, keyof any>> = {
    [K in T[keyof T]]: { [P in keyof T]: K extends T[P] ? P : never }[keyof T]
}

function reverseMapping<T extends Record<keyof T, keyof any>>(t: T): ReverseMapping<T> {
    const ret = {} as ReverseMapping<T>;
    (Object.keys(t) as Array<keyof T>).forEach(k => ret[t[k]] = k as any);
    return ret;
}

// do this once
const reverseMyEnum = reverseMapping(MyEnum); // reverseMyEnum: { x: "YES", y: "NO" }

// reuse reverseMyEnum for reverse lookups:
const xKey = reverseMyEnum.x; // xKey: "YES"
const yKey = reverseMyEnum.y; // yKey: "NO"
const randKey = reverseMyEnum[Math.random() < 0.5 ? "x" : "y"]; // randKey: "YES" | "NO"

//只做一次
const reverseMyEnum=反向映射（MyEnum）；//reverseMyEnum:{x:“是”，y:“否”}
//重新使用reverseMyEnum进行反向查找：
const xKey=reverseMyEnum.x；//xKey：“是的”
常数yKey=reverseMyEnum.y；//yKey：“不”
const randKey=reverseMyEnum[Math.random（）<0.5？“x”：“y”]；//randKey：“是”|“否”

当然，

reverseMapping（）

函数可能比

find（）

更“过度设计”，因此它是否值得您使用取决于您自己。我倾向于继续使用

find（）

（虽然类型更强，但不是您要求的），除非我遇到了某种问题（例如，不断迭代一个真正庞大的枚举的性能…不太可能）

无论如何，我希望这能有所帮助。祝你好运