它在TypeScript 4.4.3 TS游乐场链接中为我工作。

  const stringToEnumValue = <T extends Record<string, string>, K extends keyof T>(
    enumObj: T,
    value: string,
  ): T[keyof T] | undefined =>
    enumObj[
      Object.keys(enumObj).filter(
        (k) => enumObj[k as K].toString() === value,
      )[0] as keyof typeof enumObj
    ];

  enum Color {
    Red = 'red',
    Green = 'green',
  }

  const result1 = stringToEnumValue(Color, 'yellow'); // undefined
  const result2 = stringToEnumValue(Color, 'green'); // Color.Green

  console.log(result1) // undefined = undefined
  console.log(result2) // Color.Green = "green"

我得到了它的工作使用以下代码。

var green= "Green";
var color : Color= <Color>Color[green];

在这个问题中有很多混合信息，所以让我们讨论TypeScript 2的整个实现。在Nick's Guide to Using Enums in Models with TypeScript中的x+。

本指南适用于:创建客户端代码的人，这些客户端代码从服务器获取一组已知字符串，这些字符串可以方便地在客户端建模为Enum。

定义枚举

让我们从枚举开始。它应该看起来像这样:

export enum IssueType {
  REPS = 'REPS',
  FETCH = 'FETCH',
  ACTION = 'ACTION',
  UNKNOWN = 'UNKNOWN',
}

这里需要注意两点:

我们显式地将这些声明为字符串支持的枚举情况，这允许我们用字符串来实例化它们，而不是其他一些不相关的数字。 我们添加了一个选项UNKNOWN，这个选项在我们的服务器模型上可能存在，也可能不存在。如果您愿意，可以将其处理为未定义，但我喜欢尽可能避免在类型上使用|未定义以简化处理。

使用UNKNOWN大小写的好处是，你可以在代码中非常明显地看到它，并为未知枚举大小写设置亮红色和闪烁的样式，这样你就知道你没有正确地处理某些事情。

解析枚举

您可以在另一个模型中使用这个枚举，或者单独使用这个枚举，但是您必须将字符串-y类型的枚举从JSON或XML (ha)解析为强类型的对应对象。当嵌入到另一个模型中时，这个解析器存在于类构造函数中。

parseIssueType(typeString: string): IssueType {
  const type = IssueType[typeString];
  if (type === undefined) {
    return IssueType.UNKNOWN;
  }

  return type;
}

如果枚举被正确地解析，它将以正确的类型结束。否则，它将是未定义的，您可以拦截它并返回UNKNOWN情况。如果您更喜欢使用undefined作为未知情况，则可以直接返回尝试的enum解析的任何结果。

从这里开始，只需要使用parse函数和使用新创建的强类型变量。

const strongIssueType: IssueType = parseIssueType('ACTION');
// IssueType.ACTION
const wrongIssueType: IssueType = parseIssueType('UNEXPECTED');
// IssueType.UNKNOWN

如果您正在使用名称空间来扩展枚举的功能，那么您还可以这样做

    enum Color {
        Red, Green
    }

    export namespace Color {
      export function getInstance(color: string) : Color {
        if(color == 'Red') {
          return Color.Red;
        } else if (color == 'Green') {
          return Color.Green;
        }
      }
    }

像这样使用它

  Color.getInstance('Red');

几乎所有答案都使用不安全的类型转换(as或is)。这一条没有:

enum Color {
    Red = "red",
    Green = "green"
}

const colorsMap = new Map<string,Color>(Object.values(Color).map((v) => [v,v]))

function parseColor(volumeData: string): Color | undefined {
    return colorsMap.get(volumeData)
}

const color = parseColor("red")

以这种方式创建的枚举被编译成一个对象，该对象同时存储正向(名称->值)和反向(值->名称)映射。从这张chrome devtools截图中我们可以看到:

下面是一个关于对偶映射如何工作以及如何从一个映射转换到另一个映射的例子:

enum Color{
    Red, Green
}
// To Number
var greenNr: number = Color['Green'];
console.log(greenNr); // logs 1

// To String
var greenString: string = Color[Color['Green']];  // or Color[Color[1]
console.log(greenString); // logs Green

// In your example

// recieve as Color.green instead of the string green
var green: string = Color[Color.Green];  

// obtain the enum number value which corresponds to the Color.green property
var color: Color = (<any>Color)[green];  

console.log(color); // logs 1