A literal type is a type whose only inhabitant is a single exact value — not just `string` but the precise string `'T20'`, not just `number` but the precise `200`. On their own a literal might seem pointless, but combined into unions they become one of TypeScript's most powerful tools for modelling closed sets of exact values, and they pair inseparably with narrowing — the compiler's ability to refine a broad type to a more specific one based on the checks your code performs. This matters because together they let you replace loose strings and magic numbers with values the compiler treats as a fixed menu, catching every typo and unhandled case. Narrowing then lets you safely act on whichever specific value you have. Mastering literals and narrowing is the bridge from merely 'typed' code to code where the compiler understands your domain's exact vocabulary and tracks which case you are in at every line.
35 minintermediate
Literal Types and Narrowing
Analogy🏏Cricket
🏏 Think of it like cricket: Picture how a scoreboard operator constructs every display string from fixed components in a strict format — a batter's line is always built as `${name} ${runs} (${balls})`, never improvised. The format is a template with slots, and only values that fit each slot are allowed. Just as the scoreboard builds each line by filling a fixed template with the right pieces, a template literal type builds a string type by filling a pattern with other types. Just as a stray entry that does not match the format — text where runs should go — is rejected by the operator, a string that does not match the template literal type is rejected by the compiler. Just as the format guarantees every line is readable and consistent, the template type guarantees every string matches the intended shape. This reveals why template literal types matter: strings in software follow patterns just like scoreboard lines, and encoding the pattern into the type makes every malformed string an immediate error.
Lesson 8 of 35
0% complete