← 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

Questions? 🙋

Do you have any questions? Not just about this specific post, but about any topic in front-end development that you'd like to learn more about? If so, feel free to send me a message on Twitter or send me an email. You can find them at the bottom of this page.
I have a long list of upcoming posts, but your questions or ideas for the next one will be my top priority. Let's learn together! Sharing knowledge is the best way to grow 🥷.

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