TypeScript Cheat Sheet

let name: string = "TypeScript";
let age: number = 30;

let isDone: boolean = false;
let total: number = 100;
let greeting: string = "Hello";

let numbers: number[] = [1, 2, 3];
let tuple: [string, number] = ["age", 30];

enum Direction {
  Up,
  Down,
  Left,
  Right
}

let anything: any = 5;
let maybe: unknown = "unknown";
function fail(): never {
  throw new Error("Error!");
}
function log(): void {
  console.log("logging");
}

Types are inferred automatically if not explicitly annotated.

let greeting = "hello"; // inferred as string

function greet(name: string): string {
  return `Hello, ${name}`;
}

function log(message: string, level: string = "info") {
  console.log(`[${level}] ${message}`);
}

function print(name?: string) {
  console.log(name ?? "Anonymous");
}

function sum(...numbers: number[]): number {
  return numbers.reduce((a, b) => a + b, 0);
}

function reverse(x: string): string;
function reverse(x: number): number;
function reverse(x: string | number): string | number {
  if (typeof x === "string") {
    return x.split('').reverse().join('');
  }
  return Number(x.toString().split('').reverse().join(''));
}

let user: { name: string; age: number } = {
  name: "Alice",
  age: 25
};

interface Person {
  name: string;
  age: number;
}

interface Car {
  readonly vin: string;
  model?: string;
}

interface Animal {
  name: string;
}

interface Dog extends Animal {
  breed: string;
}

type A = { a: number };
type B = { b: string };
type C = A & B;

let obj: C = { a: 1, b: "test" };

let value: string | number = "text";

class Point {
  x: number;
  y: number;

  constructor(x: number, y: number) {
    this.x = x;
    this.y = y;
  }

  move(dx: number, dy: number) {
    this.x += dx;
    this.y += dy;
  }
}

class Employee {
  public name: string;
  private salary: number;
  protected department: string;

  constructor(name: string, salary: number, department: string) {
    this.name = name;
    this.salary = salary;
    this.department = department;
  }
}

class Book {
  readonly isbn: string;

  constructor(isbn: string) {
    this.isbn = isbn;
  }
}

class Animal {
  speak() {
    console.log("Animal speaks");
  }
}

class Cat extends Animal {
  speak() {
    console.log("Meow");
  }
}

interface Shape {
  area(): number;
}

class Circle implements Shape {
  constructor(private radius: number) {}
  area(): number {
    return Math.PI * this.radius ** 2;
  }
}

type ID = string | number;

type Direction = "up" | "down";

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

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

let input = document.getElementById("input") as HTMLInputElement;

let value: string | null = getValue();
console.log(value!.length);

type Person = { name: string; age: number };
type NameType = Person["name"];

type Keys = keyof Person;
const person = { name: "Alex", age: 20 };
type PersonType = typeof person;

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

interface Box {
  value: T;
}

function logLength(arg: T): void {
  console.log(arg.length);
}

interface Response {
  data: T;
}

type User = {
  name: string;
  age: number;
};

Partial
Required
Readonly
Pick
Omit
Record
ReturnType<() => string>
Parameters<(a: number) => void>

// math.ts
export function add(x: number, y: number): number {
  return x + y;
}

// main.ts
import { add } from './math';

declare module "express" {
  interface Request {
    user?: User;
  }
}

declare var myGlobal: string;

namespace MathUtils {
  export function square(x: number): number {
    return x * x;
  }
}

{
  "compilerOptions": {
    "target": "es6",
    "strict": true,
    "module": "commonjs"
  }
}

declare module "my-lib" {
  export function greet(name: string): void;
}

npm install --save-dev @types/lodash

Enable options like strictNullChecks, noImplicitAny to enforce strict typing rules.

declare function require(moduleName: string): any;

Use type declarations via @types packages or write your own .d.ts files.

Use import/export for ES Modules and require/module.exports for CommonJS compatibility.

function sealed(constructor: Function) {
  Object.seal(constructor);
  Object.seal(constructor.prototype);
}

type ReadonlyUser = {
  readonly [P in keyof T]: T[P];
};

type IsString = T extends string ? true : false;

type ReturnType = T extends (...args: any[]) => infer R ? R : never;