我想迭代一个 TypeScript 枚举对象并获取每个枚举的符号名称,例如: enum myEnum { entry1, entry2 }
for (var entry in myEnum) {
// use entry's name here, e.g., "entry1"
}
我想迭代一个 TypeScript 枚举对象并获取每个枚举的符号名称,例如: enum myEnum { entry1, entry2 }
for (var entry in myEnum) {
// use entry's name here, e.g., "entry1"
}
尽管已经提供了答案,但几乎没有人指出文档
这是一个片段
enum Enum {
A
}
let nameOfA = Enum[Enum.A]; // "A"
请记住,字符串枚举成员根本不会生成反向映射。
您发布的代码将起作用;它将打印出枚举的所有成员,包括枚举成员的值。例如,下面的代码:
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 决定在未来以不同的方式实现它们,上述技术可能会失效。
对我来说,了解正在发生的事情的一种更简单、实用和直接的方法是以下枚举:
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];
上述两种情况是更为常见的情况,因为通常您对特定值的名称和以通用方式序列化值更感兴趣。
如果您只搜索名称并稍后进行迭代,请使用:
Object.keys(myEnum).map(key => myEnum[key]).filter(value => typeof value === 'string') as string[];
假设您遵守规则并且只生成带有数值的枚举,您可以使用此代码。这可以正确处理您的姓名恰好是有效数字的情况
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']
对于当前的 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" ];
从 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()}`);
并得到这个输出:
一个是第一
似乎这里的所有答案都不适用于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]
该解决方案也有效。
enum ScreenType {
Edit = 1,
New = 2,
View = 4
}
var type: ScreenType = ScreenType.Edit;
console.log(ScreenType[type]); //Edit
简而言之
如果您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)
让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();
这里发现的另一个有趣的解决方案是使用 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
从 TypeScript 2.4 开始,枚举不再包含作为成员的键。来自 TypeScript 自述文件的来源
需要注意的是,字符串初始化的枚举不能反向映射以获取原始枚举成员名称。换句话说,您不能编写 Colors["RED"] 来获取字符串“Red”。
我的解决方案:
export const getColourKey = (value: string ) => {
let colourKey = '';
for (const key in ColourEnum) {
if (value === ColourEnum[key]) {
colourKey = key;
break;
}
}
return colourKey;
};
我厌倦了浏览错误的答案,我自己做了。
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"]
假设你有一个enum
export enum SCROLL_LABEL_OFFSET {
SMALL = 48,
REGULAR = 60,
LARGE = 112
}
并且您想创建一个基于枚举的类型,而不仅仅是复制和粘贴。您可以使用 anenum
来创建您的type
这样的:
export type ScrollLabelOffset = keyof typeof SCROLL_LABEL_OFFSET;
结果,您将收到一个type
可能值为'SMALL' | 'REGULAR' | 'LARGE'
基于上面的一些答案,我想出了这个类型安全的函数签名:
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'
根据 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
要阅读有关具有静态功能的枚举的更多信息,请点击以下链接 https://basarat.gitbooks.io/typescript/docs/enums.html
我写了一个 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"]
他们在官方文档中提供了一个称为“反向映射”的概念。它帮助了我:
https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings
解决方案非常简单:
enum Enum {
A,
}
let a = Enum.A;
let nameOfA = Enum[a]; // "A"
在所有情况下(即使值是字符串)都适用于我的唯一解决方案如下:
var enumToString = function(enumType, enumValue) {
for (var enumMember in enumType) {
if (enumType[enumMember]==enumValue) return enumMember
}
}
我通过搜索“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]
}))
老问题,但是,为什么不使用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]
如果你有枚举
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
});
您可以通过这种方式从 Enum 中获取名称数组:
const enumNames: string[] = Object.keys(YourEnum).filter(key => isNaN(Number(key)));
在 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'
但是,字符串枚举在设计上没有反向映射(请参阅评论和拉取请求),因为这可能导致映射对象中的键和值之间发生冲突。
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'
我发现该解决方案更优雅:
for (let val in myEnum ) {
if ( isNaN( parseInt( val )) )
console.log( val );
}
它显示:
bar
foo
要获取您必须使用的枚举值列表:
enum AnimalEnum {
DOG = "dog",
CAT = "cat",
MOUSE = "mouse"
}
Object.values(AnimalEnum);
可以很简短:
enum AnimalEnum {
DOG = "dog",
CAT = "cat",
MOUSE = "mouse"
}
Object.keys(AnimalEnum).filter(v => typeof v == 'string' && isNaN(v))
我的枚举是这样的:
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",
}
这样做会返回undefined:
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]);
我希望这个问题仍然相关。我使用这样的功能:
function enumKeys(target: Record<string, number|string>): string[] {
const allKeys: string[] = Object.keys(target);
const parsedKeys: string[] = [];
for (const key of allKeys) {
const needToIgnore: boolean
= target[target[key]]?.toString() === key && !isNaN(parseInt(key));
if (!needToIgnore) {
parsedKeys.push(key);
}
}
return parsedKeys;
}
function enumValues(target: Record<string, number|string>): Array<string|number> {
const keys: string[] = enumKeys(target);
const values: Array<string|number> = [];
for (const key of keys) {
values.push(target[key]);
}
return values;
}
例子:
enum HttpStatus {
OK,
INTERNAL_ERROR,
FORBIDDEN = 'FORBIDDEN',
NOT_FOUND = 404,
BAD_GATEWAY = 'bad-gateway'
}
console.log(enumKeys(HttpStatus));
// > ["OK", "INTERNAL_ERROR", "FORBIDDEN", "NOT_FOUND", "BAD_GATEWAY"]
console.log(enumValues(HttpStatus));
// > [0, 1, "FORBIDDEN", 404, "bad-gateway"]
这对于基于键值的枚举更有效:
enum yourEnum {
["First Key"] = "firstWordValue",
["Second Key"] = "secondWordValue"
}
Object.keys(yourEnum)[Object.values(yourEnum).findIndex(x => x === yourValue)]
// Result for passing values as yourValue
// FirstKey
// SecondKey
我写了一个辅助函数来枚举一个枚举:
static getEnumValues<T extends number>(enumType: {}): T[] {
const values: T[] = [];
const keys = Object.keys(enumType);
for (const key of keys.slice(0, keys.length / 2)) {
values.push(<T>+key);
}
return values;
}
用法:
for (const enumValue of getEnumValues<myEnum>(myEnum)) {
// do the thing
}
该函数返回可以轻松枚举的内容,并且还强制转换为枚举类型。
这里已经有很多答案了,但我想我还是会把我的解决方案扔到堆栈上。
enum AccountType {
Google = 'goo',
Facebook = 'boo',
Twitter = 'wit',
}
type Key = keyof typeof AccountType // "Google" | "Facebook" | "Twitter"
// this creates a POJO of the enum "reversed" using TypeScript's Record utility
const reversed = (Object.keys(AccountType) as Key[]).reduce((acc, key) => {
acc[AccountType[key]] = key
return acc
}, {} as Record<AccountType, string>)
为了清晰:
/*
* reversed == {
* "goo": "Google",
* "boo": "Facebook",
* "wit": "Twitter",
* }
* reversed[AccountType.Google] === "Google"
*/
一个不错的辅助函数:
const getAccountTypeName = (type: AccountType) => {
return reversed[type]
};
// getAccountTypeName(AccountType.Twitter) === 'Twitter'
使用当前版本的 TypeScript,您可以使用这些函数将 Enum 映射到您选择的记录。请注意,您不能使用这些函数定义字符串值,因为它们会查找具有数字值的键。
enum STATES {
LOGIN,
LOGOUT,
}
export const enumToRecordWithKeys = <E extends any>(enumeration: E): E => (
Object.keys(enumeration)
.filter(key => typeof enumeration[key] === 'number')
.reduce((record, key) => ({...record, [key]: key }), {}) as E
);
export const enumToRecordWithValues = <E extends any>(enumeration: E): E => (
Object.keys(enumeration)
.filter(key => typeof enumeration[key] === 'number')
.reduce((record, key) => ({...record, [key]: enumeration[key] }), {}) as E
);
const states = enumToRecordWithKeys(STATES)
const statesWithIndex = enumToRecordWithValues(STATES)
console.log(JSON.stringify({
STATES,
states,
statesWithIndex,
}, null ,2));
// Console output:
{
"STATES": {
"0": "LOGIN",
"1": "LOGOUT",
"LOGIN": 0,
"LOGOUT": 1
},
"states": {
"LOGIN": "LOGIN",
"LOGOUT": "LOGOUT"
},
"statesWithIndex": {
"LOGIN": 0,
"LOGOUT": 1
}
}
这里有很多答案,考虑到尽管这是 7 岁的问题,我还是查了一下,我想会有更多的人来这里。这是我的解决方案,它比其他解决方案简单一些,它处理纯数字/纯文本/混合值枚举,都一样。
enum funky {
yum , tum='tum', gum = 'jump', plum = 4
}
const list1 = Object.keys(funky)
.filter(k => (Number(k).toString() === Number.NaN.toString()));
console.log(JSON.stringify(list1)); // ["yum","tum","gum","plum"]"
// for the numeric enum vals (like yum = 0, plum = 4), typescript adds val = key implicitly (0 = yum, 4 = plum)
// hence we need to filter out such numeric keys (0 or 4)
如果它是你的enum
并且你定义如下,名称和值是相同的,它会直接给你条目的名称。
enum myEnum {
entry1="entry1",
entry2="entry2"
}
for (var entry in myEnum) {
// use entry's name here, e.g., "entry1"
}
只是为了用所有可能的解决方案来更新这个问题,现在我们可以使用迭代器协议来使任何对象可迭代
enum carsEnum{
BMW="BMW",
MERCEDES="Mercedes",
TOYOTA="toyota",
}
carsEnum.[Symbol.iterator]=function(){
let keys = Object.keys(carsEnum)
let idx =0;
return {
next:()=>
(idx<keys.length)?{value:this[keys[idx++]],done:false}:{value:undefined,done:true}
}
}
for(let value of carsEnum){
console.log(value) //'BMW' 'Mercedes' 'toyota'
}
有数字枚举:
enum MyNumericEnum {
First = 1,
Second = 2
}
您需要先将其转换为数组:
const values = Object.values(MyNumericEnum);
// ['First', 'Second', 1, 2]
如您所见,它包含键和值。钥匙先走。
之后,您可以检索其密钥:
values.slice(0, values.length / 2);
// ['First', 'Second']
和价值观:
values.slice(values.length / 2);
// [1, 2]
对于字符串枚举,您可以分别Object.keys(MyStringEnum)
用于获取键和Object.values(MyStringEnum)
获取值。
尽管提取混合 enum的键和值有些挑战。
这不完全是您问题的答案,但它是解决您问题的技巧。
export module Gender {
export enum Type {
Female = 1,
Male = 2
};
export const List = Object.freeze([
Type[Type.Female] ,
Type[Type.Male]
]);
}
您可以以您想要的方式扩展您的列表模型。
export const List = Object.freeze([
{ name: Type[Type.Female], value: Type.Female } ,
{ name: Type[Type.Male], value: Type.Male }
]);
现在,您可以通过以下方式使用它:
for(const gender of Gender.List){
console.log(gender.name);
console.log(gender.value);
}
或者:
if(i === Gender.Type.Male){
console.log("I am a man.");
}