Question 1

What is TypeScript and how does it benefit JavaScript developers?

Accepted Answer

TypeScript is a strongly typed superset of JavaScript that compiles down to clean, plain JavaScript. It benefits developers by adding static typing, allowing type-related errors to be caught at compile time (during code editing) rather than at runtime. It also enhances the developer experience with robust IDE autocompletion, refactoring tools, and clear API self-documentation.

Question 2

Explain the differences between Interface and Type in TypeScript.

Accepted Answer

Both declare custom object structures, but they have key differences:
1. Interfaces support declaration merging (declaring the same interface twice merges their fields), whereas Types cannot be redeclared.
2. Types support union and intersection operations: `type ID = string | number`. Interfaces are preferred for standard object declarations, and Types for complex structures.

Question 3

What is type inference in TypeScript?

Accepted Answer

Type inference is TypeScript's ability to deduce the type of a variable automatically based on its initial value, without requiring explicit type annotations. For example, if you write `let x = 5`, TypeScript automatically infers that `x` is a `number`.

Question 4

What is the 'any' type, and why should it be avoided?

Accepted Answer

The `any` type disables type checking for a variable, instructing TypeScript to allow any operations on it. Using `any` defeats the purpose of TypeScript, exposing the application to runtime type crashes. Use `unknown` instead when handling dynamic variables.

Question 5

What is the difference between 'unknown' and 'any'?

Accepted Answer

Both represent values of any type. However, `any` is completely unchecked, while `unknown` is safe. You cannot perform operations on an `unknown` variable (like accessing attributes or invoking it) without first narrowing its type using type guards or assertions.

Question 6

Explain Union types and Intersection types.

Accepted Answer

Union types (`A | B`) allow a variable to hold any one of several types. Intersection types (`A & B`) combine multiple type definitions into a single type containing all properties of the intersected types.

Question 7

What is the 'never' type in TypeScript and when is it used?

Accepted Answer

The `never` type represents values that will never occur. It is used to declare return types for functions that never return (e.g. infinite loops or functions that always throw errors) and for exhaustive checks in switch blocks.

Question 8

Explain Tuple types in TypeScript.

Accepted Answer

Tuples are arrays with a fixed number of elements, where the types of each element are known and ordered: `const coords: [number, number] = [40.7, -74.0]`. Attempting to insert a different type or wrong length throws errors.

Question 9

What are Enums in TypeScript and their compiler outputs?

Accepted Answer

Enums allow declaring named constants: `enum Status { Active, Inactive }`. By default, they compile to JavaScript objects supporting reverse lookups, unless declared as `const enum`, which has zero runtime footprint because it compiles to raw values.

Question 10

What is the purpose of the tsconfig.json file?

Accepted Answer

`tsconfig.json` is the configuration file for the TypeScript compiler (`tsc`). It specifies compiler options, directories to include or exclude, output directories, and type-checking rules (like `strict`).

Question 11

Explain optional properties and optional chaining in TypeScript.

Accepted Answer

Optional properties are defined using `?` in types: `interface User { age?: number }`. Optional chaining (`user?.profile?.name`) evaluates to `undefined` if any reference in the chain is nullish, preventing null pointer crashes.

Question 12

What are Type Assertions in TypeScript?

Accepted Answer

Type Assertions (`value as string` or `<string>value`) instruct the compiler to treat a variable as a specific type, overriding type inference. They do not perform any runtime checks or modifications.

Question 13

Explain read-only properties and Readonly utility types.

Accepted Answer

The `readonly` modifier makes object properties immutable after initialization: `interface Config { readonly port: number }`. The `Readonly<T>` utility type makes all properties of an object type read-only.

Question 14

What is the difference between void and never return types?

Accepted Answer

`void` means a function completes execution but returns no value (returns `undefined` implicitly). `never` means the function never completes execution (e.g., it crashes or loops infinitely).

Question 15

What are declaration files (.d.ts) in TypeScript?

Accepted Answer

Declaration files contain only type definitions and no runtime code. They are used to describe the shape of JavaScript code (like third-party npm modules) so TypeScript can provide compile-time checking for them.

Question 16

Explain string and numeric literal types.

Accepted Answer

Literal types restrict variables to exact values: `type Action = 'ADD' | 'REMOVE'`. A variable of type `Action` can only hold those exact strings, preventing typos.

Question 17

What is the 'as const' assertion?

Accepted Answer

The `as const` assertion creates a readonly literal type. It prevents widening of arrays and objects into generic types, making all nested properties readonly constants.

