TypeScript Cheatsheet

Primitives

let name: string = "Alice";
let age: number = 30;
let active: boolean = true;

Arrays

let nums: number[] = [1, 2, 3];
let strs: Array<string> = ["a", "b"];

Tuple

let pair: [string, number] = ["Alice", 30];

Union

let id: string | number;

Literal

let dir: "left" | "right" | "up" | "down";

any / unknown / never

let x: any;
let y: unknown;
function fail(): never { throw new Error(); }

Interface

interface User {
  id: number;
  name: string;
  email?: string; // optional
}

Type alias

type Point = {
  x: number;
  y: number;
};

Extending interface

interface Admin extends User {
  role: "admin";
}

Intersection type

type AdminUser = User & { role: "admin" };

Readonly

interface Config {
  readonly apiKey: string;
}

Typed function

function add(a: number, b: number): number {
  return a + b;
}

Arrow function type

const greet: (name: string) => string = (name) => `Hi ${name}`;

Optional & default params

function log(msg: string, level?: string) { ... }
function repeat(s: string, n: number = 1) { ... }

Overloads

function process(x: string): string;
function process(x: number): number;
function process(x: any): any { return x; }

Generic function

function identity<T>(arg: T): T {
  return arg;
}

Generic interface

interface ApiResponse<T> {
  data: T;
  error: string | null;
}

Constrained generic

function getLength<T extends { length: number }>(arg: T): number {
  return arg.length;
}

keyof constraint

function getField<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

Partial<T>

type PartialUser = Partial<User>;
// All fields optional

Required<T>

type RequiredUser = Required<User>;
// All fields required

Pick<T, K>

type UserPreview = Pick<User, "id" | "name">;

Omit<T, K>

type UserWithoutEmail = Omit<User, "email">;

Record<K, V>

type Scores = Record<string, number>;

Readonly<T>

const config: Readonly<Config> = { apiKey: "abc" };

ReturnType<T>

type R = ReturnType<typeof fetchUser>; // inferred return type

NonNullable<T>

type Safe = NonNullable<string | null | undefined>; // string

typeof guard

if (typeof value === "string") { ... }

instanceof guard

if (error instanceof Error) { console.log(error.message); }

in operator

if ("email" in user) { ... }

Custom type guard

function isUser(x: unknown): x is User {
  return typeof x === "object" && x !== null && "id" in x;
}

as const

const ROLES = ["admin", "user", "guest"] as const;
type Role = typeof ROLES[number];