1. Introduction
A literal type restricts a value to one exact, specific value rather than a whole category of values. Instead of the general type string, a literal type like "success" only permits that one exact string. TypeScript supports string literal types, numeric literal types, and boolean literal types, and they become especially powerful when combined into unions of literals.
Cricket analogy: A literal type is like specifying "not out" as the only accepted dismissal value instead of any general string, so TypeScript rejects "retired hurt" unless you also included it in the union.
Literal type unions are TypeScript's idiomatic replacement for many uses of enums: type Direction = "north" | "south" | "east" | "west" restricts a value to exactly one of those four strings, giving you autocomplete and compile-time validation without a runtime enum object.
Cricket analogy: type Direction = "north" | "south" | "east" | "west" mirrors restricting a fielding position call to exactly "slip" | "gully" | "point" | "cover" — the captain gets autocomplete on the sideline without needing a runtime FieldingPosition object.
2. Syntax
let direction: "up" | "down" | "left" | "right";
direction = "up"; // OK
// direction = "north"; // Error: not assignable
type HttpMethod = "GET" | "POST" | "PUT" | "DELETE";
function request(method: HttpMethod, url: string) {
console.log(`${method} ${url}`);
}
const config = { role: "admin" } as const; // literal-typed via as const3. Explanation
When you write let direction: "up" | "down";, the annotation restricts the variable to exactly one of those two exact string values -- assigning any other string is a type error, even other perfectly valid strings. This is a stricter and more precise alternative to using the general string type, and it plugs directly into editor autocomplete, giving you the full list of valid values as you type.
Cricket analogy: let call: "heads" | "tails" restricts the toss call so tightly that even the valid English word "top" is a type error, and the editor autocompletes only the two legal calls at the coin toss.
Literal types combine naturally with unions to build lightweight, string-based enums (type Status = "idle" | "loading" | "success" | "error"), which many teams prefer over TypeScript's enum keyword because they compile away completely (no runtime object) and work well with plain JSON data from APIs. A common way to get literal types automatically from object properties is as const, which tells TypeScript to infer the narrowest possible (deeply readonly) literal types for an expression instead of widening them to their general types.
Cricket analogy: type Status = "idle"|"loading"|"success"|"error" behaves like a lightweight scoreboard-state field that compiles away entirely, matching plain JSON from a scoring API, and marking a lineup object as const with as const locks each batting-order slot to its exact literal name instead of widening to string.
Gotcha: without as const, an object literal like const config = { role: "admin" } infers role as the widened type string, not the literal "admin" -- object property inference widens by default even though the outer binding is const. Adding as const makes every property (recursively) a readonly literal type, which is often required when passing object literals to functions expecting literal-typed parameters.
4. Example
type Size = "small" | "medium" | "large";
function priceFor(size: Size): number {
const prices: Record<Size, number> = {
small: 3,
medium: 5,
large: 7,
};
return prices[size];
}
console.log(priceFor("medium"));
// Without as const, role widens to string
const configLoose = { role: "admin" };
// Function expecting a literal union would reject configLoose.role
// With as const, role narrows to the literal "admin"
const configStrict = { role: "admin" } as const;
function printRole(role: "admin" | "guest") {
console.log(`Role: ${role}`);
}
printRole(configStrict.role);
console.log(typeof configLoose.role);5. Output
5
Role: admin
string6. Key Takeaways
Practice what you learned
1. Given `let dir: "up" | "down";`, what happens if you write `dir = "left";`?
2. What is the inferred type of `role` in `const config = { role: "admin" };` (without `as const`)?
3. What does adding `as const` after an object literal do?
4. Why do many TypeScript codebases prefer literal type unions over the `enum` keyword?
5. Which type correctly restricts a variable to only the numbers 1, 2, or 3?
Was this page helpful?
You May Also Like
Type Inference in TypeScript
How TypeScript figures out types automatically from values, without explicit annotations.
Union and Intersection Types in TypeScript
Combine types with `|` (union) and `&` (intersection) to model values that can be one of several shapes or must satisfy all of them.
Enums in TypeScript
Named sets of constants — numeric, string, and const enums — and how they differ from plain unions of literal types at runtime.
Template Literal Types in TypeScript
Build new string literal types by interpolating other types into a template, similar to JS template literals but evaluated at the type level.
Related Reading
Related Study Notes in Programming
Browse all study notesApache Spark Study Notes
Programming · 30 topics
ProgrammingApache Flink Study Notes
Programming · 30 topics
ProgrammingHadoop Study Notes
Programming · 30 topics
ProgrammingSnowflake Study Notes
Programming · 30 topics
ProgrammingApache Airflow Study Notes
Programming · 30 topics
Programmingdbt (Data Build Tool) Study Notes
Programming · 30 topics