Middle TypeScript Interview Questions (50 MCQs)

Question 1

What do generics help with?

Accepted Answer

Abstracting over types without losing type info

Answer

Removing types entirely

Answer

Only for CSS-in-JS

Answer

Speeding up runtime

Question 2

What does `Partial<T>` do?

Accepted Answer

Makes all properties optional

Answer

Makes all required

Answer

Converts the type to string

Answer

Creates an array

Question 3

In a discriminated union, what do we usually narrow on?

Accepted Answer

A shared field like `kind`

Answer

The file name

Answer

Only `any`

Answer

Line numbers

Question 4

What type is `keyof { a: 1; b: 2 }`?

Accepted Answer

`"a" | "b"`

Answer

`1 | 2`

Answer

`string`

Answer

`object`

Question 5

What does `type Cfg = typeof config` do?

Accepted Answer

Derives a type from an existing value

Answer

Returns the string "object"

Answer

Copies config

Answer

It's invalid in TS

Question 6

What does `function isFish(p): p is Fish` do?

Accepted Answer

A custom type guard that narrows inside if

Answer

Converts p into Fish

Answer

Throws at runtime

Answer

It's documentation only

Question 7

What does `{ [key: string]: number }` describe?

Accepted Answer

An object with arbitrary string keys and number values

Answer

An array of strings

Answer

Exactly one key named key

Answer

A tuple

Question 8

What type does `["a", "b"] as const` have?

Accepted Answer

`readonly ["a", "b"]`

Answer

`string[]`

Answer

`any[]`

Answer

`[string, string]`

Question 9

What are function overloads in TS?

Accepted Answer

Several type signatures with one implementation

Answer

Multiple runtime implementations

Answer

Class inheritance

Answer

The same as generics

Question 10

In `interface Res<T = string> { data: T }`, what is `data` in plain `Res`?

Accepted Answer

`string`, because the default type parameter applies

Answer

`unknown`

Answer

An error; the type argument is required

Answer

`any`

Question 11

Which is the type-safe signature for `get(obj, key)` returning the property value?

Accepted Answer

`<T, K extends keyof T>(obj: T, key: K): T[K]`

Answer

`<T>(obj: T, key: string): any`

Answer

`<T, K>(obj: T, key: K): T`

Answer

`<T>(obj: T, key: keyof T): T`

Question 12

What is `User["address"]["city"]` at the type level?

Accepted Answer

The type of `city` inside `address` of `User`

Answer

A syntax error; indexing is only allowed on values

Answer

A union of all keys of `User`

Answer

A string literal `"city"`

Question 13

Given `const roles = ["admin", "user"] as const`, what is `(typeof roles)[number]`?

Accepted Answer

`"admin" | "user"`

Answer

`string`

Answer

`number`

Answer

`readonly ["admin", "user"]`

Question 14

What is `Exclude<"a" | "b" | "c", "a" | "c">`?

Accepted Answer

`"b"`

Answer

`"a" | "c"`

Answer

`never`

Answer

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

Question 15

What is `NonNullable<string | null | undefined>`?

Accepted Answer

`string`

Answer

`string | undefined`

Answer

`never`

Answer

`{}`

Question 16

For `function f(a: string, b?: number) {}`, what is `Parameters<typeof f>`?

Accepted Answer

The tuple `[a: string, b?: number]`

Answer

`string | number`

Answer

`{ a: string; b?: number }`

Answer

`(string | number)[]`

Question 17

What is `Awaited>>`?

Accepted Answer

`number`

Answer

`Promise<number>`

Answer

`Promise<Promise<number>>`

Answer

`unknown`

Question 18

Why does `ReturnType<getUser>` error (where `getUser` is a function)?

Accepted Answer

`getUser` is a value; you need `ReturnType<typeof getUser>`

Answer

`ReturnType` only works on arrow functions

Answer

Because the function must be async

Answer

Because `ReturnType` must be imported

Question 19

In an overloaded function, what is the status of the implementation signature?

Accepted Answer

It's not callable from outside; only the overloads above it are visible

Answer

It's callable from outside like an extra overload

Answer

It must be identical to the first overload

Answer

