检查 TypeScript 的枚举中是否存在值

Question

我收到一个号码 type = 3 并且必须检查它是否存在于这个枚举中：

export const MESSAGE_TYPE = {
    INFO: 1,
    SUCCESS: 2,
    WARNING: 3,
    ERROR: 4,
};

我发现最好的方法是将所有枚举值作为一个数组并在其上使用 indexOf。但是生成的代码不是很清晰：

if( -1 < _.values( MESSAGE_TYPE ).indexOf( _.toInteger( type ) ) ) {
    // do stuff ...
}

有没有更简单的方法？

Answer 1

这仅适用于非常量、基于数字的枚举。对于 const 枚举或其他类型的枚举，请参阅this answer above

---

如果您使用的是 TypeScript，则可以使用 actual enum。然后您可以使用in 进行检查。

export enum MESSAGE_TYPE {
    INFO = 1,
    SUCCESS = 2,
    WARNING = 3,
    ERROR = 4,
};

var type = 3;

if (type in MESSAGE_TYPE) {

}

这是因为当你编译上面的枚举时，它会生成下面的对象：

{
    '1': 'INFO',
    '2': 'SUCCESS',
    '3': 'WARNING',
    '4': 'ERROR',
    INFO: 1,
    SUCCESS: 2,
    WARNING: 3,
    ERROR: 4
}

Answer 2

如果您希望它与字符串枚举一起使用，您需要使用Object.values(ENUM).includes(ENUM.value)，因为根据https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-4.html，字符串枚举不是反向映射的：

Enum Vehicle {
    Car = 'car',
    Bike = 'bike',
    Truck = 'truck'
}

变成：

{
    Car: 'car',
    Bike: 'bike',
    Truck: 'truck'
}

所以你只需要这样做：

if (Object.values(Vehicle).includes('car')) {
    // Do stuff here
}

如果您收到错误消息：Property 'values' does not exist on type 'ObjectConstructor'，那么您的目标不是 ES2017。你可以使用这个 tsconfig.json 配置：

"compilerOptions": {
    "lib": ["es2017"]
}

或者你可以做一个 any 演员：

if ((<any>Object).values(Vehicle).includes('car')) {
    // Do stuff here
}

Answer 3

export enum UserLevel {
  Staff = 0,
  Leader,
  Manager,
}

export enum Gender {
  None = "none",
  Male = "male",
  Female = "female",
}

日志中的差异结果：

log(Object.keys(Gender))
=>
[ 'None', 'Male', 'Female' ]

log(Object.keys(UserLevel))
=>
[ '0', '1', '2', 'Staff', 'Leader', 'Manager' ]

解决方案，我们需要将键删除为数字。

export class Util {
  static existValueInEnum(type: any, value: any): boolean {
    return Object.keys(type).filter(k => isNaN(Number(k))).filter(k => type[k] === value).length > 0;
  }
}

用法

// For string value
if (!Util.existValueInEnum(Gender, "XYZ")) {
  //todo
}

//For number value, remember cast to Number using Number(val)
if (!Util.existValueInEnum(UserLevel, 0)) {
  //todo
}

Answer 4

您的问题有一个非常简单易行的解决方案：

var districtId = 210;

if (DistrictsEnum[districtId] != null) {

// Returns 'undefined' if the districtId not exists in the DistrictsEnum 
    model.handlingDistrictId = districtId;
}

Answer 5

export enum YourEnum {
   enum1 = 'enum1',
   enum2 = 'enum2',
   enum3 = 'enum3',
}

const status = 'enumnumnum';

if (!Object.values(YourEnum)?.includes(status)) {
     throw new UnprocessableEntityResponse('Invalid enum val');
}

Answer 6

enum ServicePlatform {
    UPLAY = "uplay",
    PSN = "psn",
    XBL = "xbl"
}

变成：

{ UPLAY: 'uplay', PSN: 'psn', XBL: 'xbl' }

所以

ServicePlatform.UPLAY in ServicePlatform // false

解决方案：

ServicePlatform.UPLAY.toUpperCase() in ServicePlatform // true

Answer 7

According to sandersn 最好的方法是：

Object.values(MESSAGE_TYPE).includes(type as MESSAGE_TYPE)

