Junior TypeScript Interview Questions (50 MCQs)

Question 1

What is TypeScript's main value over JS?

Accepted Answer

Static types catching errors before runtime

Answer

Faster execution in every browser with no compile step

Answer

Replacing HTML

Answer

Removing the need for tests entirely

Question 2

Which capability is more specific to `interface`?

Accepted Answer

Declaration merging

Answer

Complex unions

Answer

Advanced mapped types

Answer

Tuple types

Question 3

Difference between `any` and `unknown`?

Accepted Answer

`unknown` is safer and must be narrowed before use

Answer

`any` is always better

Answer

There is no difference

Answer

`unknown` is only checked at runtime

Question 4

What does `readonly` on a property do?

Accepted Answer

Forbids reassignment after initialization at compile time

Answer

Freezes the object at runtime

Answer

Makes the property private

Answer

Makes the property optional

Question 5

In `{ name?: string }`, what is the type of `name`?

Accepted Answer

`string | undefined`

Answer

`string | null`

Answer

`string`

Answer

`any`

Question 6

What does `string | number` mean?

Accepted Answer

The value can be a string or a number

Answer

The value must be both at once

Answer

Only numbers are allowed

Answer

It's an invalid type

Question 7

Which emits no JavaScript at runtime?

Accepted Answer

`type Dir = "up" | "down"`

Answer

`enum Dir { Up, Down }`

Answer

`class Dir {}`

Answer

`const Dir = { Up: 0 }`

Question 8

What does the `never` type represent?

Accepted Answer

A value that never occurs, like a function that always throws

Answer

Same as `undefined`

Answer

Same as `void`

Answer

Any value

Question 9

In `let x = 5`, what is the type of `x`?

Accepted Answer

`number`

Answer

`5`

Answer

`any`

Answer

`unknown`

Question 10

What does the type `[string, number]` describe?

Accepted Answer

A fixed-length array whose first item is a string and second a number

Answer

An array of any number of strings or numbers in any order

Answer

An object with two properties named string and number

Answer

A union that is either a string or a number

Question 11

What does a `void` return type on a function mean?

Accepted Answer

The function returns no meaningful value

Answer

The function never finishes

Answer

The function always returns `null`

Answer

The function may return any value of any type

Question 12

What is the difference between `number[]` and `Array<number>`?

Accepted Answer

None; they are two syntaxes for the same type

Answer

`Array<number>` is checked at runtime

Answer

`number[]` is only for readonly arrays

Answer

`Array<number>` fixes the array length

Question 13

What does the intersection type `A & B` mean?

Accepted Answer

A value that has all members of both `A` and `B`

Answer

A value that is either `A` or `B`

Answer

Only the properties common to both

Answer

A bitwise AND over two numeric types

Question 14

Given `let dir: "left" | "right"`, what happens with `dir = "up"`?

Accepted Answer

A compile error, because `"up"` isn't one of the allowed literals

Answer

No error, because `"up"` is also a string

Answer

It only fails at runtime

Answer

The type of `dir` automatically widens to `string`

Question 15

In `const greeting = "hi"`, what is the inferred type of `greeting`?

Accepted Answer

The literal type `"hi"`

Answer

`string`

Answer

`any`

Answer

`String` (the wrapper object)

Question 16

With `strictNullChecks` on, what happens with `let name: string = null`?

Accepted Answer

A compile error; you'd need `string | null`

Answer

No error, because `null` belongs to every type

Answer

The value is automatically converted to `""`

Answer

Only a runtime warning is shown

Question 17

Where can an optional parameter like `b?: number` appear in a parameter list?

Accepted Answer

After all required parameters

Answer

Only as the first parameter

Answer

Anywhere; order doesn't matter

Answer

Only when the function is an arrow function

Question 18

In `function f(limit = 10) {}`, what is true about `limit`?

Accepted Answer

It's inferred as `number` and is optional for callers

Answer

It's `any` because it has no annotation

Answer

Its type is the literal `10`, accepting only 10

Answer

Callers must always pass it

Question 19

