TypeScript Cheat Sheet

npx tsc --init

# Create a starter tsconfig.json in the current project.

npx tsc --version

# Print the installed TypeScript compiler version.

npx tsc --noEmit

# Run the compiler only for type-checking.

npx tsc --watch

# Rebuild automatically when files change.

npx tsc -p tsconfig.json

# Use a given tsconfig path.

npx tsc --build

# Use build mode for multi-project repos.

npx tsc --explainFiles

# Show why files are part of the compilation.

npx tsc --traceResolution

# Print how imports are resolved.

const appName: string = "CheatSheet";
const port: number = 3000;
const isProd: boolean = false;

# Explicitly type strings, numbers, and booleans.

const ids: number[] = [1, 2, 3];
const names: Array<string> = ["Ada", "Linus"];

# Declare arrays using `T[]` or `Array<T>`.

const user: { id: number; name: string; admin?: boolean } = {
  id: 1,
  name: "Ada"
};

# Describe the expected properties of an object.

let value: string | number;
value = "ok";
value = 42;

# Allow multiple possible primitive types.

type Theme = "light" | "dark" | "system";
const theme: Theme = "dark";

# Use exact string values for safer APIs.

const count = 10;      // number
const title = "Hello"; // string

# Let TypeScript infer common variable types.

const statusMap = {
  ok: 200,
  notFound: 404,
} as const;

# Preserve readonly literal values for objects and arrays.

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

# Use an interface to model a reusable object shape.

type UserId = string | number;
type Point = { x: number; y: number };

# Use a type alias for unions, objects, tuples, or helpers.

interface Person {
  name: string;
}

interface Employee extends Person {
  team: string;
}

# Compose interfaces with inheritance.

type Audit = { createdAt: Date };
type Customer = { id: string; name: string };

type AuditedCustomer = Customer & Audit;

# Merge multiple types into one.

type Config = {
  readonly apiBaseUrl: string;
  readonly retries: number;
};

# Prevent mutation through the type system.

type StringMap = {
  [key: string]: string;
};

# Type dictionary-like objects with dynamic keys.

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

# Model a fixed-size array with known positions.

type HttpResponse = [status: number, body: string];

# Improve tuple readability with labels.

enum Direction {
  Up,
  Down,
  Left,
  Right,
}

# Declare a group of related named constants.

enum Status {
  Draft = "draft",
  Published = "published",
}

# Give enum members stable string values.