TypeScript Quick Reference

let name: string = "Ada";
let age: number = 36;
let active: boolean = true;

let nums: number[] = [1, 2];

let names: Array<string> = [];

let point: [number, number] = [4, 5];

let data: unknown = JSON.parse(text);

let loose: any;  // avoid

let dir: "left" | "right" = "left";

let email: string | null = null;

const total = 10;  // inferred as 10 (number)

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

interface User {
  readonly id: number;
  name: string;
}

interface Admin extends User {
  permissions: string[];
}

type Admin = User & { permissions: string[] };

type Scores = { [player: string]: number };

const scores: Record<string, number> = {};

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

const add = (a: number, b: number): number => a + b;

function greet(name?: string) { }

function greet(name = "world") { }

type Handler = (event: MouseEvent) => void;

function log(msg: string): void { }

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

function parse(x: string): number;
function parse(x: number): string;
function parse(x: string | number) { /* ... */ }

type Id = string | number;

if (typeof id === "string") {
  id.toUpperCase();
}

if ("permissions" in user) { }

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; size: number };

switch (shape.kind) {
  case "circle": return Math.PI * shape.radius ** 2;
  case "square": return shape.size ** 2;
}

function isString(x: unknown): x is string {
  return typeof x === "string";
}

document.getElementById("app")!

const input = el as HTMLInputElement;

function first<T>(items: T[]): T | undefined {
  return items[0];
}

type ApiResponse<T> = { data: T; error?: string };

function len<T extends { length: number }>(x: T) {
  return x.length;
}

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

class Box<T> {
  constructor(public value: T) {}
}

Partial<User>

Required<User>

Readonly<User>

Pick<User, "id" | "name">

Omit<User, "email">

ReturnType<typeof load>

Parameters<typeof add>

Awaited<ReturnType<typeof load>>

NonNullable<string | null>

type Config = typeof config;

const roles = ["admin", "user"] as const;
type Role = (typeof roles)[number];

const config = { port: 3000 } satisfies Config;

class Account {
  private balance = 0;
  constructor(public owner: string) {}
}

class Dog implements Animal { }

abstract class Shape {
  abstract area(): number;
}

enum Status {
  Active = "active",
  Disabled = "disabled",
}

type Status = "active" | "disabled";

npm install --save-dev typescript

npx tsc --init

npx tsc --noEmit

"compilerOptions": { "strict": true }

node --experimental-strip-types app.ts

// @ts-expect-error  (fails if there's no error)