What is a correct type for the rest parameter in `function sum(...nums) {}`?

Accepted Answer

`...nums: number[]`

Answer

`...nums: number`

Answer

`...nums?: number`

Answer

`...nums: Rest<number>`

Question 20

What does `!` do in `document.getElementById("app")!`?

Accepted Answer

Tells TS the value isn't `null`/`undefined`, with no runtime check

Answer

Throws at runtime if the value is `null`

Answer

Converts the value to a boolean

Answer

Replaces `null` with an empty element

Question 21

What does `const n = value as number` do at runtime?

Accepted Answer

Nothing; it only changes the compiler's view of the type

Answer

Converts the value to a number like `Number(value)`

Answer

Throws if the value isn't a number

Answer

Turns the value into `NaN` if it isn't a number

Question 22

After `tsc` compiles TS code, what happens to type annotations?

Accepted Answer

They are erased, leaving plain JS

Answer

They become runtime checks

Answer

They remain as JSDoc comments in the output

Answer

They are stored in a separate file used at runtime

Question 23

What is the role of `tsconfig.json`?

Accepted Answer

Defines compiler options and which files belong to the project

Answer

Holds the list of npm dependencies

Answer

Defines runtime types for the browser

Answer

Is used only to configure ESLint

Question 24

What does `"strict": true` in tsconfig do?

Accepted Answer

Enables a family of strict checks such as `strictNullChecks` and `noImplicitAny`

Answer

Only wraps the output in `"use strict"` and nothing else

Answer

Bans the use of `any` entirely

Answer

Enables type checking at runtime

Question 25

What does `interface Admin extends User { role: string }` mean?

Accepted Answer

`Admin` has all members of `User` plus `role`

Answer

`Admin` has only the `role` property

Answer

`User` now also has the `role` property

Answer

`Admin` is a class inheriting from `User`

Question 26

In `function f(x: string | number)`, what is `x` inside `if (typeof x === "string") { ... }`?

Accepted Answer

`string`

Answer

`string | number`

Answer

`unknown`

Answer

`"string"`

Question 27

With `type Pet = Bird | Fish`, what does `if ("swim" in pet)` do?

Accepted Answer

Narrows `pet` to the union member that has a `swim` property

Answer

Calls the `swim` method on `pet`

Answer

Works only at runtime and doesn't change the type

Answer

Errors because `in` is only for arrays

Question 28

What does `instanceof` narrowing work with?

Accepted Answer

Values created by a class or constructor, like `Date`

Answer

Any interface or type alias

Answer

Only primitive types like `string`

Answer

Only literal types

Question 29

What's the difference between `private secret` and `#secret` in a class?

Accepted Answer

`private` is compile-time only; `#secret` is truly private at runtime too

Answer

There's no difference; they emit the same code

Answer

`#secret` is just a comment

Answer

`private` is private at runtime but `#secret` isn't

Question 30

Where is a `protected` class member accessible?

Accepted Answer

Inside the class and its subclasses

Answer

Only inside the same class

Answer

From anywhere

Answer

Only from files that import the class

Question 31

What does `constructor(private name: string) {}` do?

Accepted Answer

Declares and initializes a private `name` property

Answer

Only accepts the parameter without creating a property

Answer

It's a syntax error

Answer

Turns `name` into a global variable

Question 32

What is the key property of `abstract class Shape`?

Accepted Answer

It can't be instantiated directly, only subclassed

Answer

It can't have any implemented methods

Answer

It's completely erased at runtime, like an interface

Answer

All its members are automatically `static`

Question 33

What does `class Dog implements Animal` guarantee?

Accepted Answer

The compiler checks that `Dog` matches the shape of `Animal`

Answer

`Dog` inherits `Animal`'s method implementations

Answer

`Animal` is added to the prototype at runtime

Answer

`Dog` can no longer have extra members

Question 34

In `enum Dir { Up, Down, Left }`, what is the value of `Dir.Down`?

Accepted Answer

`1`

Answer

`"Down"`

Answer

`0`

Answer

`undefined`

Question 35

