🔷 TypeScript Cheat Sheet

let name: string = "Alice";

let age: number = 30;

let active: boolean = true;

let items: string[] = ["a", "b"];

let tuple: [string, number] = ["a", 1];

let id: string | number = "abc";

let anything: any = 42;

let unknown: unknown = getData();

let nothing: void = undefined;

let nope: never = (() => { throw Error(); })();

let sym: symbol = Symbol("id");

let big: bigint = 100n;

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

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

interface StringMap {
  [key: string]: string;
}

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

type ID = string | number;

type Status = "active" | "inactive" | "banned";

interface Animal { name: string; }
interface Dog extends Animal { breed: string; }

type Admin = User & { role: string };

interface Clickable {
  onClick(event: MouseEvent): void;
}

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

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

function log(msg: string, level?: string): void {}

function create(name: string, age: number = 25) {}

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

function parse(input: string): number;
function parse(input: number): string;
function parse(input: any): any { /*...*/ }

type Callback = (data: string) => void;

const fn: (x: number) => boolean = x => x > 0;

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

const identity = <T>(arg: T): T => arg;

interface Box<T> { value: T; }

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

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

function merge<T, U>(a: T, b: U): T & U {
  return { ...a, ...b };
}

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

type Nullable<T> = T | null;

Partial<User>

Required<User>

Readonly<User>

Pick<User, 'name' | 'email'>

Omit<User, 'password'>

Record<string, number>

Exclude<'a' | 'b' | 'c', 'a'>

Extract<'a' | 'b' | 'c', 'a' | 'b'>

NonNullable<string | null | undefined>

ReturnType<typeof myFunc>

Parameters<typeof myFunc>

Awaited<Promise<string>>

class Animal {
  constructor(
    public name: string,
    private age: number,
    protected sound: string
  ) {}
}

class Dog extends Animal {
  constructor(name: string, public breed: string) {
    super(name, 0, 'woof');
  }
}

abstract class Shape {
  abstract area(): number;
  describe() { return `Area: ${this.area()}`; }
}

class Singleton {
  private static instance: Singleton;
  private constructor() {}
  static getInstance() {
    return this.instance ??= new Singleton();
  }
}

class Logger implements ILogger {
  log(msg: string) { console.log(msg); }
}

class Config {
  #secret = 'hidden';  // ES private
  private key = 'also private';  // TS private
}

enum Direction {
  Up,     // 0
  Down,   // 1
  Left,   // 2
  Right   // 3
}

enum Color {
  Red = '#ff0000',
  Green = '#00ff00',
  Blue = '#0000ff'
}

const enum Status {
  Active = 1,
  Inactive = 0
}

const Direction = {
  Up: 'UP',
  Down: 'DOWN'
} as const;
type Direction = typeof Direction[keyof typeof Direction];

if (typeof x === 'string') {
  x.toUpperCase(); // x is string
}

if (x instanceof Date) {
  x.getTime(); // x is Date
}

if ('name' in obj) {
  obj.name; // narrowed
}

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

function assertDefined<T>(val: T): asserts val is NonNullable<T> {
  if (val == null) throw Error('Undefined!');
}

type Shape = Circle | Square;
switch (shape.kind) {
  case 'circle': /* Circle */ break;
  case 'square': /* Square */ break;
}

type Optional<T> = {
  [K in keyof T]?: T[K];
};

type Immutable<T> = {
  readonly [K in keyof T]: T[K];
};

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type IsString<T> = T extends string ? true : false;

type Flatten<T> = T extends Array<infer U> ? U : T;

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object
    ? DeepReadonly<T[K]>
    : T[K];
};

async function fetchUser(id: number): Promise<User> {
  const res = await fetch(`/api/users/${id}`);
  return res.json();
}

const fetchAll = async <T>(urls: string[]): Promise<T[]> => {
  return Promise.all(urls.map(u => fetch(u).then(r => r.json())));
};

type AsyncFn<T> = () => Promise<T>;

interface ApiResponse<T> {
  data: T;
  error?: string;
  status: number;
}

async function safeFetch<T>(url: string): Promise<T | null> {
  try {
    const res = await fetch(url);
    if (!res.ok) return null;
    return res.json();
  } catch { return null; }
}

export interface Config { port: number; }

export default class App {}

export type { User };  // type-only export

import type { Config } from './config';

import { type User, createUser } from './user';

declare module '*.css' {
  const styles: Record<string, string>;
  export default styles;
}

declare global {
  interface Window { analytics: Analytics; }
}

// tsconfig.json essentials
{
  "strict": true,
  "target": "ES2022",
  "module": "ESNext",
  "moduleResolution": "bundler"
}

// Enable decorators
{
  "experimentalDecorators": true,
  "emitDecoratorMetadata": true
}

function Log(target: any, key: string, desc: PropertyDescriptor) {
  const orig = desc.value;
  desc.value = function(...args: any[]) {
    console.log(`${key} called`);
    return orig.apply(this, args);
  };
}

// Path aliases in tsconfig
{
  "paths": {
    "@/*": ["./src/*"],
    "@utils/*": ["./src/utils/*"]
  }
}