It compiles to several separate functions at runtime

Question 20

What effect does calling `function assertString(v: unknown): asserts v is string` have?

Accepted Answer

For the rest of the scope, `v` is narrowed to `string`

Answer

Returns a boolean to be used in an `if`

Answer

Automatically performs a `typeof` check at runtime

Answer

Converts the value to a string

Question 21

With `strict: true`, what is the type of `e` in `catch (e) {}`?

Accepted Answer

`unknown`

Answer

`Error`

Answer

`any`

Answer

`never`

Question 22

In TS 5.5+, what is the type of `["a", undefined].filter(x => x !== undefined)`?

Accepted Answer

`string[]`

Answer

`(string | undefined)[]`

Answer

`unknown[]`

Answer

`never[]`

Question 23

With `count: number | undefined`, what's the pitfall of `if (count) { ... }` to exclude `undefined`?

Accepted Answer

`0` is also falsy and is skipped

Answer

TS doesn't narrow on truthiness checks

Answer

It's a compile error

Answer

`NaN` gets converted to `undefined`

Question 24

With `x: string | number` and `y: string | boolean`, what are the types inside `if (x === y)`?

Accepted Answer

Both `string`

Answer

They stay unchanged

Answer

Both `never`

Answer

`x` is `number` and `y` is `boolean`

Question 25

What's the difference between `f(a?: number)` and `f(a: number | undefined)`?

Accepted Answer

In the second, an argument must be passed, even if `undefined`

Answer

There is no difference

Answer

The first doesn't accept `undefined`

Answer

The second also accepts `null`

Question 26

What happens when passing a `readonly string[]` to a parameter typed `string[]`?

Accepted Answer

An error, because the function could mutate the array

Answer

It's allowed; readonly only affects the variable

Answer

The array is copied automatically

Answer

It's allowed only when `strict` is on

Question 27

For `type T = [name: string, age?: number]`, what is `T["length"]`?

Accepted Answer

`1 | 2`

Answer

`2`

Answer

`number`

Answer

`0 | 1 | 2`

Question 28

With `type Append = [...T, number]`, what is `Append<[string, boolean]>`?

Accepted Answer

`[string, boolean, number]`

Answer

`[[string, boolean], number]`

Answer

`(string | boolean | number)[]`

Answer

`[string, boolean]`

Question 29

What does ``{ [K in keyof T as `get${Capitalize<K & string>}`]: () => T[K] }`` produce for `T = { name: string }`?

Accepted Answer

`{ getName: () => string }`

Answer

`{ name: () => string }`

Answer

`{ getname: string }`

Answer

An error; `as` isn't allowed in mapped types

Question 30

What does `{ -readonly [K in keyof T]-?: T[K] }` do?

Accepted Answer

Removes `readonly` and `?` from all properties

Answer

Makes all properties readonly and optional

Answer

Removes readonly properties entirely

Answer

It's a syntax error

Question 31

With `type ToArray = T extends any ? T[] : never`, what is `ToArray`?

Accepted Answer

`string[] | number[]`

Answer

`(string | number)[]`

Answer

`never`

Answer

`[string, number]`

Question 32

What does `string | never` simplify to?

Accepted Answer

`string`

Answer

`never`

Answer

`unknown`

Answer

`string | undefined`

Question 33

What's the main difference between a `const enum` and a regular `enum`?

Accepted Answer

Its values are inlined at use sites and no runtime object is emitted

Answer

Its members can't change but regular enum members can

Answer

It only accepts strings

Answer

It iterates faster at runtime

Question 34

To add `window.analytics` to the `Window` type inside a module file, what do you write?

Accepted Answer

`declare global { interface Window { analytics: Analytics } }`

Answer

`type Window = { analytics: Analytics }`

Answer

`window.analytics = {} as Analytics` is enough

Answer

`class Window { analytics: Analytics }`

Question 35

What does `import type { User } from "./models"` guarantee?

Accepted Answer

The import is fully removed from the JS output

Answer

`User` is lazily loaded at runtime

Answer

`User` can also be used as a value

Answer

The `./models` module is guaranteed to execute

Question 36

What behavior does `verbatimModuleSyntax` enforce?

