TypeScript

TypeScript is a statically-typed superset of JavaScript that compiles to plain JavaScript. It adds optional type annotations, interfaces, and compile-time type checking.

Benefits:

• Catches errors at compile time (before runtime)
• Better IDE support (autocompletion, refactoring)
• Self-documenting code through types
• Safer refactoring in large codebases

• any: Disables type checking entirely. Anything goes—avoid when possible.
• unknown: The type-safe counterpart to any. You must narrow/check the type before using it.
• never: Represents values that never occur (e.g., a function that always throws or has an infinite loop).

Both define object shapes, but:

Rule of thumb: Use interface for object shapes (especially public APIs). Use type for unions, primitives, or complex type expressions.

TypeScript automatically infers types when you don't explicitly annotate them.

Inference reduces boilerplate while still providing type safety.

Types that represent exact values, not just general types.

Literal types are the building blocks of discriminated unions.

A fixed-length array where each element has a specific type.

Enums define a set of named constants.

Caution: Numeric enums create runtime code. Consider using as const objects or union types as lighter alternatives:

• undefined: Variable declared but not assigned; default for optional properties.
• null: Explicitly assigned "no value."

With strictNullChecks enabled, both are separate types and not assignable to other types without explicit checks.

Generics allow you to write reusable, type-safe code that works with multiple types.

Without generics, you'd have to use any (losing type safety) or write duplicate functions for each type.

Using extends to limit what types a generic can accept.

Used inside conditional types to extract/infer a type from another type.

infer R captures the return type and makes it available as R.

Creates a union type of all property keys of a type.

Often used with generics to create type-safe property access.

Extracts the type from a value (different from JavaScript's runtime typeof).

The process of refining a variable's type within a conditional block using control flow analysis.

A function that performs a runtime check and tells TypeScript the type within that scope.

The value is string return type is the type predicate.

A pattern where each member of a union has a common literal property (the "discriminant") that TypeScript uses to narrow the type.

Checks if a property exists in an object, narrowing the type accordingly.

Built-in generic types that transform other types.

• const: Prevents reassignment of a variable, but object properties can still be mutated.
• Readonly<T>: Makes all properties of an object immutable at the type level.

Tells TypeScript to infer the narrowest possible type (literal types, readonly arrays/objects).

Types that iterate over keys of another type to create a new type.

You can also remap keys:

Types that choose between two options based on a condition.

Types that use string template syntax to create new string literal types.

Useful for typing string patterns (CSS units, event handlers, routes).

Defines the type for dynamic property names.

Validates that a value conforms to a type while preserving the narrowest inferred type.

Without satisfies, using a type annotation would widen the types.

Defining multiple function signatures for different parameter types.

The implementation signature is not visible to callers—only the overload signatures.

Note: These are compile-time only. At runtime, all properties are accessible (use # for true private fields).

Classes that cannot be instantiated directly—only extended. They can contain abstract methods that subclasses must implement.

When TypeScript combines multiple declarations with the same name into one.

This is why interface is preferred for public APIs—consumers can extend them.

A compiler flag that enables a set of strict type-checking options:

• strictNullChecks: null/undefined are not assignable to other types
• noImplicitAny: Error when type is implicitly any
• strictFunctionTypes: Stricter function type checking
• strictBindCallApply: Check bind, call, apply methods
• strictPropertyInitialization: Class properties must be initialized

Best practice: Always enable strict: true in new projects for maximum type safety.

Decorators are special declarations that can be attached to classes, methods, properties, or parameters to modify their behavior. They use the @expression syntax.

Note: Decorators require experimentalDecorators: true in tsconfig. TypeScript 5.0+ also supports the new TC39 standard decorators.

Extending existing modules or libraries with additional type declarations without modifying the original source.

Useful for adding custom properties to third-party library types.

A function that throws an error if a condition is not met, and tells TypeScript to narrow the type after the call.

A pattern to create distinct types that are structurally identical but treated as different by TypeScript.

Prevents accidentally mixing semantically different values.

How subtype relationships work in generic types:

• Covariance: If Dog extends Animal, then Array<Dog> is assignable to Array<Animal>. (Output positions)
• Contravariance: Function parameters work in reverse—(animal: Animal) => void is assignable to (dog: Dog) => void. (Input positions)

Understanding this helps when you get unexpected type errors with callbacks.

When enabled, accessing an array or object by index includes undefined in the type.

This catches potential "index out of bounds" bugs at compile time.

A declaration file that contains only type information (no runtime code). Used to:

• Provide types for JavaScript libraries
• Separate type definitions from implementation
• Describe the shape of external modules

• import type: Imports only types; completely erased at runtime. Ensures no runtime dependency on the module.
• Regular import: Imports values and/or types; may include runtime code.

Use import type when you only need types to reduce bundle size and avoid circular dependency issues.

You can explicitly type this as the first parameter in a function (it's erased at runtime).

Both filter union types:

• Exclude<T, U>: Removes types from T that are assignable to U.
• Extract<T, U>: Keeps only types from T that are assignable to U.