← Back tothis vs that

literal union type vs string enums

Written byPhuoc Nguyen
26 Aug, 2020
In TypeScript, there are a few ways to enumerate the possible values of a type. Let's consider a situation where our website has to support different themes including default, light, and dark.
They can be defined by one of the following approaches:
  • Using a union of string literal types
type Theme = 'DEFAULT' | 'LIGHT' | 'DARK';
  • Using an enum
enum Theme {


  1. TypeScript does not generate code for the union of string literals. As a result, the generated code will have a smaller size.
    Here is the generated code when TypeScript transpiles the `Theme` enum:
    var Theme;
    (function (Theme) {
    Theme[(Theme['DEFAULT'] = 0)] = 'DEFAULT';
    Theme[(Theme['LIGHT'] = 1)] = 'LIGHT';
    Theme[(Theme['DARK'] = 2)] = 'DARK';
    })(Theme || (Theme = {}));
  2. In the case of using a union type, you still have to type the full string when creating a new variable, for example:
    type Theme = 'DEFAULT' | 'LIGHT' | 'DARK';
    const theme: Theme = 'DEFAULT';
    Popular editors like Visual Studio Code help us choose the value from the list of possible values quickly but we have to manually change the value in all places if we want to refactor the value to something else.
    On the other hand, using `enum` gives a few remarkable benefits when you refactor the code or develop a library. Let's take a look at a simple use case where your library provides the following function to switch the website to a given theme:
    const switchTheme = (theme: Theme) => {

    export { Theme, switchTheme };
    The consumers now can pass a particular theme to the `switchTheme` function without caring about the real value behind:
    // consumer
    import { Theme, switchTheme } from 'your-lib';

    In comparison to `switchTheme('DARK')`, how convenient and safe the invoke above is.

Good to know

There is another approach using the const assertions which is available from TypeScript 3.4.
const Theme = {
DEFAULT: 'Default',
LIGHT: 'Light',
DARK: 'Dark',
} as const;

type Theme = typeof Theme[keyof typeof Theme];

let darkTheme: Theme = Theme.DARK;
let lightTheme: Theme = 'Light';
const invalidTheme: Theme = 'Blue'; // ERROR

Good practice

If you don't set the values for enum, they will be set to incremental numbers by default.
So `Theme.DEFAULT`, `Theme.LIGHT` and `Theme.DARK` will take the value of 0, 1, 2, respectively. It is more hard to debug:
console.log(Theme.DARK); // 2
Even if we set the number for enum values, it's still possible for us to set an invalid value for a variable whose type is the enum:
enum Theme {
LIGHT = 1,
DARK = 2,

// TypeScript doesn't throw errors
const theme: Theme.DEFAULT = 3;
Due to these reasons, it's advised to use string literals for the enum values. The `Theme` enum should look like as follow:
enum Theme {
DEFAULT = 'Default',
LIGHT = 'Light',
DARK = 'Dark',

console.log(Theme.DARK); // 'Dark'
let theme: Theme.DEFAULT = 'Default'; // ERROR

See also

If you found this post helpful, please consider giving the repository a star on GitHub or sharing the post on your favorite social networks 😍. Your support would mean a lot to me!

Questions? 🙋

Do you have any questions about front-end development? If so, feel free to create a new issue on GitHub using the button below. I'm happy to help with any topic you'd like to learn more about, even beyond what's covered in this post.
While I have a long list of upcoming topics, I'm always eager to prioritize your questions and ideas for future content. Let's learn and grow together! Sharing knowledge is the best way to elevate ourselves 🥷.
Ask me questions

Recent posts ⚡

Newsletter 🔔

If you're into front-end technologies and you want to see more of the content I'm creating, then you might want to consider subscribing to my newsletter.
By subscribing, you'll be the first to know about new articles, products, and exclusive promotions.
Don't worry, I won't spam you. And if you ever change your mind, you can unsubscribe at any time.
Phước Nguyễn