Accepted Answer

Imports without `type` are kept as written, so type imports must be marked with `type`

Answer

Converts all imports to `require`

Answer

Automatically removes unused imports

Answer

Allows only default imports

Question 37

What problem does `esModuleInterop` solve?

Accepted Answer

Allows default imports from CommonJS modules like `import express from "express"`

Answer

Automatically converts ESM to UMD

Answer

Running TS directly in the browser

Answer

Removing the need for `.d.ts` files

Question 38

Why might code compiled by `tsc` fail in Node after configuring `paths` like `"@/*": ["src/*"]`?

Accepted Answer

`tsc` doesn't rewrite import paths in the output

Answer

`paths` only works with `module: "amd"`

Answer

Node doesn't support `@` in imports

Answer

`paths` excludes files from the build

Question 39

In `function onClick(this: HTMLButtonElement, e: MouseEvent) {}`, what is the `this` parameter?

Accepted Answer

A fake parameter that types `this`; it's erased in the output

Answer

A real first argument callers must pass

Answer

A syntax error since `this` is reserved

Answer

It automatically binds the function

Question 40

With `function f<const T>(x: T): T`, what is the type of `f(["a", "b"])`?

Accepted Answer

`readonly ["a", "b"]`

Answer

`string[]`

Answer

`("a" | "b")[]`

Answer

`[string, string]`

Question 41

Why does `Object.keys(user)` return `string[]` rather than `(keyof User)[]`?

Accepted Answer

Due to structural typing, the object may have more keys at runtime

Answer

Because `keyof` isn't defined in the lib

Answer

It's a known bug fixed in TS 5

Answer

Because numeric keys aren't supported

Question 42

With `noUncheckedIndexedAccess`, what is `cache[key]` for `cache: Record<string, number>`?

Accepted Answer

`number | undefined`

Answer

`number`

Answer

`unknown`

Answer

`never`

Question 43

With `class A implements I { handle(x) {} }` where `I` declares `handle(x: string)`, what is `x`?

Accepted Answer

Implicit `any`; `implements` doesn't propagate parameter types

Answer

`string`, inferred from the interface

Answer

`unknown`

Answer

`never`

Question 44

With `noImplicitOverride`, how does the `override` keyword help?

Accepted Answer

The compiler errors if the base method is removed or renamed

Answer

It protects the method from change at runtime

Answer

It automatically calls the base method

Answer

It makes the method final so no further subclass can override it

Question 45

In a class, what does `token!: string` (with `!`) mean?

Accepted Answer

Tells TS the field will definitely be assigned, even outside the constructor

Answer

Makes the field required and immutable

Answer

Gives the field a default value of `""`

Answer

Makes the field private

Question 46

Why does `function f<T extends { id: number }>(x: T): T { return { id: 1 }; }` error?

Accepted Answer

`T` may be a subtype with more properties; `{ id: 1 }` isn't necessarily `T`

Answer

Because `id` must be a string

Answer

Because the parameter `x` is unused

Answer

Because generics can't return object literals

Question 47

How many members does ``type T = `${"sm" | "lg"}-${"red" | "blue"}` `` have?

Accepted Answer

4 members; every combination like `"sm-red"`

Answer

2 members; positional pairs

Answer

One member, `string`

Answer

An error; unions aren't allowed in template literals

Question 48

What values does the type `{}` accept?

Accepted Answer

Any value except `null` and `undefined`, even `42` and `"hi"`

Answer

Only the empty object `{}`

Answer

Only objects, not primitives

Answer

No values; it's equivalent to `never`

Question 49

To get the props type of an existing component like `Button`, which approach fits?

Accepted Answer

`React.ComponentProps<typeof Button>`

Answer

`typeof Button.props`

Answer

`Props<Button>`

Answer

`ReturnType<typeof Button>`

Question 50

What is the right parameter type for the handler in `<input onChange={handle} />`?

Accepted Answer

`React.ChangeEvent<HTMLInputElement>`

Answer

`Event`

Answer

`React.MouseEvent<HTMLInputElement>`

Answer

`InputEvent<string>`

TypeScript · Middle · 50

What do generics help with?