Basic Types

TypeScript adds a type-checking layer on top of JavaScript, but the values at runtime are exactly the same values JavaScript has always had. The three you reach for constantly are string, number and boolean — lower-case, because TypeScript reserves the capitalised String, Number and Boolean for the rarely-used wrapper object types. An annotation is the : type after a name; it tells the compiler what is allowed, and disappears completely once the code is compiled to JavaScript.

let age: number
age = "thirty"

app.ts:2:1 - error TS2322: Type 'string' is not assignable to type 'number'.

2 age = "thirty"
  ~~~

let age: number
age = 30

Primitive

An immutable value that is not an object: string, number, boolean, null, undefined, bigint, symbol.

Type annotation

The : Type written after a name to declare what values it may hold. Erased entirely at compile time — it produces no JavaScript.

Static typing

Checking types before the program runs (at compile time) rather than while it runs. TypeScript's whole job.

An array type says two things: "this is a list" and "every element has this type". You can write it two ways — number[] or Array<number> — and they mean exactly the same thing. The bracket form is far more common in everyday code; the generic form shows up more once you are comfortable with generics in general, or when the element type itself is already a union and brackets would be ambiguous.

A tuple is written like an array literal of types — [string, number] — and it fixes both the length and the type at each position. Position 0 must be a string, position 1 must be a number, and (by default) that is the whole array. Tuples are how you type things like coordinate pairs, [key, value] entries, or a function that returns two values at once.

const point: [number, number] = [10, "20"]

app.ts:1:39 - error TS2322: Type 'string' is not assignable to type 'number'.

1 const point: [number, number] = [10, "20"]
                                        ~~~~

const point: [number, number] = [10, 20]

Tuple

An array type with a fixed length and a specific type per position, e.g. [string, number].

Tuple destructuring

Unpacking a tuple by position into named variables: const [key, value] = entry.

any, unknown and never sit at the edges of the type system and are easy to mix up. any tells the compiler to stop checking — you can call anything on it, assign it anywhere, and get no warnings, which makes it a trapdoor out of type safety rather than a type. unknown is the type-safe version: it can hold anything, but the compiler will not let you do anything with it until you narrow it — with typeof, instanceof, or a custom check — to something more specific. never is the type of a value that can never exist: a function that always throws, or one with an infinite loop, returns never.

let u: unknown = "hello"
console.log(u.toUpperCase())

app.ts:2:14 - error TS2571: Object is of type 'unknown'.

2 console.log(u.toUpperCase())
               ~

let u: unknown = "hello"
if (typeof u === "string") {
  console.log(u.toUpperCase())
}

function fail(message: string): never {
  throw new Error(message)
}

function loopForever(): never {
  while (true) {
    // never returns
  }
}

A function annotated never is a promise to the caller: this call will not complete normally — it always throws or never returns. The compiler also infers never on its own for the unreachable branch of an exhaustive switch.

A literal type narrows a general type down to one exact value — not "a string", but the string "left" specifically. On their own they are not very useful, but combined with the union operator | they describe a closed, exact set of allowed values, which is one of TypeScript's most practical patterns for options, modes and states.

type Direction = "left" | "right"

function move(direction: Direction) {
  console.log("Moving", direction)
}

move("up")

app.ts:6:6 - error TS2345: Argument of type '"up"' is not assignable to parameter of type '"left" | "right"'.

6 move("up")
       ~~~~

type Direction = "left" | "right" | "up"

function move(direction: Direction) {
  console.log("Moving", direction)
}

move("up")

• Function options: type Align = "start" | "center" | "end"
• State machines: type Status = "idle" | "loading" | "success" | "error"
• HTTP-adjacent code: type Method = "GET" | "POST" | "PUT" | "DELETE"
• Anywhere you would reach for an enum in another language — see the enums lesson for the tradeoff

The type keyword gives a name to any type — a primitive, a union, an object shape, a function signature, anything the type system can express. It does not create a new type, just a shorter name for an existing one, which is why two variables with the aliased type and the type it points to are completely interchangeable.

Type alias

A name, declared with type, that stands in for another type. Purely a compile-time convenience.

Union type

A type built with | meaning "one of these": string | number is a string or a number, never both at once.

An enum gives a name to a fixed set of related constants. Unlike an interface or a type alias, an enum is not erased — it compiles down to a real JavaScript object that exists at runtime. There are two flavours: a numeric enum, where members default to 0, 1, 2, …, and a string enum, where every member must have its own explicit string value.