Which feature is missing from a string enum (e.g. `enum S { A = "a" }`)?

Accepted Answer

Reverse mapping from value to name (`S["a"]`)

Answer

Accessing a member via `S.A`

Answer

Using the enum as a type

Answer

Having an object at runtime

Question 36

What type is `Record<"light" | "dark", string>`?

Accepted Answer

An object with exactly the keys `light` and `dark`, each a string

Answer

An array of strings of length 2

Answer

An object that has only one of the two keys

Answer

A runtime Map

Question 37

Which defines the type "a function taking a number and returning a string"?

Accepted Answer

`type Fn = (n: number) => string`

Answer

`type Fn = (number) -> string`

Answer

`type Fn = function(number): string`

Answer

`type Fn = Function<number, string>`

Question 38

What values does the `object` type (lowercase) accept?

Accepted Answer

Any non-primitive value such as objects, arrays, and functions

Answer

All values including strings and numbers

Answer

Only object literals, not arrays

Answer

Only `null`

Question 39

With `type P = { x: number }`, why does `const p: P = { x: 1, y: 2 }` error?

Accepted Answer

Excess property check: an object literal mustn't have unknown properties

Answer

Because `y` must be declared optional

Answer

Because `x` must be a string

Answer

It doesn't error

Question 40

How does TS decide whether types are compatible?

Accepted Answer

By shape (structural); compatible if it has the required members

Answer

By the type's name (nominal)

Answer

By the file where the type is declared

Answer

Only if declared explicitly with `implements`

Question 41

What are packages like `@types/lodash` for?

Accepted Answer

Type definitions for JS libraries that ship no types

Answer

A faster build of the original library

Answer

The library's unit tests

Answer

Polyfills for old browsers

Question 42

Given `interface Box { value: T }`, what is the type of `value` in `Box`?

Accepted Answer

`string`

Answer

`T`

Answer

`unknown`

Answer

`Box<string>`

Question 43

What exactly does `type ID = string | number` do?

Accepted Answer

Gives a new name to that union, not a distinct type

Answer

Creates a new runtime class

Answer

Creates a nominal type that rejects plain `string`

Answer

Defines an enum with two members

Question 44

What is the return type of `function add(a: number, b: number) { return a + b; }`?

Accepted Answer

`number`, inferred from the body

Answer

`any`, because it isn't written

Answer

`void`

Answer

`unknown`

Question 45

With `noImplicitAny`, what happens to `function log(msg) {}`?

Accepted Answer

Errors because `msg` is implicitly `any`

Answer

`msg` is automatically treated as `string`

Answer

`msg` automatically becomes `unknown`

Answer

It errors only in `.js` files

Question 46

What does `Required<{ a?: number; b?: string }>` produce?

Accepted Answer

`{ a: number; b: string }`

Answer

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

Answer

`{ a: number | undefined; b: string | undefined }`

Answer

`[number, string]`

Question 47

With `Readonly<{ user: { name: string } }>`, is `obj.user.name = "x"` allowed?

Accepted Answer

Yes; `Readonly` is shallow and only makes `user` readonly

Answer

No; `Readonly` makes the whole structure deeply readonly

Answer

No; the object is frozen at runtime

Answer

Only if `name` is optional

Question 48

By default, what happens when `tsc` finds type errors?

Accepted Answer

It reports the errors but still emits JS files

Answer

It emits no files at all

Answer

It fixes the errors automatically

Answer

It deletes the error-free files

Question 49

What does `Omit<User, "password">` do?

Accepted Answer

Builds a type like `User` but without the `password` property

Answer

Keeps only the `password` property

Answer

Makes `password` optional

Answer

Deletes `password` from the object at runtime

Question 50

With `x: string | number`, why does `x.toUpperCase()` error?

Accepted Answer

On a union, only members common to all types are accessible

Answer

Because `toUpperCase` doesn't exist in TS

Answer

Because `x` must first be cast to `any`

Answer

It doesn't error; it's checked at runtime

TypeScript · Junior · 50

What is TypeScript's main value over JS?