TypeScript Classes and Modules

class User {
  constructor(public id: number, public name: string) {}
}

# Type instance fields and constructor parameters.

class Counter {
  private value = 0;

  increment() {
    this.value += 1;
  }
}

# Control visibility with `public`, `private`, and `protected`.

class Config {
  readonly env: string;

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

# Prevent reassignment after construction.

class Animal {
  move() {
    return "moving";
  }
}

class Bird extends Animal {
  fly() {
    return "flying";
  }
}

# Reuse behavior with inheritance.

abstract class Repository<T> {
  abstract findById(id: string): T | undefined;
}

# Require derived classes to implement specific methods.

class Temperature {
  private celsius = 0;

  get fahrenheit() {
    return this.celsius * 1.8 + 32;
  }

  set fahrenheit(value: number) {
    this.celsius = (value - 32) / 1.8;
  }
}

# Wrap computed or validated access around fields.

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

export const APP_NAME = "CheatSheet";

# Export multiple values from a module.

export default function formatCurrency(value: number) {
  return `$${value.toFixed(2)}`;
}

# Export one primary value from a module.

import type { User } from "./types";

# Import a type without generating runtime usage.

export { add, subtract } from "./math";
export type { MathOptions } from "./types";

# Create barrel files or focused module facades.

const module = await import("./heavy-module");

# Load a module asynchronously at runtime.

const raw: unknown = JSON.parse(payload);

# Treat external JSON as unsafe until validated.

try {
  riskyWork();
} catch (error: unknown) {
  if (error instanceof Error) {
    console.error(error.message);
  }
}

# Handle `unknown` errors in catch blocks safely.