使用对象字面量作为 TypeScript 枚举值

Question

我有一个枚举：

export enum PizzaSize {
  SMALL =  0,
  MEDIUM = 1,
  LARGE = 2
}

但在这里我想使用一些值：例如SMALL 我想说它有0 的key 和100 的value。我努力使用：

export enum PizzaSize {
  SMALL =  { key: 0, value: 100 },
  // ...
}

但是 TypeScript 不接受这个。我该怎么做？

Answer 1

仅限 TypeScript supports numeric or string-based enums，因此您必须使用类模拟对象枚举（这将允许您将其用作函数声明中的类型）：

export class PizzaSize {
  static readonly SMALL  = new PizzaSize('SMALL', 'A small pizza');
  static readonly MEDIUM = new PizzaSize('MEDIUM', 'A medium pizza');
  static readonly LARGE  = new PizzaSize('LARGE', 'A large pizza');

  // private to disallow creating other instances of this type
  private constructor(private readonly key: string, public readonly value: any) {
  }

  toString() {
    return this.key;
  }
}

那么你可以使用预定义的实例来访问他们的value:

const mediumVal = PizzaSize.MEDIUM.value;

或您可能想在PizzaSize 中定义的任何其他属性/属性类型。

并且由于 toString() 覆盖，您还可以从对象中隐式打印枚举名称/键：

console.log(PizzaSize.MEDIUM);  // prints 'MEDIUM'

Answer 2

更新：在下方找到@Javarome's answer，更优雅。我建议用他的方式。

如果您需要使用 Type，请尝试添加一些代码。 用法：getPizzSizeSpec(PizzaSize.small).value

enum PizzaSize {
    small,
    medium,
    large
}
interface PizzaSizeSpec {
    key: number,
    value: number
}
function getPizzaSizeSpec(pizzaSize: PizzaSize): PizzaSizeSpec {
    switch (pizzaSize) {
        case PizzaSize.small:
            return {key:0, value: 25};
        case PizzaSize.medium:
            return {key:0, value: 35};
        case PizzaSize.large:
            return {key:0, value: 50};
    }
}

Answer 3

从Typescript 3.4 开始，您可以使用keyof typeof 和const assertions 的组合来创建可以与枚举具有相同类型安全性的对象，并且仍然可以保存复杂值。

通过创建与const 同名的type，您可以进行与普通枚举相同的详尽检查。

唯一的缺点是你需要复杂对象中的一些键（我在这里使用value）来保存枚举成员的名称（如果有人能找出一个可以在类型安全的方式，我很想看到它！我无法让一个工作）。

export const PizzaSize = {
    small: { value: 'small', key: 0, size: 25 },
    medium: { value: 'medium', key: 1, size: 35 },
    large: { value: 'large', key: 2, size: 50 },
} as const

export type PizzaSize = keyof typeof PizzaSize

// if you remove any of these cases, the function won't compile
// because it can't guarantee that you've returned a string
export function order(p: PizzaSize): string {
    switch (p) {
        case PizzaSize.small.value: return 'just for show'
        case PizzaSize.medium.value: return 'just for show'
        case PizzaSize.large.value: return 'just for show'
    }
}

// you can also just hardcode the strings,
// they'll be type checked
export function order(p: PizzaSize): string {
    switch (p) {
        case 'small': return 'just for show'
        case 'medium': return 'just for show'
        case 'large': return 'just for show'
    }
}

在其他文件中这个可以简单的使用，只需要导入PizzaSize即可。

import { PizzaSize } from './pizza'

console.log(PizzaSize.small.key)

type Order = { size: PizzaSize, person: string }

还要注意即使是通常可变的对象也不能使用as const 语法进行变异。

const Thing = {
    ONE: { one: [1, 2, 3] }
} as const

// this won't compile!! Yay!!
Thing.ONE.one.splice(1, 0, 0)

Answer 4

我认为要达到你想要的，这样的事情会起作用

interface PizzaInfo {
  name: string;
  cost_multiplier: number;
}

enum PizzaSize {
  SMALL,
  MEDIUM,
  LARGE,
}

const pizzas: Record<PizzaSize, PizzaInfo> = {
  [PizzaSize.SMALL]: { name: "Small", cost_multiplier: 0.7 },
  [PizzaSize.MEDIUM]: { name: "Medium", cost_multiplier: 1.0 },
  [PizzaSize.LARGE]: { name: "Large", cost_multiplier: 1.5 },
};

const order = PizzaSize.SMALL;
console.log(pizzas[order].name);  // "Small"

Answer 5

Object.freeze 使其只读并防止添加更多属性：

const pizzaSize = Object.freeze({
  small: { key: 0, value: 25 },
  medium: { key: 1, value: 35 },
  large: { key: 2, value: 50 }
})

Answer 6

您可以使用类型化的 const 来实现：

export const PizzaSize: {
    [key: string]: { key: string, value: string };
} = {
    SMALL: { key: 'key', value: 'value' }
};

您可以选择将类型信息提取到单独的接口声明中：

interface PizzaSizeEnumInstance {
    key: string;
    value: string;
}

interface PizzaSizeEnum {
    [key: string]: PizzaSizeEnumInstance;
}

export const PizzaSize: PizzaSizeEnum = {
    SMALL: { key: 'key', value: 'value' }
};