Senior TypeScript Interview Questions (50 MCQs)

Question 1

What is the general shape of a conditional type?

Accepted Answer

`T extends U ? X : Y`

Answer

`T && U || Y`

Answer

`if T then U`

Answer

`T ?? U`

Question 2

What does `satisfies` help with?

Accepted Answer

Validate compatibility without widening literals

Answer

Executing code at runtime

Answer

Turning off type checking

Answer

Enums only

Question 3

What are `.d.ts` files for?

Accepted Answer

Declaring types for JS/APIs without implementation

Answer

CSS styles

Answer

E2E tests

Answer

The final browser bundle

Question 4

`{ [K in keyof T]?: T[K] }` is equivalent to which utility?

Accepted Answer

`Partial<T>`

Answer

`Required<T>`

Answer

`Readonly<T>`

Answer

`Pick<T, K>`

Question 5

What is ``type E = `on${Capitalize<"click">}` ``?

Accepted Answer

`"onClick"`

Answer

`"onclick"`

Answer

`string`

Answer

A compile error

Question 6

What is a branded type like `string & { __brand: "UserId" }` for?

Accepted Answer

Preventing mix-ups between same-shaped ids like UserId and OrderId

Answer

Encrypting the string

Answer

Automatic runtime validation

Answer

Reducing bundle size

Question 7

In a union switch's `default`, what does `const x: never = value` do?

Accepted Answer

Causes a compile error if a case is unhandled

Answer

Throws at runtime only

Answer

Makes the switch faster

Answer

Has no effect

Question 8

What does `T extends (...a: any[]) => infer R ? R : never` extract?

Accepted Answer

The function's return type (like `ReturnType`)

Answer

The parameter types

Answer

The function name

Answer

The argument count

Question 9

What does `function f<T extends { id: string }>(x: T)` guarantee?

Accepted Answer

Any T must have `id: string`, and the rest of its type is preserved

Answer

T can only be exactly `{ id: string }`

Answer

T must be a class

Answer

No constraint at all

Question 10

What do the `in` and `out` annotations in `interface Producer<out T>` do?

Accepted Answer

They make the type parameter's intended variance explicit, and the compiler checks it

Answer

They mark `T` as runtime input or output only

Answer

They make `T` readonly or write-only

Answer

They're just comments with no effect

Question 11

Even with `strictFunctionTypes`, which form has its parameters checked bivariantly?

Accepted Answer

Methods written in method shorthand: `{ handle(x: T): void }`

Answer

Function-typed properties: `{ handle: (x: T) => void }`

Answer

Function type aliases: `type H = (x: T) => void`

Answer

None; all are contravariant

Question 12

With `strictFunctionTypes`, what happens assigning `(x: string) => void` to `let f: (x: string | number) => void`?

Accepted Answer

An error; parameters are contravariant and the function could receive a number

Answer

Allowed, since `string` is part of the union

Answer

Allowed, but the parameter becomes `any`

Answer

An error only if the return types differ

Question 13

Why wrap the type in a tuple in `type IsStr<T> = [T] extends [string] ? true : false`?

Accepted Answer

To prevent distribution over union members

Answer

To convert `T` into an array

Answer

Because conditional types don't work without tuples

Answer

Purely for compile speed, nothing else

Question 14

With `type IsStr = T extends string ? true : false`, what is `IsStr`?

Accepted Answer

`never`

Answer

`true`

Answer

`false`

Answer

`boolean`

Question 15

Why does `type IsAny<T> = 0 extends 1 & T ? true : false` detect `any`?

Accepted Answer

`1 & any` is `any`, which accepts `0`; for other types it doesn't

Answer

Because `any` always equals `0`

Answer

Because intersecting with `any` always gives `never`

Answer

It doesn't work and always returns `false`

Question 16

Why is `Equals` written as `(() => G extends A ? 1 : 2) extends (() => G extends B ? 1 : 2)` instead of mutual `extends`?

Accepted Answer

Mutual assignability treats `any` as equal to everything; this compares exact identity

Answer

Because `extends` can only be used one way in conditional types

Answer

It's only faster

Answer

Because parameterless generics never resolve

Question 17

Why does `(U extends any ? (x: U) => void : never) extends (x: infer I) => void ? I : never` turn a union into an intersection?

Accepted Answer

`infer` in a contravariant (parameter) position combines candidates as an intersection

Answer

Because `extends any` always produces an intersection

Answer

Because `void` merges union members

Answer

It actually returns the union unchanged

Question 18

In `T extends [infer H extends string, ...unknown[]] ? H : never`, what does `extends string` after `infer H` do?

Accepted Answer

Constrains the inferred variable; if unmet, the false branch is taken

Answer

Forces `H` to be converted to a string

Answer

Creates a nested conditional with its own branches

Answer

It's a syntax error

Question 19

