DEVPREP CODEX · #26

TypeScript Interview Questions

171 curated questions graded from Foundations (Easy) to Practical Patterns (Medium) and Internals & Architecture (Hard).

TOTAL QUESTIONS

171

THEORY QUESTIONS

150

IMPLEMENTATION FOLIOS

FREE QUESTIONS

5 / Level

Easy Level·57 Questions Total

Foundations & Core Concepts

Open Full Easy List

Q1What is TypeScript? Compare it with JavaScript.

Definition: TypeScript is a strongly typed, static superset of JavaScript developed by Microsoft. It compiles down to plain JavaScript.
Static Typing: Checks and validates types during compilation, whereas JavaScript resolves types dynamically at runtime.
Error Detection: Catches syntax and type-mismatch bugs in the IDE/compiler before execution.
Tooling: Provides superior IDE support (advanced autocomplete, safe refactoring, and parameter signatures).

Q2Compare dynamic, static, and structural typing.

Dynamic Typing (JS): Variable types are resolved at runtime. Variables can freely change types.
Static Typing (TS): Variable types are declared and enforced during compile-time. Re-assigning an incompatible type causes a compile error.
Structural Typing (TS): Types are compared based on their shape/structure rather than explicit nominal declarations (duck typing: "if it looks like a duck, it is a duck").

Q3Compare `any`, `unknown`, `never`, and `void` in TypeScript.

any: Turns off all compile-time type checking. Highly unsafe; permits accessing any property or calling any method.
unknown: Type-safe counterpart to any. Allows holding any value, but bars any operations (property access/calls) until the type is narrowed.
void: Indicates the complete absence of a return value (typically used for functions with side effects).
never: Represents values that will never occur (e.g., functions that throw errors or enter infinite loops).

Q4Compare Interfaces and Type Aliases.

Declaration Merging: Interfaces can be re-declared and automatically merge properties. Type Aliases throw "duplicate identifier" errors.
Extensibility: Interfaces extend other interfaces/types via extends. Type Aliases compose via intersection operators (&).
Capabilities: Type Aliases can describe unions, primitives, tuples, and mapped types directly. Interfaces are strictly limited to object/class shapes.

Q5What are Type Assertions? Why can they be dangerous?

Definition: Bypasses the compiler's automatic type inference, manually informing the compiler of a specific type (using value as Type or <Type>value).
Danger: Type assertions do not run runtime casting/conversions. If the runtime value does not match the asserted compile-time type, it can crash during execution with silent type mismatches.

52 More Easy Questions Locked

Unlock the complete TypeScript Easy question bank

Get instant access to all 57 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Medium Level·57 Questions Total

Mechanisms & Practical Patterns

Open Full Medium List

Q1Compare Index Signatures and Mapped Types.

Index Signatures ([key: string]: any): Define arbitrary properties on objects. Flexible, but cannot restrict keys to a specific finite union of literals.
Mapped Types ([K in Keys]: T): Use iteration to construct an object type based on a source union of keys. Allow dynamic property construction with full type safety.

Q2What are Discriminated Unions (Tagged Unions)? Why are they powerful?

Definition: A union of object types where each object has a common literal property (the "discriminated" tag).
```
type Shape = { kind: "circle"; radius: number } | { kind: "square"; side: number };
```
Power: Enables the compiler to perform complete, automatic type narrowing inside conditional or switch blocks based on checking the literal tag.

Q3How do Generics with defaults work?

Definition: Specifying a default fallback type inside generic parameters if no explicit type argument is passed during invocation.
```
interface Config<T = string> { value: T; }
```

Q4Compare `extends` in Type Aliases vs. Interfaces.

Interfaces: interface A extends B {} represents static OOP-style inheritance. If properties overlap with incompatible types, it throws a compile-time error.
Type Aliases: Used in Conditional Types (T extends U ? X : Y), checking if a type is assignable to/compatible with another structure. Highly dynamic.

Q5Explain Mapped Type modifiers (e.g., `-readonly` or `-?`).

Prefix Modifiers (+ or -): Modify existing property constraints during mapping.
- -readonly: Removes readonly from all properties.
- -?: Removes optionality, making all properties strictly required.

52 More Medium Questions Locked

Unlock the complete TypeScript Medium question bank

Get instant access to all 57 questions, in-depth model answers, code sandboxes, and all 27+ technologies for a single one-time payment.

Unlock All — One-time payment · Lifetime access

Hard Level·57 Questions Total

Internals & System Architecture

Open Full Hard List

Q1Detail Covariance, Contravariance, and Bivariance in TS. How does `strictFunctionTypes` affect them?

Covariance (Read-only / Output): Asserts that subtype relationship is preserved. If Dog extends Animal, then () => Dog is assignable to () => Animal.
Contravariance (Write-only / Input): Asserts that subtype relationship is reversed. If Dog extends Animal, then (a: Animal) => void is assignable to (d: Dog) => void (because the target function expects a Dog but can safely pass it to a handler expecting Animal).
Bivariance: Allows parameter assignability in both directions. Highly unsafe.
strictFunctionTypes: Disables bivariance checking for function arguments, forcing them to be checked contravariantly (methods, however, remain bivariant for OOP backwards compatibility).

Q2Explain Distributive Conditional Types. How do you disable this behavior?

Distribution: When checking a union type through a naked generic parameter (e.g., T extends any), the compiler evaluates the condition for each union member individually and unions the final results:
```
type Distribute<T> = T extends any ? T[] : never;
type Res = Distribute<string | number>; // string[] | number[]
```

Disabling: Wrap the parameter in a tuple [T]. This forces the compiler to treat the entire union as a single consolidated check:

type NonDistribute<T> = [T] extends [any] ? T[] : never;
type Res = NonDistribute<string | number>; // (string | number)[]

Q3How does TS compile deep type recursions? What is Tail-Call Optimization (TCO) for types?

Recursion Limits: TS enforces strict limits (typically 50-100 frames) to prevent compiler stack crashes.
Type TCO (TS 4.5+): Conditional types that are tail-recursive (where the recursive call is the direct, final output of a branch) are optimized under the hood. This increases recursion limits significantly (up to ~1000 frames) enabling complex compile-time parsers and state engines.

Q4Explain Branded / Opaque Types. How are they constructed?

Definition: Simulates nominal typing. Differentiates structurally identical primitives (e.g., UserId and ProductId are both strings but must not be interchangeable).

Construction: Intersect the primitive type with a unique, nominal literal branding tag object:

type Brand<T, B> = T & { readonly __brand: B };
type UserId = Brand<string, "UserId">;

Q5Name the compiler flags triggered by the `strict` suite.

noImplicitAny: Throws error on un-inferred implicit any variables.
strictNullChecks: Disallows assignment of null or undefined to non-nullable variables.
strictFunctionTypes: Enforces contravariant checks on function arguments.
strictBindCallApply: Validates function arguments during .bind(), .call(), and .apply().
strictPropertyInitialization: Verifies class properties are initialized in the constructor.
noImplicitThis: Enforces explicit typing of the this context inside functions.
useUnknownInCatchVariables: Forces catch block error parameters to default to unknown instead of any.