Use object literal as TypeScript enum values
Solution 1
Update: find @Javarome's answer below, which is more elegant. I suggest using his way.
If you need to use Type, try adding some code.
usage: 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};
}
}
Solution 2
TypeScript supports numeric or string-based enums only, so you have to emulate object enums with a class (which will allow you to use it as a type in a function declaration):
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;
}
}
then you can use the predefined instances to access their value
:
const mediumVal = PizzaSize.MEDIUM.value;
or whatever other property/property type you may want to define in a PizzaSize
.
and thanks to the toString()
overriding, you will also be able to print the enum name/key implicitly from the object:
console.log(PizzaSize.MEDIUM); // prints 'MEDIUM'
Solution 3
As of Typescript 3.4, you can use a combination of keyof typeof
and const
assertions to create objects that can have the same type safety as enums, and still hold complex values.
By creating a type
with the same name as the const
, you can have the same exhaustiveness checks that normal enums have.
The only wart is that you need some key in the complex object (I'm using value
here) to hold the name of the enum member (if anyone can figure out a helper function that can build these objects in a typesafe way, I'd love to see it! I couldn't get one working).
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'
}
}
In other files this can be used simply, just import PizzaSize
.
import { PizzaSize } from './pizza'
console.log(PizzaSize.small.key)
type Order = { size: PizzaSize, person: string }
Also notice how even objects that are usually mutable can't be mutated with the as const
syntax.
const Thing = {
ONE: { one: [1, 2, 3] }
} as const
// this won't compile!! Yay!!
Thing.ONE.one.splice(1, 0, 0)
Solution 4
I think to get to what you want, something like this will work
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"
Solution 5
Object.freeze makes it read only and prevents more properties being added:
const pizzaSize = Object.freeze({
small: { key: 0, value: 25 },
medium: { key: 1, value: 35 },
large: { key: 2, value: 50 }
})
Vahe Akhsakhalyan
Updated on March 19, 2021Comments
-
Vahe Akhsakhalyan about 3 years
I have an enum:
export enum PizzaSize { SMALL = 0, MEDIUM = 1, LARGE = 2 }
But here I'd like to use some pair of values: e.g.
SMALL
I would like to say that it has akey
of0
and avalue
of100
. I endeavor to use:export enum PizzaSize { SMALL = { key: 0, value: 100 }, // ... }
But TypeScript doesn't accept this one. How can I do this?
-
Frohlich over 5 yearsWay more elegant than the accepted answer but, the constructor should be private constructor(private key: string, PUBLIC value: any) {} to be able to use PizzaSize.MEDIUM.value or define a getter to it
-
Jérôme Beau over 5 yearsTrue @Flohlich. Just added a getter to forbid change of such an enum constant.
-
Alexander Mills over 5 yearsthis answer is unclear to me, can you show the
enum
declaration not just thePizzaSize
class? -
Jérôme Beau over 5 years@Alexander Mills There is no enum declaration, that’s the point : as there is no support for object enum you have to emulate it through a class declaration.
-
qqilihq about 5 yearsI'd suggest to declare the static items
readonly
as well. Else wise they could be reassigned externally (PizzaSize.SMALL = PizzaSize.LARGE; // get a big pizza, but pay small :-)
). -
Joe Tse about 5 yearsThis is much more elegant. I would use your way too. Upvoted.
-
j1s about 5 yearsHow can use this in angular html template?
-
Jérôme Beau about 5 years@j1s In the relevant component, declare a public property this has the name name as the enum and is equal to it:
PizzaSize = PizzaSize
. Then you'll be allowed to writePizzaSize.LARGE
in your template. -
blaineh almost 5 yearsCheck out my recent answer, it also has the benefit of exhausiveness checks
-
Drenai over 4 years+1 for the
const ... as const
, that's a new one for me! This approach is ok, but it's a bit more difficult to reason about than Javarome's -
JeffryHouser over 4 yearsWhat is the purpose of the
toString()
method or the arguments into the constructor? -
JeffryHouser over 4 yearsNevermind, I figured it out. The internal read only variables are instances of the class. Got it!
-
Drenai over 4 yearsBe careful using this approach if you clone your objects with
Ramda
/lodash
, e.gR.clone({pizza: PizzaSize.MEDIUM})
or_.cloneDeep
. Triple equals andswitch
statements won't work like they do with TypeScriptenum
-
blaineh over 4 yearsI wish this gave exhaustiveness checks :( That's often the main reason I want to use an enum typescriptlang.org/play/#code/…
-
blaineh over 4 yearsIt does seem a little tricky. And it doesn't allow you to add functions to the "enum" values like the class does. But this give exhaustiveness checks where the class doesn't, so it's just a choice of tradeoffs I'm afraid.
-
Basti over 3 yearsFYI my tsc
3.9.7
is complaining aboutorder(PizzaSize.large)
withArgument of type '{ readonly value: "large"; readonly key: 2; readonly size: 50; }' is not assignable to parameter of type '"small" | "medium" | "large"'
. So it doesn't behave like enums in that way. -
blaineh over 3 yearsYeah this solution isn't exactly like enums, it's just parallel, using the keys of a
const
object instead of an actual enum value. Passorder(PizzaSize.large.value)
ororder('large')
and everything will compile. Doing that is just as typesafe as an enum. -
Onur Yıldırım over 2 yearsOnly first level. You should also freeze each deeper level.
-
fIwJlxSzApHEZIl over 2 yearsis there any way to make compilation fail if you add a value to
PizzaSize
if you forget to modifypizzas
? -
Dennis over 2 yearsIn terms of building the values of the enumerated objects in a typesafe way, the best I could think to do was to cast each declaration as I defined it. It's a little more verbose than I'd like, but it seems to get the job done.
-
bhantol over 2 yearsThis answer is no way close to object literal enum. stackoverflow.com/a/51398471/2103767 is by far the best by @Javarome