Which technique helps avoid "Type instantiation is excessively deep" in a recursive conditional type?

Accepted Answer

Rewriting it tail-recursively with an accumulator

Answer

Adding `// @ts-ignore` above the definition

Answer

Converting the type alias to an interface

Answer

Increasing `maxDepth` in tsconfig

Question 20

What does ``"a.b.c" extends `${infer H}.${infer R}` ? [H, R] : never`` produce?

Accepted Answer

`["a", "b.c"]`

Answer

`["a.b", "c"]`

Answer

`["a", "b"]`

Answer

`never`

Question 21

In `function pick(opts: T[], initial: NoInfer)`, what does `NoInfer` do?

Accepted Answer

`initial` doesn't contribute to inferring `T`, so a value outside `opts` errors

Answer

Turns `T` into `unknown`

Answer

Makes `initial` optional

Answer

Disables inference for the whole function

Question 22

With `exactOptionalPropertyTypes`, what happens assigning `{ theme: undefined }` to `{ theme?: "dark" | "light" }`?

Accepted Answer

An error; optional means "absent," not the value `undefined`

Answer

Allowed, since `?` always adds `undefined`

Answer

The property is removed automatically

Answer

It only applies to classes

Question 23

What is `Partial<[string, number]>`?

Accepted Answer

`[string?, number?]`

Answer

`{ 0?: string; 1?: number; length?: 2 }`

Answer

`(string | number)[]`

Answer

`[string, number] | undefined`

Question 24

What does ``{ [K in keyof T as T[K] extends Function ? never : K]: T[K] }`` do?

Accepted Answer

Removes all properties whose values are functions

Answer

Keeps only the methods

Answer

Sets every property type to `never`

Answer

Renames keys to function names

Question 25

Where can the `unique symbol` type be used?

Accepted Answer

Only on `const` declarations or `static readonly` properties

Answer

On any `let` variable

Answer

Only as a type parameter

Answer

Only inside `.d.ts` files

Question 26

Why does a mixin with `Base: new (...args: any[]) => object` reject abstract classes, and what's the fix?

Accepted Answer

Abstract classes aren't assignable to a plain construct signature; use `abstract new (...args: any[]) => object`

Answer

Mixins only work with interfaces

Answer

You must type `Base` as `any`; there's no other way

Answer

Abstract classes don't exist at runtime

Question 27

Why can `declare module "express" { interface Request { user?: User } }` in a file with no imports/exports break express's types?

Accepted Answer

In a script file it declares a new ambient module that replaces the types instead of augmenting them

Answer

Because `declare module` is only for CSS files

Answer

Because interfaces can't be merged

Answer

Because you must use a `namespace`

Question 28

With `isolatedModules`, why does `export { User } from "./types"` error when `User` is only a type?

Accepted Answer

A single-file transpiler can't know `User` is a type to drop it; use `export type`

Answer

Re-exports aren't allowed in ESM

Answer

Because types can't be exported

Answer

Because `./types` must have a `.d.ts` extension

Question 29

With `moduleResolution: "nodenext"` in an ESM file, how is a relative import of `./utils.ts` written?

Accepted Answer

`import { x } from "./utils.js"`

Answer

`import { x } from "./utils"`

Answer

`import { x } from "utils"`

Answer

`import { x } from "./utils.d.ts"`

Question 30

In a library's package.json `exports` field, where should the `"types"` condition go?

Accepted Answer

First, before `"import"`/`"require"`/`"default"`

Answer

Last, after all other conditions

Answer

Order doesn't matter

Answer

Outside `exports` in a separate `typesExports` field

Question 31

In project references, what do `composite: true` and `tsc -b` do?

Accepted Answer

They build projects in dependency order incrementally, consuming each other's emitted `.d.ts`

Answer

They merge all projects into one JS file

Answer

They disable type checking for dependent projects

Answer

They only work in Yarn monorepos

Question 32

What exactly does `skipLibCheck: true` skip?

Accepted Answer

Type checking of all declaration files (`*.d.ts`)

Answer

Type checking of everything in `node_modules`, including `.ts` files

Answer

Loading the `lib` option

Answer

Checking the project's own code

Question 33

What is `declarationMap` for?

Accepted Answer

Editor "Go to Definition" jumps to the original `.ts` source instead of the `.d.ts`

Answer

Minifies `.d.ts` files

Answer

Generates source maps for running JS in the browser

Answer

Extracts types from JS files

Question 34

What does `using conn = openConnection()` (TS 5.2+) do?

Accepted Answer

Calls `conn[Symbol.dispose]()` automatically at the end of the scope

Answer

Makes `conn` readonly and lazy

Answer

It's an alias for `const` with no difference

Answer

Shares the connection across modules

Question 35

What limitation do standard decorators (TS 5.0 without `experimentalDecorators`) have versus the legacy ones?

Accepted Answer