Question 18

Explain the non-null assertion operator (!).

Accepted Answer

The non-null assertion operator (`!`) tells the compiler that a variable is not `null` or `undefined`, overriding strict null check warnings. It should be used sparingly since it can hide runtime bugs.

Question 19

What is type widening in TypeScript?

Accepted Answer

Type widening is when TypeScript assigns a wider type to a variable than its literal value (e.g., inferring `let x = 'hello'` as `string` instead of `'hello'`), permitting reassignment to other strings.

Question 20

Explain how TypeScript compiles class property access modifiers.

Accepted Answer

TypeScript supports `public`, `private`, and `protected` modifiers. They restrict access during compilation, but compile down to standard JS classes where all fields are public, unless ES6 private fields (`#`) are used.

Question 21

Explain Generics in TypeScript and write a generic utility function.

Accepted Answer

Generics allow components and functions to work with multiple types rather than a single type, creating reusable code that maintains type safety. You pass the type parameter using angle brackets:
```typescript
function getFirstElement<T>(arr: T[]): T | undefined {
  return arr[0];
}
```
This ensures that if you pass an array of numbers, the return type is checked as a number, and if you pass strings, it is treated as a string.

Question 22

What are Type Guards in TypeScript? Write a custom type guard.

Accepted Answer

Type Guards narrow the type of a variable within a conditional block. A custom type guard uses a type predicate (`parameterName is Type`) as its return type:
```typescript
interface User { name: string; email: string }

function isUser(obj: any): obj is User {
  return obj && typeof obj.name === 'string' && typeof obj.email === 'string';
}
```
When called inside an `if` block, TypeScript automatically assumes the variable is a `User` inside that scope.

Question 23

Explain TypeScript Utility Types: Partial, Required, Pick, and Omit.

Accepted Answer

TypeScript includes built-in utility types to transform types: - `Partial` makes all properties of `T` optional. - `Required` makes all properties of `T` required. - `Pick` creates a type by selecting a specific set of keys `K` from `T`. - `Omit` creates a type by removing a specific set of keys `K` from `T`.

Question 24

What is mapped type in TypeScript? Write an example.

Accepted Answer

Mapped types allow you to create new types based on the properties of an existing type, iterating over keys using `keyof`:
```typescript
type ReadOnlyUser<T> = {
  readonly [P in keyof T]: T[P];
};
```
This maps over each key `P` in type `T` and appends the `readonly` flag.

Question 25

Explain index signatures and Record types.

Accepted Answer

Index signatures define type boundaries for objects where key names are unknown: `interface Settings { [key: string]: boolean }`. The `Record` utility is a shortcut for the same pattern: `const config: Record = { debug: true }`.

Question 26

Explain how to test TypeScript components using mock type interfaces.

Accepted Answer

In tests, you assert values against typed mock structures. Use utility types like `DeepPartial<T>` to create incomplete mocks of large interfaces without compiler errors, and check return structures against target signatures.

Question 27

What are index access types and keyof operations?

Accepted Answer

`keyof` extracts a union of keys from an object type: `type UserKeys = keyof User`. Index access types extract the type of a specific property: `type Age = User['age']`, which helps share nested type references.

Question 28

How does TypeScript perform type compatibility checks?

Accepted Answer

TypeScript uses structural typing (duck typing). Two types are compatible if they share the same structure, regardless of nominal declarations. If an object has all properties required by an interface, it is compatible.

Question 29

Explain how to debug TypeScript compilation speeds.

Accepted Answer

To profile slow builds, run compilation with `--diagnostics` or `--generateCpuProfile`. This outputs parser and checker durations, helping locate complex recursive types or excessive import paths.

Question 30

What are conditional types in TypeScript?

Accepted Answer

Conditional types select types based on a condition: `Type extends OtherType ? TrueType : FalseType`. They enable creating dynamic type mappings that resolve based on parameter types.

Question 31

Explain how to configure path aliases in tsconfig.json.

Accepted Answer

Set the `baseUrl` property and specify patterns under `paths`. This maps modules (e.g. `@services/*` to `./src/services/*`), keeping imports clean and independent of relative folder levels.

Question 32

What is the difference between type guard and type assertion?

Accepted Answer

A type guard performs checks at runtime to narrow types inside conditional blocks safely. A type assertion is a compile-time cast that forces the compiler to trust your type, bypassing safety checks.

Question 33

Explain template literal types in TypeScript.