Answer 8

对于任何来到这里希望验证字符串是否是枚举值之一并将其类型转换的人，我编写了这个函数，它返回正确的类型，如果字符串不在枚举中，则返回 undefined。

function keepIfInEnum<T>(
  value: string,
  enumObject: { [key: string]: T }
) {
  if (Object.values(enumObject).includes((value as unknown) as T)) {
    return (value as unknown) as T;
  } else {
    return undefined;
  }
}

举个例子：

enum StringEnum {
  value1 = 'FirstValue',
  value2 = 'SecondValue',
}
keepIfInEnum<StringEnum>('FirstValue', StringEnum)  // 'FirstValue'
keepIfInEnum<StringEnum>('OtherValue', StringEnum)  // undefined

Answer 9

类型断言是不可避免的。跟进

enum Vehicle {
    Car = 'car',
    Bike = 'bike',
    Truck = 'truck'
}

我找到了一个没有提到的替代方案，所以我想分享一下我的解决方法：

const someString: Vehicle | string = 'car';
const inEnum = (Object.values(Vehicle) as string[]).includes(someString);

我觉得这更真实，因为我们通常使用类型安全（带有字符串）并希望将其与枚举进行比较；将其转换为any（原因：永远不要这样做）或Vehicle（原因：可能不真实）有点鲁莽。相反，将Object.values() 输出类型转换为字符串数组实际上非常真实。

Answer 10

更新：

我发现每当我需要检查枚举中是否存在值时，我并不真的需要枚举，而类型是更好的解决方案。所以我的原始答案中的枚举变为：

export type ValidColors =
  | "red"
  | "orange"
  | "yellow"
  | "green"
  | "blue"
  | "purple";

原答案：

为了清楚起见，我喜欢将 values 和 includes 调用分成不同的行。这是一个例子：

export enum ValidColors {
  Red = "red",
  Orange = "orange",
  Yellow = "yellow",
  Green = "green",
  Blue = "blue",
  Purple = "purple",
}

function isValidColor(color: string): boolean {
  const options: string[] = Object.values(ValidColors);
  return options.includes(color);
}

Answer 11

如果你在那里找到如何检查联合是否包含特定值，有解决方案：

// source enum type
export const EMessagaType = {
   Info,
   Success,
   Warning,
   Error,
};

//check helper
const isUnionHasValue = <T extends number>(union: T, value: T) =>
   (union & value) === value;


//tests
console.log(
 isUnionHasValue(EMessagaType.Info | EMessagaType.Success), 
 EMessagaType.Success);

//output: true


console.log(
 isUnionHasValue(EMessagaType.Info | EMessagaType.Success), 
 EMessagaType.Error); 

//output: false

Answer 12

以下函数返回另一个函数，该函数充当输入枚举的类型谓词（假设它是字符串样式的枚举）。

function constructEnumPredicate<RuntimeT extends string, EnumClass extends {[key: string]: RuntimeT}>(enumClass: EnumClass): (maybeEnum: string) => maybeEnum is EnumClass[keyof EnumClass] {
    const reverseMapping: {[key: string]: boolean} = {};

    for (const enumVal in enumClass) {
        const enumStr = enumClass[enumVal];
        reverseMapping[enumStr] = true;
    }

    function result(maybeEnum: any): maybeEnum is EnumClass[keyof EnumClass] {
        return !!reverseMapping[maybeEnum];
    }

    return result;
}

它适用于 TypeScript 4.2.4，但我没有测试过早期版本。

主要有趣的部分是EnumClass[keyof EnumClass] 返回类型。当这种类型是 TypeScript 中的枚举时，它返回枚举的原始类型，其中 EnumClass 是运行时枚举类的类型。

关于如何使用这种构造的示例，假设我们有以下枚举：

enum Direction {
    Left = "<-",
    Right = "->"
}

Direction 既是类型又是运行时对象。我们可以为 Direction 生成一个类型谓词并像这样使用它：

const isDirection = constructEnumPredicate(Direction);
function coerceDirection(maybeDir: string): Direction {
    // Since we make a type predicate rather than just a normal predicate,
    // no explicit type casting is necessary!
    return isDirection(maybeDir) ? maybeDir : Direction.Left;
}