They don't support parameter decorators or `emitDecoratorMetadata`

Answer

They can't be used on methods

Answer

They only work in `.d.ts` files

Answer

They produce no runtime output

Question 36

When calling an overloaded function, which overload does TS pick?

Accepted Answer

The first overload, top to bottom, that matches the arguments

Answer

The most specific overload regardless of order

Answer

The last declared overload

Answer

A union of all matching overloads

Question 37

With overloads `f(x: string): string` and `f(x: number): number`, what happens calling `f(v)` with `v: string | number`?

Accepted Answer

An error; no single overload accepts the union

Answer

The result is `string | number`

Answer

The first overload is chosen, returning `string`

Answer

TS tries both and returns the union of results

Question 38

Why do builder methods return `this` as a type (e.g. `setName(n: string): this`)?

Accepted Answer

So method chaining keeps the subclass type in subclasses

Answer

So the method is auto-bound

Answer

Because returning `Builder` isn't allowed in TS

Answer

To make the method static

Question 39

Since TS 5.4, when is a `let` variable's narrowing preserved inside a closure?

Accepted Answer

When there are no assignments to the variable after the closure is created

Answer

Always, unconditionally

Answer

Only when the closure is an arrow function

Answer

Never; only `const` preserves narrowing

Question 40

After `if (obj.val !== undefined)`, if a function that might mutate `obj.val` is called, what does TS do?

Accepted Answer

Keeps the narrowing; a deliberate unsound trade-off for usability

Answer

Resets the narrowing, adding `undefined` back

Answer

Reports a compile error

Answer

Analyzes whether the function actually mutates `obj`

Question 41

Why does `const animals: Animal[] = dogs; animals.push(cat);` (with `dogs: Dog[]`) compile without error?

Accepted Answer

Mutable arrays are covariant in TS, which is unsound

Answer

Because `push` is untyped in TS

Answer

Because `Cat` and `Dog` are structurally identical

Answer

It doesn't compile; it errors

Question 42

Why does `const o = { x: 1, y: 2 }; const p: { x: number } = o;` not trigger an excess property error?

Accepted Answer

Excess property checks only apply to "fresh" object literals

Answer

Because `const` disables excess checks

Answer

Because `y` is a number

Answer

It does error

Question 43

With `type Opts = { color?: string; size?: number }`, why does `const o = { colour: "red" }; const x: Opts = o;` error?

Accepted Answer

Weak type detection: an all-optional type requires at least one overlapping property

Answer

Excess property checking on the variable

Answer

Because TS recognizes `colour` as a spelling mistake

Answer

Because optional types aren't assignable

Question 44

For `function f(b: B): [A, B]`, what happens with `f(42)`?

Accepted Answer

An error; TS doesn't support partial type argument inference

Answer

`A` is `string` and `B` is inferred as `number`

Answer

`B` becomes `unknown`

Answer

`string` is assigned to `B`

Question 45

What does `{ kind: "a"; x: number } & { kind: "b" }` reduce to?

Accepted Answer

`never`

Answer

`{ kind: never; x: number }`

Answer

`{ kind: "a" | "b"; x: number }`

Answer

`{ kind: "b"; x: number }`

Question 46

How does `((x: string) => string) & ((x: number) => number)` behave?

Accepted Answer

Like an overloaded function, in the intersection's order

Answer

Like a function whose parameter is `string & number`, i.e. `never`

Answer

Like a function with a `string | number` parameter and a union result

Answer

It immediately becomes `never`

Question 47

For `A = { a: 1; c: 1 }` and `B = { b: 1; c: 1 }`, what is `keyof (A | B)`?

Accepted Answer

`"c"`

Answer

`"a" | "b" | "c"`

Answer

`never`

Answer

`"a" | "b"`

Question 48

Per the TS team's performance guide, why is `interface C extends A, B {}` usually preferred over `type C = A & B`?

Accepted Answer

Interface relationships are cached and property conflicts are reported early

Answer

Intersections emit extra runtime code

Answer

Interfaces don't support generics, so they're simpler

Answer

Intersections are deprecated in TS 5

Question 49

What does setting `"types": ["node"]` in tsconfig do?

Accepted Answer

Only `@types/node` is auto-included globally; other `@types` packages aren't

Answer

Forbids importing any other package

Answer

Changes `lib` to `node`

Answer

Removes the DOM types

Question 50

Why might `const assertOk = (v: unknown): asserts v => { ... }` followed by `assertOk(x)` error with "Assertions require every name in the call target to be declared with an explicit type annotation"?

Accepted Answer

`assertOk`'s type is inferred; the variable needs an explicit annotation or use a function declaration

Answer

Arrow functions can never use `asserts`

Answer

Because `v` must be `any`

Answer

Because assertion functions must be async

TypeScript · Senior · 50

What is the general shape of a conditional type?