Accepted Answer

Template literal types construct custom types by combining string components using template syntax: `type Event = `on${'Click' | 'Hover'}``. This yields the union `'onClick' | 'onHover'`.

Question 34

What is the readonly array modifier?

Accepted Answer

The `ReadonlyArray<T>` type defines an immutable array. Modifying elements or calling mutator methods (like `push`, `pop`, `reverse`) throws compiler errors, preventing state mutation bugs.

Question 35

How do you define types for third-party JS modules without types?

Accepted Answer

Create a local declaration file (e.g. `declarations.d.ts`) and declare the module: `declare module 'untyped-library';`. This prevents compilation errors and types imports from it as `any`.

Question 36

What is the difference between keyof and typeof?

Accepted Answer

`typeof` extracts a type representation from a JavaScript variable value: `type UserType = typeof userObj`. `keyof` extracts a union of keys from a TypeScript type definition.

Question 37

How do you enforce strict type checking in configurations?

Accepted Answer

Enable `strict: true` in `tsconfig.json`. This turns on checks like `noImplicitAny`, `strictNullChecks`, and `strictFunctionTypes` to guarantee strict type safety.

Question 38

Explain the Parameters and ReturnType utility types.

Accepted Answer

- `Parameters` extracts parameter types from a function type `T` as a tuple. - `ReturnType` extracts the return type of function type `T`, which is useful when mapping async actions.

Question 39

What is compile-time type-safety vs runtime type-safety?

Accepted Answer

TypeScript ensures compile-time safety; types are stripped at compilation and do not exist at runtime. Runtime safety requires executing code validators (like Zod) to check variables.

Question 40

How do you debug TypeScript types using compiler utility options?

Accepted Answer

Use options like `noImplicitReturns` and `noUnusedLocals` in `tsconfig.json` to highlight structural errors and clean up unused code imports automatically during builds.

Question 41

Explain Advanced TypeScript Generics, specifically conditional types and the 'infer' keyword.

Accepted Answer

Conditional types allow you to write type-level logic: `T extends U ? X : Y`. The `infer` keyword can only be used within the extends clause of a conditional type, allowing you to dynamically capture and reference a type parameter from a larger type structure. Here is how you would write a custom utility type to extract the resolved value of a Promise using `infer`: ```typescript type UnpackPromise = T extends Promise ? U : T; type ResolvedString = UnpackPromise>; // Resolves to string ``` This allows architects to build highly dynamic APIs where return types are calculated based on input functions.

Question 42

How do you design type-safe state patterns using discriminated unions?

Accepted Answer

Discriminated unions use a common literal property (like `type` or `status`) to distinguish between types. By checking this shared key, TypeScript automatically narrows the union to the correct type branch inside switch blocks:
```typescript
type NetworkState = 
  | { status: 'loading' }
  | { status: 'success'; data: string }
  | { status: 'error'; error: Error };
```
This prevents accessing `data` when status is `loading`, guaranteeing safety at compile time.

Question 43

Explain how to write recursively mapped types for deep immutability.

Accepted Answer

Standard `Readonly` only locks top-level properties. To make nested properties recursively readonly, write a recursively mapped type: ```typescript type DeepReadonly = { readonly [K in keyof T]: T[K] extends object ? DeepReadonly : T[K]; }; ``` This type checks if a property is an object. If it is, it applies `DeepReadonly` recursively, preventing deep state updates in stores.

Question 44

How do you optimize compiler speeds for large enterprise TypeScript codebases?

Accepted Answer

To speed up compilation in large codebases:
1. Enable project references: Divide code into separate modular packages using `tsconfig.json` project references.
2. Skip type checking: Enable `skipLibCheck` to skip checking `.d.ts` files of dependencies.
3. Avoid complex utility types: Avoid deep recursive mappings. Prefer nominal definitions and explicit interfaces over infinite utility layers.

Question 45

Explain how to write custom decorators in TypeScript and their compiler implications.

Accepted Answer

Decorators are functions that can be attached to classes, methods, or properties to modify their behaviors. They use ES Experimental Decorators or modern TC39 Stage 3 standard specifications. They intercept class creation and method overrides, and require setting `experimentalDecorators: true` in configurations.

Question 46

How do you build custom utility types using template literal type mapping?

Accepted Answer

Template literal types can be mapped dynamically. To transform object keys (e.g. converting `name` to `getName`), combine mapped types with string utilities: ```typescript type GetterName ~~= `get${Capitalize~~}`; type Getters = { [K in keyof T as GetterName]: () => T[K]; }; ```~~~~

