Type Systems in TypeScript: A Comprehensive Guide

A type system is a set of rules the compiler uses to decide what's allowed and what isn't. In TypeScript, that checking happens at compile time — before your code ever runs. The goal: catch mistakes early instead of discovering them in production.

Type annotations

TypeScript can infer types, but sometimes you need to be explicit. That's a type annotation.

let name: string = 'John';
let age: number = 30;

You're telling the compiler: "This is a string. This is a number. Don't let me use them as anything else."

When to annotate vs. when to let TypeScript infer? I annotate function parameters and return types. I let inference handle local variables. That's the sweet spot between safety and readability.

Type guards

Sometimes a value could be one of several types. A type guard narrows it down within a specific scope.

Think of it as asking "are you a number?" and getting a compiler-verified answer.

function isNumber<T>(value: T): value is number {
  return typeof value === 'number';
}

let age: number | string = 30;
if (isNumber(age)) {
  console.log(`Age: ${age}`); // TypeScript knows age is a number here
} else {
  console.log('Not a number');
}

The value is number return type is the key. It tells TypeScript to narrow the type inside the if block.

Conditional types

Conditional types let you create types that change based on a condition. They follow the same A extends B ? C : D pattern as a ternary expression, but at the type level.

type IsString<T> = T extends string ? string : never;

type NameType = IsString<"John">;  // string
type AgeType = IsString<42>;       // never

If T extends string, the type resolves to string. Otherwise, never.

This is powerful for building flexible utility types. But it's also where TypeScript's type system starts to feel like its own programming language. Use conditional types when you need them. Don't reach for them to be clever.

The trade-off

TypeScript's type system catches real bugs. I've seen it prevent production incidents that would have taken hours to debug.

The cost: it adds complexity. Overly clever types slow down your team more than they protect it. The best TypeScript code uses the simplest types that get the job done.