如何获取枚举条目的名称？答案

【问题标题】：How to get names of enum entries?如何获取枚举条目的名称？
【发布时间】：2013-08-09 07:37:39
【问题描述】：

我想迭代一个 TypeScript 枚举对象并获取每个枚举的符号名称，例如：枚举 myEnum { entry1, entry2 }

for (var entry in myEnum) { 
    // use entry's name here, e.g., "entry1"
}

【问题讨论】：

这个小enum-for 包有getAllEnumValues 和getAllEnumKeys 供您使用
我创建了 a PR (issue) 来为 Typescript 添加对 for (const [name, value] of MyEnum) { 的原生支持。希望有一天这会更容易！
一定很难提供EnumType.name() 方法。

标签： enums typescript

【解决方案1】：

虽然已经给出了答案，但几乎没有人指向docs

这是一个sn-p

enum Enum {
    A
}
let nameOfA = Enum[Enum.A]; // "A"

请记住，字符串枚举成员根本不会生成反向映射。

【讨论】：

从这个枚举中显示0 或1 怎么样？ export enum Octave { ZERO = 0, ONE = 1 }
@jbojcic 是关于情况吗：enum Enum {"A"}; let nameOfA = Enum[Enum.A];？从 typescript@2.9.2 开始，它对我来说很好......
循环遍历值怎么样？
在 JS 中枚举是 [value]: name 的一个对象，因此您可以获得所有类似 Object.keys(enum) 的值，所有名称 Object.values(enum) 并使用 for(const [value, name] of Object.entries(enum)) { ... } 一次性迭代。请注意，当您获取值时，它们将是字符串，而不是您期望的数字（因为在 JS 中对象的键是字符串）。
我不明白这如何回答所提出的问题。是的，这里陈述的事实是正确的，可以从中推断出答案，但没有直接的答案。

【解决方案2】：

您发布的代码将起作用；它将打印出枚举的所有成员，包括枚举成员的值。例如以下代码：

enum myEnum { bar, foo }

for (var enumMember in myEnum) {
   console.log("enum member: ", enumMember);
}

将打印以下内容：

Enum member: 0
Enum member: 1
Enum member: bar
Enum member: foo

如果您只需要成员名称而不是值，则可以执行以下操作：

for (var enumMember in myEnum) {
   var isValueProperty = parseInt(enumMember, 10) >= 0
   if (isValueProperty) {
      console.log("enum member: ", myEnum[enumMember]);
   }
}

这将只打印出名称：

Enum member: bar  
Enum member: foo

警告：这稍微依赖于实现细节：TypeScript 将枚举编译为 JS 对象，其中枚举值是对象的成员。如果 TS 决定在未来以不同的方式实现它们，上述技术可能会失效。

【讨论】：

需要明确的是，上述答案在 TS 2.3 中仍然有效。但是，如果你使用“const enum”，而不仅仅是“enum”，那么它就不会起作用。使用 const enum 基本上是告诉 TS 进行搜索和替换；你使用 MyEnum.Foo 的每一个地方，都会被替换成一个对应的数值。
我认为+enumMember >= 0 应该是isFinite(+enumMember)，因为负值或浮点值也会被反向映射。 (Playground)
枚举条目可以是带有leading zeros的字符串，比如00111，你也需要排除这些
从 TS 4 开始，不适用于数字和异构枚举。

【解决方案3】：

对我来说，了解正在发生的事情的一种更简单、实用且直接的方法是以下枚举：

enum colors { red, green, blue };

基本上会转换成这个：

var colors = { red: 0, green: 1, blue: 2,
               [0]: "red", [1]: "green", [2]: "blue" }

正因为如此，以下将是正确的：

colors.red === 0
colors[colors.red] === "red"
colors["red"] === 0

这创建了一种获取枚举名称的简单方法，如下所示：

var color: colors = colors.red;
console.log("The color selected is " + colors[color]);

它还创建了一种将字符串转换为枚举值的好方法。

var colorName: string = "green";
var color: colors = colors.red;
if (colorName in colors) color = colors[colorName];

上述两种情况更为常见，因为通常您对特定值的名称和以通用方式序列化值更感兴趣。

【讨论】：

【解决方案4】：

如果您只搜索名称并在以后迭代使用：

Object.keys(myEnum).map(key => myEnum[key]).filter(value => typeof value === 'string') as string[];

【讨论】：

或使用 ES2017 库：Object.values(myEnum).filter(value => typeof value === 'string') as string[];
我需要创建一个字典，并以您的回答为起点。如果其他人需要它，Object.values(myEnum).filter(value => typeof value === 'string').map(key => { return {id: myEnum[key], type: key }; });
或者只是 Object.values(myEnum).filter(isNaN) as string[];
Object.keys(myEnum) 不足以在枚举对象中获取包含键名的数组吗？

【解决方案5】：

假设您遵守规则并且只生成带有数值的枚举，您可以使用此代码。这可以正确处理您的名字恰好是有效数字的情况

enum Color {
    Red,
    Green,
    Blue,
    "10" // wat
}

var names: string[] = [];
for(var n in Color) {
    if(typeof Color[n] === 'number') names.push(n);
}
console.log(names); // ['Red', 'Green', 'Blue', '10']

【讨论】：

警告在现代打字稿（tsc 2.5.2 atm）中，您甚至不允许将数字字符串作为开头的键。因此，Himango 的答案更好，因为它涵盖了所有情况并且没有缺点。

【解决方案6】：

对于当前的 TypeScript 版本 1.8.9，我使用类型化枚举：

export enum Option {
    OPTION1 = <any>'this is option 1',
    OPTION2 = <any>'this is option 2'
}

在这个 Javascript 对象中产生结果：

Option = {
    "OPTION1": "this is option 1",
    "OPTION2": "this is option 2",
    "this is option 1": "OPTION1",
    "this is option 2": "OPTION2"
}

所以我必须通过键和值查询并且只返回值：

let optionNames: Array<any> = [];    
for (let enumValue in Option) {
    let optionNameLength = optionNames.length;

    if (optionNameLength === 0) {
        this.optionNames.push([enumValue, Option[enumValue]]);
    } else {
        if (this.optionNames[optionNameLength - 1][1] !== enumValue) {
            this.optionNames.push([enumValue, Option[enumValue]]);
        }
    }
}

我收到一个数组中的选项键：

optionNames = [ "OPTION1", "OPTION2" ];

【讨论】：

好吧，代码有不同的含义，你会得到：optionNames = [["OPTION1", "this is option 1"], ["OPTION2", "this is option 2"]]，但总的来说，我很欣赏你删除双反转条目的想法，这里的其他人都认为值始终是一个数字

【解决方案7】：

从 TypeScript 2.4 开始，枚举可以包含字符串初始化器 https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-4.html

这允许你写：

 enum Order {
      ONE = "First",
      TWO = "Second"
 }

console.log(`One is ${Order.ONE.toString()}`);

并得到这个输出：

一个是第一

【讨论】：

【解决方案8】：

这里的答案似乎都不适用于strict-mode 中的字符串枚举。

将枚举视为：

enum AnimalEnum {
  dog = "dog", cat = "cat", mouse = "mouse"
}

使用AnimalEnum["dog"] 访问它可能会导致如下错误：

Element implicitly has an 'any' type because expression of type 'any' can't be used to index type 'typeof AnimalEnum'.ts(7053).

针对这种情况的正确解决方案，写成：

AnimalEnum["dog" as keyof typeof AnimalEnum]

【讨论】：

将keyof 与typeof 结合使用的绝妙解决方案！其他解决方案似乎很不透明，但毕竟我认为 Typescript 需要不断改进 DX - Enum 的开发人员体验
值和key不一样的时候就没那么精彩了
当你想在传递一个键时映射枚举值时，这个解决方案很好，

【解决方案9】：

这个解决方案也可以。

enum ScreenType {
    Edit = 1,
    New = 2,
    View = 4
}

var type: ScreenType = ScreenType.Edit;

console.log(ScreenType[type]); //Edit

【讨论】：

为什么它为我打印“未定义”？有什么想法吗？

【解决方案10】：

简而言之

如果您的enums 如下：

export enum Colors1 {
  Red = 1,
  Green = 2,
  Blue = 3
}

获取特定的文本和值：

console.log(Colors1.Red); // 1 
console.log(Colors1[Colors1.Red]); // Red

获取值和文本列表：

public getTextAndValues(e: { [s: number]: string }) {
  for (const enumMember in e) {
    if (parseInt(enumMember, 10) >= 0) {
      console.log(e[enumMember]) // Value, such as 1,2,3
      console.log(parseInt(enumMember, 10)) // Text, such as Red,Green,Blue
    }
  }
}
this.getTextAndValues(Colors1)

如果您的enums 如下：

export enum Colors2 {
  Red = "Red",
  Green = "Green",
  Blue = "Blue"
}

获取特定的文本和值：

console.log(Colors2.Red); // Red
console.log(Colors2["Red"]); // Red

获取值和文本列表：

public getTextAndValues(e: { [s: string]: string }) {
  for (const enumMember in e) {
    console.log(e[enumMember]);// Value, such as Red,Green,Blue
    console.log(enumMember); //  Text, such as Red,Green,Blue
  }
}
this.getTextAndValues(Colors2)

【讨论】：

不适用于字符串和异构枚举。从thsi 看来，很容易暗示代码从未编译过。
@polkovnikov.ph- 我更新了我的答案，在我看来，你不应该因为写作错误而对问题投反对票
我投了反对票，因为它是错误的。数字枚举不是唯一的枚举类型。我也不明白为什么数字必须是非负数。 enum A { B = -1 } 完全有效。

【解决方案11】：

让ts-enum-util (github, npm) 为您完成这项工作，并提供许多额外的类型安全实用程序。适用于字符串和数字枚举，正确忽略数字枚举的数字索引反向查找条目：

字符串枚举：

import {$enum} from "ts-enum-util";

enum Option {
    OPTION1 = 'this is option 1',
    OPTION2 = 'this is option 2'
}

// type: ("OPTION1" | "OPTION2")[]
// value: ["OPTION1", "OPTION2"]
const keys= $enum(Option).getKeys();

// type: Option[]
// value: ["this is option 1", "this is option 2"]
const values = $enum(Option).getValues();

数字枚举：

enum Option {
    OPTION1,
    OPTION2
}

// type: ("OPTION1" | "OPTION2")[]
// value: ["OPTION1", "OPTION2"]
const keys= $enum(Option).getKeys();

// type: Option[]
// value: [0, 1]
const values = $enum(Option).getValues();

【讨论】：

【解决方案12】：

另一个有趣的解决方案found here 是使用 ES6 Map：

export enum Type {
  low,
  mid,
  high
}

export const TypeLabel = new Map<number, string>([
  [Type.low, 'Low Season'],
  [Type.mid, 'Mid Season'],
  [Type.high, 'High Season']
]);

使用

console.log(TypeLabel.get(Type.low)); // Low Season

【讨论】：

【解决方案13】：

从 TypeScript 2.4 开始，枚举不再包含作为成员的键。 source from TypeScript readme

需要注意的是，字符串初始化的枚举不能反向映射以获取原始枚举成员名称。换句话说，你不能写 Colors["RED"] 来获取字符串 "Red"。

我的解决方案：

export const getColourKey = (value: string ) => {
    let colourKey = '';
    for (const key in ColourEnum) {
        if (value === ColourEnum[key]) {
            colourKey = key;
            break;
        }
    }
    return colourKey;
};

【讨论】：

【解决方案14】：

我厌倦了看错误的答案，我自己做了。

这个有测试。
适用于所有类型的枚举。
输入正确。

type EnumKeys<Enum> = Exclude<keyof Enum, number>

const enumObject = <Enum extends Record<string, number | string>>(e: Enum) => {
    const copy = {...e} as { [K in EnumKeys<Enum>]: Enum[K] };
    Object.values(e).forEach(value => typeof value === 'number' && delete copy[value]);
    return copy;
};

const enumKeys = <Enum extends Record<string, number | string>>(e: Enum) => {
    return Object.keys(enumObject(e)) as EnumKeys<Enum>[];
};

const enumValues = <Enum extends Record<string, number | string>>(e: Enum) => {
    return [...new Set(Object.values(enumObject(e)))] as Enum[EnumKeys<Enum>][];
};

enum Test1 { A = "C", B = "D"}
enum Test2 { A, B }
enum Test3 { A = 0, B = "C" }
enum Test4 { A = "0", B = "C" }
enum Test5 { undefined = "A" }
enum Test6 { A = "undefined" }
enum Test7 { A, B = "A" }
enum Test8 { A = "A", B = "A" }
enum Test9 { A = "B", B = "A" }

console.log(enumObject(Test1)); // {A: "C", B: "D"}
console.log(enumObject(Test2)); // {A: 0, B: 1}
console.log(enumObject(Test3)); // {A: 0, B: "C"}
console.log(enumObject(Test4)); // {A: "0", B: "C"}
console.log(enumObject(Test5)); // {undefined: "A"}
console.log(enumObject(Test6)); // {A: "undefined"}
console.log(enumObject(Test7)); // {A: 0,B: "A"}
console.log(enumObject(Test8)); // {A: "A", B: "A"}
console.log(enumObject(Test9)); // {A: "B", B: "A"}

console.log(enumKeys(Test1)); // ["A", "B"]
console.log(enumKeys(Test2)); // ["A", "B"]
console.log(enumKeys(Test3)); // ["A", "B"]
console.log(enumKeys(Test4)); // ["A", "B"]
console.log(enumKeys(Test5)); // ["undefined"]
console.log(enumKeys(Test6)); // ["A"]
console.log(enumKeys(Test7)); // ["A", "B"]
console.log(enumKeys(Test8)); // ["A", "B"]
console.log(enumKeys(Test9)); // ["A", "B"]

console.log(enumValues(Test1)); // ["C", "D"]
console.log(enumValues(Test2)); // [0, 1]
console.log(enumValues(Test3)); // [0, "C"]
console.log(enumValues(Test4)); // ["0", "C"]
console.log(enumValues(Test5)); // ["A"] 
console.log(enumValues(Test6)); // ["undefined"] 
console.log(enumValues(Test7)); // [0, "A"]
console.log(enumValues(Test8)); // ["A"]
console.log(enumValues(Test9)); // ["B", "A"]

Online version.

【讨论】：

【解决方案15】：

你可以使用我遇到同样问题时写的enum-values包：

Git: enum-values

var names = EnumValues.getNames(myEnum);

【讨论】：

你并没有真正回答这个问题，最好用代码/等记录你的答案，但我确实发现这个包很有用。
看起来魔法线是Object.keys(e).filter(key => isNaN(+key))，它不适用于字符串枚举等，对吧？
@jchook 它会起作用的。你可以看看这个test

【解决方案16】：

假设你有一个enum

export enum SCROLL_LABEL_OFFSET {
  SMALL = 48,
  REGULAR = 60,
  LARGE = 112
}

并且您想创建一个基于枚举的类型，而不仅仅是复制和粘贴。您可以使用enum 来创建您的type，如下所示：

export type ScrollLabelOffset = keyof typeof SCROLL_LABEL_OFFSET;

结果您将收到一个type，其可能值为'SMALL' | 'REGULAR' | 'LARGE'

【讨论】：

【解决方案17】：

根据上面的一些答案，我想出了这个类型安全的函数签名：

export function getStringValuesFromEnum<T>(myEnum: T): (keyof T)[] {
  return Object.keys(myEnum).filter(k => typeof (myEnum as any)[k] === 'number') as any;
}

用法：

enum myEnum { entry1, entry2 };
const stringVals = getStringValuesFromEnum(myEnum);

stringVals 的类型是'entry1' | 'entry2'

See it in action

【讨论】：

函数应该返回(keyof T)[]而不是keyof T。此外，export 会阻止您的游乐场工作。

【解决方案18】：

根据 TypeScript 文档，我们可以通过 Enum 使用静态函数来做到这一点。

使用静态函数获取枚举名称

enum myEnum { 
    entry1, 
    entry2 
}

namespace myEnum {
    export function GetmyEnumName(m: myEnum) {
      return myEnum[m];
    }
}


now we can call it like below
myEnum.GetmyEnumName(myEnum.entry1);
// result entry1

要阅读更多关于 Enum 的静态函数，请点击以下链接 https://basarat.gitbooks.io/typescript/docs/enums.html

【讨论】：

【解决方案19】：

我写了一个 EnumUtil 类，它通过枚举值进行类型检查：

export class EnumUtils {
  /**
   * Returns the enum keys
   * @param enumObj enum object
   * @param enumType the enum type
   */
  static getEnumKeys(enumObj: any, enumType: EnumType): any[] {
    return EnumUtils.getEnumValues(enumObj, enumType).map(value => enumObj[value]);
  }

  /**
   * Returns the enum values
   * @param enumObj enum object
   * @param enumType the enum type
   */
  static getEnumValues(enumObj: any, enumType: EnumType): any[] {
    return Object.keys(enumObj).filter(key => typeof enumObj[key] === enumType);
  }
}

export enum EnumType {
  Number = 'number',
  String = 'string'
}

使用方法：

enum NumberValueEnum{
  A= 0,
  B= 1
}

enum StringValueEnum{
  A= 'A',
  B= 'B'
}

EnumUtils.getEnumKeys(NumberValueEnum, EnumType.Number);
EnumUtils.getEnumValues(NumberValueEnum, EnumType.Number);

EnumUtils.getEnumKeys(StringValueEnum, EnumType.String);
EnumUtils.getEnumValues(StringValueEnum, EnumType.String);

NumberValueEnum 键的结果：["A", "B"]

NumberValueEnum 值的结果：[0, 1]

StringValueEnumkeys 的结果：["A", "B"]

StringValueEnumvalues 的结果：["A", "B"]

【讨论】：

不错！但是，我会切换您定义为键和值的内容。值应该是等号右侧的值，左侧的键
如何使用异构枚举？

【解决方案20】：

他们在官方文档中提供了一个名为“反向映射”的概念。它帮助了我：

https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings

解决方案非常简单：

enum Enum {
 A,
}

let a = Enum.A;
let nameOfA = Enum[a]; // "A"

【讨论】：

这有效，但仅在 numeric enums.

【解决方案21】：

在所有情况下都适合我的唯一解决方案（即使值是字符串）如下：

var enumToString = function(enumType, enumValue) {
    for (var enumMember in enumType) {
        if (enumType[enumMember]==enumValue) return enumMember
    }
}

【讨论】：

【解决方案22】：

我通过搜索“TypeScript iterate over enum keys”找到了这个问题。所以我只想发布适合我的解决方案。也许它也会对某人有所帮助。

我的情况如下：我想遍历每个枚举键，然后过滤一些键，然后访问一些对象，该对象将键作为枚举的计算值。所以这就是我在没有任何 TS 错误的情况下这样做的方式。

    enum MyEnum = { ONE = 'ONE', TWO = 'TWO' }
    const LABELS = {
       [MyEnum.ONE]: 'Label one',
       [MyEnum.TWO]: 'Label two'
    }


    // to declare type is important - otherwise TS complains on LABELS[type]
    // also, if replace Object.values with Object.keys - 
    // - TS blames wrong types here: "string[] is not assignable to MyEnum[]"
    const allKeys: Array<MyEnum> = Object.values(MyEnum)

    const allowedKeys = allKeys.filter(
      (type) => type !== MyEnum.ONE
    )

    const allowedLabels = allowedKeys.map((type) => ({
      label: LABELS[type]
    }))

【讨论】：

【解决方案23】：

老问题，但是，为什么不使用const 对象映射？

不要这样做：

enum Foo {
    BAR = 60,
    EVERYTHING_IS_TERRIBLE = 80
}

console.log(Object.keys(Foo))
// -> ["60", "80", "BAR", "EVERYTHING_IS_TERRIBLE"]
console.log(Object.values(Foo))
// -> ["BAR", "EVERYTHING_IS_TERRIBLE", 60, 80]

这样做（注意as const 演员表）：

const Foo = {
    BAR: 60,
    EVERYTHING_IS_TERRIBLE: 80
} as const

console.log(Object.keys(Foo))
// -> ["BAR", "EVERYTHING_IS_TERRIBLE"]
console.log(Object.values(Foo))
// -> [60, 80]

【讨论】：

如果我错了，请纠正我，但第一个示例中的 console.log(Object.keys(Foo)) 仅返回 ["BAR", "EVERYTHING_IS_TERRIBLE"]..
@Peter 看看here at the ts playground，只需打开控制台并单击运行。至少对我来说，它打印["60", "80", "BAR", "EVERYTHING_IS_TERRIBLE"]
这似乎是你的权利，有趣的是，如果你从数字更改为字符串，你会得到我期望的输出，我不知道为什么打字稿在枚举中处理字符串和数字的方式不同..

【解决方案24】：

如果你有枚举

enum Diet {
  KETO = "Ketogenic",
  ATKINS = "Atkins",
  PALEO = "Paleo",
  DGAF = "Whatever"
}

然后你可以得到如下键和值：

Object.keys(Diet).forEach((d: Diet) => {
  console.log(d); // KETO
  console.log(Diet[d]) // Ketogenic
});

【讨论】：

这会导致错误：Argument of type '(d: Diet) => void' is not assignable to parameter of type '(value: string, index: number, array: string[]) => void'. Types of parameters 'd' and 'value' are incompatible. Type 'string' is not assignable to type 'MyEnum'.(2345)

【解决方案25】：

您可以通过这种方式从 Enum 中获取名称数组：

const enumNames: string[] = Object.keys(YourEnum).filter(key => isNaN(Number(key)));

【讨论】：

【解决方案26】：

在 TypeScript 中，枚举被编译为 javascript 中的映射（从键中获取值）：

enum MyEnum {
  entry0,
  entry1,
}

console.log(MyEnum['entry0']); // 0
console.log(MyEnum['entry1']); // 1

它还创建了一个反向映射（从值中获取键）：

console.log(MyEnum[0]); // 'entry0'
console.log(MyEnum[0]); // 'entry1'

因此您可以通过以下方式访问条目的名称：

console.log(MyEnum[MyEnum.entry0]); // 'entry0'
console.log(MyEnum[MyEnum.entry1]); // 'entry1'

但是，字符串枚举在设计上没有反向映射（请参阅comment 和pull request），因为这可能会导致映射对象中的键和值之间发生冲突。

enum MyEnum {
  entry0 = 'value0',
  entry1 = 'value1',
}

console.log(MyEnum['value0']); // undefined
console.log(MyEnum['value1']); // undefined

如果你想强制你的字符串枚举编译一个反向映射（你必须确保所有的键和值都不同），你可以使用这个技巧：

enum MyEnum {
  entry0 = <any>'value0',
  entry1 = <any>'value1',
}

console.log(MyEnum['value0']); // 'entry0'
console.log(MyEnum['value1']); // 'entry1'
console.log(MyEnum[MyEnum.entry0]); // 'entry0'
console.log(MyEnum[MyEnum.entry1]); // 'entry1'

【讨论】：

【解决方案27】：

我发现这个解决方案更优雅：

for (let val in myEnum ) {

 if ( isNaN( parseInt( val )) )
     console.log( val );
}

它显示：

bar 
foo

【讨论】：

【解决方案28】：

要获取您必须使用的枚举值列表：

enum AnimalEnum {
  DOG = "dog", 
  CAT = "cat", 
  MOUSE = "mouse"
}

Object.values(AnimalEnum);

【讨论】：

对于具有 int 值的枚举，遗憾的是它没有按预期工作
int值的情况是什么结果？
它将返回枚举的名称和 int 值。示例：["DOG", "CAT", "MOUSE", 1, 2, 3]

【解决方案29】：

可以简短：

enum AnimalEnum {
  DOG = "dog", 
  CAT = "cat", 
  MOUSE = "mouse"
}

Object.keys(AnimalEnum).filter(v => typeof v == 'string' && isNaN(v))

【讨论】：

【解决方案30】：

我的枚举是这样的：

export enum UserSorting {
    SortByFullName = "Sort by FullName", 
    SortByLastname = "Sort by Lastame", 
    SortByEmail = "Sort by Email", 
    SortByRoleName = "Sort by Role", 
    SortByCreatedAt = "Sort by Creation date", 
    SortByCreatedBy = "Sort by Author", 
    SortByUpdatedAt = "Sort by Edit date", 
    SortByUpdatedBy = "Sort by Editor", 
}

这样做会返回未定义：

UserSorting[UserSorting.SortByUpdatedAt]

为了解决这个问题，我选择了另一种使用管道的方法：

import { Pipe, PipeTransform } from '@angular/core';

@Pipe({
    name: 'enumKey'
})
export class EnumKeyPipe implements PipeTransform {

  transform(value, args: string[] = null): any {
    let enumValue = args[0];
    var keys = Object.keys(value);
    var values = Object.values(value);
    for (var i = 0; i < keys.length; i++) {
      if (values[i] == enumValue) {
        return keys[i];
      }
    }
    return null;
    }
}

并使用它：

return this.enumKeyPipe.transform(UserSorting, [UserSorting.SortByUpdatedAt]);

【讨论】：