Question 47

Explain brand types (nominal typing) and how to implement them.

Accepted Answer

TypeScript typing is structural. If you want nominal typing (e.g. preventing assigning a generic `string` to a `UserId`), implement Brand types using intersection types: ```typescript type Brand = K & { __brand: T }; type UserId = Brand; ``` This prevents runtime mixups by requiring explicit type casts before assignment.

Question 48

How do you type and validate dynamic configurations inside a monorepo?

Accepted Answer

Configure shared configurations inside a central package. Export Zod validation schemas along with TypeScript interfaces, and run Zod validators during server startup to crash if environment variables fail checks.

Question 49

Explain the compiler trade-offs of using declarations (declaration: true).

Accepted Answer

Enabling `declaration: true` generates `.d.ts` files during builds. This allows library consumers to access types, but increases compilation times. To optimize, ensure compiler settings use `composite` and incremental caches.

Question 50

How do you type dynamic event emitters with variable payload signatures?

Accepted Answer

Define event maps as types, and use generics on the emitter class: ```typescript class TypedEmitter> { on(event: K, listener: (payload: T[K]) => void): void; emit(event: K, payload: T[K]): void; } ```

Question 51

How do you debug circular references in TypeScript compilations?

Accepted Answer

Circular module imports increase compiler memory usage and can cause runtime crashes where imports evaluate to `undefined`. Locate them using bundler analysis tools (like `dependency-cruiser` or Webpack circular dependency plugins).

Question 52

What is type-level programming and write an Fibonacci type mapping.

Accepted Answer

Type-level programming involves using TypeScript's type engine (conditional, mapped, and tuple types) to perform computations during compile-time. For example, you can calculate tuple lengths recursively to simulate arithmetic addition.

Question 53

How do you prevent type-narrowing bugs when handling dynamic data?

Accepted Answer

Never cast untrusted data using `as`. Instead, parse incoming payloads using runtime validation libraries (like Zod or Superstruct). This ensures that if the shape changes, validation throws immediately.

Question 54

Explain the architecture of declaration maps (declarationMap: true).

Accepted Answer

Declaration maps link compiled `.d.ts` files back to their original `.ts` source files. Enabling this lets developers Ctrl+Click symbols inside IDEs to jump directly to TS source code rather than compiler types.

Question 55

How do you write a utility type to extract parameters from a nested path?

Accepted Answer

Write a recursive template literal parser: ```typescript type ExtractParams ~~= S extends `${string}:${infer Param}/${infer Rest}` ? Param | ExtractParams : S extends `${string}:${infer Param}` ? Param : never; ```~~

Question 56

How do you profile memory leaks inside the tsc compiler?

Accepted Answer

TSC compile processes run on V8. Run compiler runs using `node --max-old-space-size=4096 node_modules/typescript/bin/tsc --diagnostics` to trace checker allocation and garbage collection sizes.

Question 57

Explain compiler differences between target configurations (ES5 vs ESNext).

Accepted Answer

The `target` option in `tsconfig.json` dictates how features (like async/await, classes, or generator functions) are transpiled. Targeting ES5 generates helper code that bloats bundles, while ESNext retains modern syntax.

Question 58

How do you write a type-safe dynamic middleware chain loader?

Accepted Answer

Define a middleware type that passes a generic context object. Chain middlewares by intersecting context modifications, returning a single, type-safe request handler with fully merged properties.

Question 59

Explain the difference between namespace and module systems.

Accepted Answer

Namespaces (`namespace MyScope`) are a legacy TS-specific scoping system compiled into global closures. Modules (`import/export`) are the standard modern ES6 system. Modern projects should avoid namespaces.

Question 60

How do you type custom array operations on complex objects?

Accepted Answer

Use generic array extensions and type definitions. Define methods on the global `Array` interface to extend it, and map array generic parameters to filter return types correctly.

Top 60 TypeScript Interview Questions and Answers (2026)

What is TypeScript and Why is it Critical in Modern Engineering?

TypeScript Lifecycle Visualizer

Core Architectural Concepts in TypeScript

Static Type Checking

Generics & Constraints

Union & Intersection Types

Utility Types (Partial, Pick)

Type Guards & Assertions

check_circleWhy Modern Companies Choose TypeScript

lightbulbStrategic Preparation Tips

errorCrucial Mistakes to Avoid

trending_upHiring Trends & Career Outlook (2026)

Basics