Question 1

How do you make values immutable in TypeScript?

Accepted Answer

Use the **`readonly`** modifier on properties or `ReadonlyArray`, and `Readonly` for whole objects. **`as const`** freezes a literal to its narrowest readonly type (great for tuples and config). These are compile-time guarantees, not runtime freezes.

Question 2

How do you do exhaustiveness checking?

Accepted Answer

In a `switch` over a discriminated union, add a `default` that assigns the value to a `never` variable: `const _exhaustive: never = value`. If you add a new variant and forget a case, the compiler errors — catching missed handling.

Question 3

What is the difference between interface and type?

Accepted Answer

Both describe object shapes. **`interface`** is extendable and supports declaration merging — ideal for public/object APIs. **`type`** is more flexible: it can alias unions, intersections, primitives, tuples, and mapped types. Use `interface` for objects you may extend, `type` for unions and computed types.

Question 4

What is the difference between any and unknown?

Accepted Answer

**`any`** opts out of type checking entirely — anything goes. **`unknown`** is the type-safe counterpart: you can assign anything to it, but you must narrow it (via `typeof`, checks, or assertions) before using it. Prefer `unknown` to keep type safety.

Question 5

What is TypeScript and why use it over JavaScript?

Accepted Answer

**TypeScript** is a typed superset of JavaScript that compiles to plain JS. It adds static types, interfaces, generics, and enums — catching errors at compile time, improving editor autocomplete and refactoring, and making large codebases easier to maintain. All valid JS is valid TS.

Question 6

What are tuple types?

Accepted Answer

A **tuple** is a fixed-length array with known types per position: `[string, number]`. They support optional/rest elements and labels, and are used for things like coordinate pairs or React's `useState` return.

Question 7

How do you safely work with JSON of unknown shape?

Accepted Answer

Type parsed JSON as **`unknown`**, then validate/narrow before use — either with manual type guards or a schema library (e.g. Zod) that both validates at runtime and infers the static type, avoiding unsafe `any`.

Question 8

What are literal types?

Accepted Answer

**Literal types** restrict a value to a specific constant — `type Dir = 'left' | 'right'` or `type One = 1`. Combined into unions they model finite sets of allowed values, safer than plain `string`/`number`.

Question 9

How does TypeScript handle null and undefined safely?

Accepted Answer

With **`strictNullChecks`**, `null`/`undefined` aren't assignable to other types unless explicitly allowed (`string | null`). **Optional chaining** `a?.b` short-circuits on nullish values, and **nullish coalescing** `a ?? b` provides a fallback only for `null`/`undefined`.

Question 10

What are access modifiers in TypeScript classes?

Accepted Answer

**public** (default) is accessible everywhere, **private** only within the class, **protected** within the class and subclasses, and **readonly** prevents reassignment after init. TS also supports JS native `#private` fields with true runtime privacy.

TypeScript Interview Library

Question Catalog

How do you make values immutable in TypeScript?

How do you do exhaustiveness checking?

What is the difference between interface and type?

What is the difference between any and unknown?

What is TypeScript and why use it over JavaScript?

What are tuple types?

How do you safely work with JSON of unknown shape?

What are literal types?

How does TypeScript handle null and undefined safely?

What are access modifiers in TypeScript classes?

What is the definite assignment assertion (!)?

What is type narrowing and what are type guards?

What are generic constraints?

What are union and intersection types?

What do ReturnType and Parameters do?

What are generics and why are they useful?

What is ReadonlyArray and readonly tuple?

What are type assertions and when should you use them?

What are abstract classes?

What is declaration merging?

What does the declare keyword do?

How does the 'in' operator narrow types?

What do Exclude, Extract, and NonNullable do?

What are utility types like Partial, Pick, and Omit?

What does the 'strict' flag in tsconfig enable?

What is a discriminated union?

What is an index signature?

Can generics have default types?

What is structural typing?

How do you get a union of an object's values as a type?

What is the Awaited utility type?

What do keyof and typeof do in TypeScript?

What is the never type?

What are assertion functions (asserts)?

What is key remapping in mapped types?

What are enums and what are their trade-offs?

What are mapped types?

How would you build a DeepPartial type?

What are indexed access types?

What are declaration files (.d.ts)?

What are template literal types?

What is module augmentation?

What are recursive types?

What does the infer keyword do?

What are function overloads?

What is a polymorphic 'this' type?

What are covariance and contravariance?

What are conditional types?

What does the satisfies operator do?

What are branded (nominal) types?

Difficulty Distribution

Tested Topics

Study Guide