TypeScript Essential Cheat Sheet

// Basic class
class User {
  // Property with type
  id: number;
  name: string;
  email: string;
  
  // Constructor
  constructor(id: number, name: string, email: string) {
    this.id = id;
    this.name = name;
    this.email = email;
  }
  
  // Method
  greet(): string {
    return `Hello, ${this.name}!`;
  }
}

// Parameter properties (shorthand)
class Profile {
  constructor(
    public id: number,
    public name: string,
    private email: string,
    readonly createdAt: Date
  ) {}
}

// Visibility modifiers
class Config {
  public setting: string = 'default'; // Accessible everywhere
  protected secret: string = 'hidden'; // In class and subclasses
  private apiKey: string = 'secret'; // Only in this class
  readonly version: string = '1.0'; // Can't be changed
}

// Abstract class
abstract class Animal {
  abstract makeSound(): void;
  
  move(): void {
    console.log('Moving...');
  }
}

class Dog extends Animal {
  makeSound(): void {
    console.log('Woof!');
  }
}

// Getters and setters
class Account {
  private _balance: number = 0;
  
  get balance(): number {
    return this._balance;
  }
  
  set balance(amount: number) {
    if (amount >= 0) {
      this._balance = amount;
    }
  }
}

// Static members
class Math {
  static PI = 3.14159;
  
  static add(a: number, b: number): number {
    return a + b;
  }
}

console.log(Math.PI);
console.log(Math.add(5, 3));

// Intersection type (&)
interface Named {
  name: string;
}

interface Aged {
  age: number;
}

type Person = Named & Aged;
const person: Person = {
  name: 'John',
  age: 30
};

// Utility types - Partial
interface User {
  id: number;
  name: string;
  email: string;
}

type PartialUser = Partial<User>;
const update: PartialUser = { name: 'Jane' };

// Readonly
type ReadonlyUser = Readonly<User>;
const frozen: ReadonlyUser = {
  id: 1,
  name: 'John',
  email: 'john@example.com'
};
// frozen.name = 'Jane'; // Error!

// Pick - select properties
type UserPreview = Pick<User, 'id' | 'name'>;

// Omit - exclude properties
type UserWithoutEmail = Omit<User, 'email'>;

// Record - create object with specific keys
type Status = 'active' | 'inactive';
const statusConfig: Record<Status, string> = {
  active: 'User is active',
  inactive: 'User is inactive'
};

// Exclude - remove from union
type NonString = Exclude<string | number | boolean, string>;
// NonString = number | boolean

// Extract - select from union
type StringOrNumber = Extract<string | number | boolean, string | number>;
// StringOrNumber = string | number

// NonNullable - remove null/undefined
type Nullable<T> = T | null | undefined;
type NonNull<T> = NonNullable<Nullable<T>>;

// ReturnType - get return type
type MyFunc = () => string;
type FuncReturn = ReturnType<MyFunc>; // string

// InstanceType - get instance type
type MyClass = new () => User;
type UserInstance = InstanceType<MyClass>; // User

// typeof guard
function process(value: string | number): string {
  if (typeof value === 'string') {
    return value.toUpperCase();
  }
  return (value * 2).toString();
}

// instanceof guard
class User {}
class Admin extends User {}

function handleUser(user: User | Admin) {
  if (user instanceof Admin) {
    user.permissions; // Admin properties
  }
}

// Custom type guard (type predicate)
interface Car {
  wheels: 4;
  drive(): void;
}

interface Bike {
  wheels: 2;
  pedal(): void;
}

function isCar(vehicle: Car | Bike): vehicle is Car {
  return (vehicle as Car).drive !== undefined;
}

const vehicle: Car | Bike = getCar();
if (isCar(vehicle)) {
  vehicle.drive(); // TypeScript knows it's a Car
}

// Property checking
type Admin = { role: 'admin'; deleteUser(): void };
type User = { role: 'user' };

function handleRole(user: Admin | User) {
  if ('deleteUser' in user) {
    user.deleteUser();
  }
}

// Discriminated union
type Result = 
  | { status: 'success'; data: any }
  | { status: 'error'; error: string };

function handle(result: Result) {
  switch (result.status) {
    case 'success':
      console.log(result.data);
      break;
    case 'error':
      console.log(result.error);
      break;
  }
}

// is operator (type assertion guard)
const value: string | number = '42';
if (typeof value === 'string' && value.includes('4')) {
  console.log('Contains 4');
}

// Function signature (no implementation)
declare function greet(name: string): string;

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

// Overloading (multiple signatures)
function format(date: Date): string;
function format(date: Date, format: string): string;
function format(date: Date, format?: string): string {
  if (format) {
    return date.toString(); // Use format
  }
  return date.toString();
}

format(new Date()); // Works
format(new Date(), 'yyyy-MM-dd'); // Works

// Function with this context
interface Button {
  text: string;
  onClick(this: Button, e: Event): void;
}

// Generic function signature
interface Observer<T> {
  onNext(value: T): void;
  onError(error: Error): void;
  onComplete(): void;
}

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

// Variadic tuple parameters
type StringNumberBooleans = [string, number, ...boolean[]];
type StringBooleansNumber = [string, ...boolean[], number];

function f1(...args: StringNumberBooleans) {
  // args: [string, number, ...boolean[]]
}

// Function type expression
type Fn = (a: string) => number;
const fn: Fn = (str) => str.length;

// Construct signature
type Constructor<T> = {
  new(...args: any[]): T;
};

// Show inferred type
const x = 42;
type X = typeof x; // number

// Hover over variable in VS Code to see type
const user = { name: 'John', age: 30 };
// Shows: { name: string; age: number; }

// Use conditional to test types
type Test = string extends string ? true : false;
// Hover shows: true

// Check if type is assignable
const test: string = 123; // Error (red squiggly)

// Use keyof to debug object types
interface User {
  name: string;
  age: number;
}

type Keys = keyof User; // 'name' | 'age'

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

type Test = Getters<User>;
// Shows: {
//   getName: () => string;
//   getAge: () => number;
// }

// Print types in errors (trick)
type Print<T> = T extends never ? 'T is never' : T;

// Use satisfies operator (TS 4.9+)
const config = {
  apiUrl: 'https://example.com'
} satisfies Record<string, string>;

// Show type in error message
type ShowType<T> = T & { __type: T };

// Enable diagnostics
// tsc --diagnostics --listFilesOnly