Junior Node.js Interview Questions (50 MCQs)

Question 1

What exactly is Node.js?

Accepted Answer

A runtime for running JavaScript outside the browser, built on V8 and libuv

Answer

A JavaScript web framework similar to Express or Django

Answer

A new programming language inspired by JavaScript

Answer

A compiler that turns JavaScript into a standalone native binary

Question 2

What is V8's role in Node.js?

Accepted Answer

Parsing, JIT-compiling and executing JavaScript, plus heap and GC management

Answer

Managing the event loop and asynchronous file and network operations

Answer

Installing and resolving packages from the npm registry

Answer

Providing the `fs`, `http` and `path` modules natively

Question 3

What does libuv do in Node.js?

Accepted Answer

Implements the event loop, cross-platform async I/O and the thread pool

Answer

Compiles JavaScript into bytecode and optimizes it

Answer

Transpiles TypeScript into JavaScript before execution

Answer

Manages the project's dependencies inside `node_modules`

Question 4

What does 'Node.js is single-threaded' actually mean?

Accepted Answer

Your JavaScript runs on one thread, but libuv uses extra threads for some I/O

Answer

The whole process, including I/O and GC, uses exactly one OS thread

Answer

Node can only serve one HTTP request at any given moment

Answer

Node cannot run on multi-core CPUs and only detects one core

Question 5

What is the correct order of the main Node event loop phases?

Accepted Answer

timers → pending callbacks → poll → check → close callbacks

Answer

poll → timers → check → close callbacks → pending callbacks

Answer

check → timers → poll → pending callbacks → close callbacks

Answer

timers → check → poll → close callbacks → pending callbacks

Question 6

In a CommonJS file, what does `setTimeout(() => console.log('t')); Promise.resolve().then(() => console.log('p')); process.nextTick(() => console.log('n')); console.log('s');` print?

Accepted Answer

`s n p t`

Answer

`s p n t`

Answer

`n s p t`

Answer

`s t n p`

Question 7

If the main module runs `setTimeout(a, 0); setImmediate(b);`, in what order do `a` and `b` run?

Accepted Answer

Not deterministic; it depends on loop startup timing and timer precision

Answer

Always `a` first, because the timers phase comes before check

Answer

Always `b` first, because `setImmediate` is immediate

Answer

Both run simultaneously on separate threads

Question 8

Inside an `fs.readFile` callback, if we call `setTimeout(a, 0)` and `setImmediate(b)`, which runs first?

Accepted Answer

Always `b`, because the check phase follows poll

Answer

Always `a`, because a zero delay means immediate

Answer

The order is random and unpredictable

Answer

`b` is deferred to the next loop iteration, after `a`

Question 9

What is the main syntax difference between CommonJS and ES Modules in Node?

Accepted Answer

CommonJS uses `require`/`module.exports`; ESM uses `import`/`export`

Answer

CommonJS uses `import`/`export`; ESM uses `require`/`exports`

Answer

They are identical and only the file extension differs

Answer

ESM only works in browsers; Node supports only CommonJS

Question 10

What does `"type": "module"` in `package.json` do?

Accepted Answer

Makes `.js` files in that package be treated as ES Modules

Answer

Marks the package as usable only in browsers

Answer

Makes npm compile the package as a native addon

Answer

Converts `.mjs` files to CommonJS

Question 11

In a package with `"type": "module"`, how do you keep one file as CommonJS?

Accepted Answer

Give it the `.cjs` extension

Answer

Add `'use commonjs'` at the top of the file

Answer

Give it the `.mjs` extension

Answer

It's impossible; every file must be ESM

Question 12

What is the `main` field in `package.json` for?

Accepted Answer

It sets the package entry point used by `require('pkg')`

Answer

It defines the script run by `npm start`

Answer

It specifies the project's main git branch

Answer

It sets the minimum required Node version

Question 13

If a CommonJS module is `require`d three times from different files, how many times does its code run?

Accepted Answer

Once; the result is cached in `require.cache` and reused

Answer

Three times; each `require` creates a fresh instance

Answer

Twice; once for parsing and once for execution

Answer

It depends on whether you store it in `const` or `let`

Question 14

What happens with `__dirname` inside an ES Module?

Accepted Answer

It isn't defined; use `import.meta.dirname` or `import.meta.url` instead

Answer

It points to the current file's folder, just like CommonJS

Answer

It points to the directory from which `node` was launched

Answer

It points to the project root where `package.json` lives

Question 15

Why does `exports = { a: 1 }` export nothing in CommonJS?

Accepted Answer

It only reassigns the local `exports` variable; `module.exports` stays unchanged

Answer

Because `exports` is read-only and throws a TypeError

Answer

Because CommonJS can only export functions, not objects

Answer

Because you must use `export default` instead

Question 16

What's the benefit of `import fs from 'node:fs'` over `'fs'`?

Accepted Answer

It explicitly loads the core module and can't be confused with an npm package

Answer

It loads a faster, multi-threaded version of `fs`

Answer

It downloads the module from the npm registry

Answer

It's only valid in TypeScript and errors in Node

Question 17

How does `npm ci` differ from `npm install`?

Accepted Answer

`npm ci` installs exactly from the lockfile, wipes `node_modules`, and never edits the lockfile

Answer

`npm ci` installs the newest versions and updates the lockfile

Answer

`npm ci` installs only devDependencies

Answer

`npm ci` is just an old alias of `npm install`

Question 18

Which versions does the range `^1.4.2` accept in `package.json`?

Accepted Answer

`>=1.4.2` and `<2.0.0`

Answer

`>=1.4.2` and `<1.5.0`

Answer

Only exactly `1.4.2`

Answer

Any version greater than or equal to `1.4.2`

Question 19

Which versions does the range `~1.4.2` accept?

Accepted Answer

`>=1.4.2` and `<1.5.0`

Answer

`>=1.4.2` and `<2.0.0`

Answer

`>=1.0.0` and `<2.0.0`

Answer

Only `1.4.x` versions below `1.4.2`

Question 20

Why should `package-lock.json` be committed?

Accepted Answer

So the exact versions of the whole dependency tree match in every environment

Answer

So npm can download packages without an internet connection

Answer

Because `npm start` won't run without it

Answer

So the `package.json` scripts are duplicated there

Question 21

Which package typically belongs in `devDependencies`?

Accepted Answer

A test tool like `jest` or a linter like `eslint`

Answer

A web framework like `express` that the server runs on

Answer

A database driver like `pg` needed in production

Answer

A logging library like `pino` used at runtime

Question 22

What is the error-first callback pattern in Node?

Accepted Answer

The callback's first argument is an error (or `null`), followed by results

Answer

You pass an error callback first, then a separate success callback

Answer

The function throws first, then calls the callback

Answer

The callback is invoked only when an error occurs

Question 23

What does `util.promisify` do?

Accepted Answer

Turns an error-first callback function into one that returns a Promise

Answer

Converts a Promise into a callback-based function

Answer

Runs a synchronous function on a worker thread

Answer

Cancels all pending Promises

Question 24

What does calling `f()` return for `async function f() { return 5; }`?

Accepted Answer

A Promise that resolves to `5`

Answer

The number `5` directly

Answer

`undefined`, since there's no `await`

Answer

A generator that yields `5`

Question 25

How do you handle a Promise rejection inside an async function?

Accepted Answer

Wrap the `await` in a `try/catch`

Answer

Call the Promise inside `try/catch` without `await`

Answer

Use `process.on('error')`

Answer

Async errors are ignored automatically

Question 26

What happens if one Promise inside `Promise.all` rejects?

Accepted Answer

`Promise.all` rejects right away with that error, but the others aren't cancelled

Answer

It waits for all and returns an array of results and errors

Answer

The rejected one is skipped and the remaining results are returned

Answer

The other Promises are automatically cancelled and freed

Question 27

What does `const e = new EventEmitter(); e.emit('x'); e.on('x', () => console.log('hi'));` print?

Accepted Answer

Nothing; the listener was registered after the emit

Answer

`hi`, because events are buffered until a listener exists

Answer

An error, because the event was emitted with no listener

Answer

`hi` on the next event loop tick

Question 28

How are EventEmitter listeners run when you call `emit`?

Accepted Answer

Synchronously, in the order they were registered

Answer

Asynchronously, in the event loop's check phase

Answer

In parallel on the thread pool

Answer

In reverse registration order, as microtasks

Question 29

What happens if an EventEmitter emits `'error'` with no `'error'` listener?

Accepted Answer

The error is thrown and, if uncaught, crashes the process

Answer

The error is silently ignored

Answer

Only a warning is printed to the console

Answer

The event is queued until a listener is added

Question 30

What is `Buffer` used for in Node?

Accepted Answer

Holding and manipulating fixed-size raw binary data

Answer

Queueing HTTP requests until the server is free

Answer

Caching `console.log` output for speed

Answer

Storing JavaScript strings in UTF-16 encoding

Question 31

What is `Buffer.from('é').length`?

Accepted Answer

`2`

Answer

`1`

Answer

`4`

Answer

`undefined`

Question 32

What are the four fundamental stream types in Node?

Accepted Answer

Readable, Writable, Duplex and Transform

Answer

Input, Output, Buffer and Pipe

Answer

File, Network, Memory and Process

Answer

Sync, Async, Parallel and Serial

Question 33

When sending a 4 GB file to a client, why is `fs.createReadStream` better than `fs.readFile`?

Accepted Answer

It reads data in chunks instead of loading the whole file into memory

Answer

It automatically compresses the file before sending

Answer

It uses multiple CPU cores to read in parallel

Answer

It always bypasses the disk by using the OS cache

Question 34

What's wrong with calling `fs.readFileSync` inside an HTTP request handler?

Accepted Answer

It blocks the event loop until done, so every other request waits

Answer

It isn't allowed in HTTP handlers and throws

Answer

It always returns base64 instead of UTF-8

Answer

It slows only that request and doesn't affect others

Question 35

What's the modern way to read a file asynchronously with `async/await`?

Accepted Answer

`const data = await readFile(p, 'utf8')` imported from `node:fs/promises`

Answer

`const data = await fs.readFileSync(p, 'utf8')`

Answer

`const data = fs.readFile(p, 'utf8')` with no callback

Answer

`const data = await require(p)`

Question 36

What's the difference between `path.join` and `path.resolve`?

Accepted Answer

`resolve` always yields an absolute path; `join` just concatenates and normalizes

Answer

`join` always yields an absolute path; `resolve` just concatenates segments

Answer

`resolve` checks the file exists on disk, while `join` doesn't

Answer

There's no difference; they're aliases

Question 37

What does `path.extname('archive.tar.gz')` return?

Accepted Answer

`'.gz'`

Answer

`'.tar.gz'`

Answer

`'gz'`

Answer

`'tar.gz'`

Question 38

In `http.createServer((req, res) => { res.write('hi'); })`, why does the client keep waiting?

Accepted Answer

Because `res.end()` is never called, so the response never finishes

Answer

Because you must set a status with `res.status` before `write`

Answer

Because `res.write` only accepts binary data

Answer

Because the server ignores requests until `listen` is called again

Question 39

What is the type of `process.env.PORT` when running `PORT=3000 node app.js`?

Accepted Answer

The string `'3000'`

Answer

The number `3000`

Answer

A Buffer containing `3000`

Answer

`undefined`, since env is only read from `.env`

Question 40

Running `node app.js --verbose`, what is `process.argv[2]`?

Accepted Answer

`'--verbose'`

Answer

The full path to `app.js`

Answer

The path to the `node` executable

Answer

`true`

Question 41

What does a non-zero exit code from a Node process mean?

Accepted Answer

The process ended with an error or failure

Answer

The process succeeded and produced output

Answer

The process is still running in the background

Answer

The number of lines written to stdout

Question 42

What is Node's equivalent of the browser's `window` object?

Accepted Answer

`global` (and the standard `globalThis`)

Answer

`process`

Answer

`module`

Answer

`document`

Question 43

Which option restarts your app on file changes without installing anything extra?

Accepted Answer

`node --watch app.js`

Answer

`node --reload app.js`

Answer

`npm watch app.js`

Answer

`node --hot app.js`

Question 44

What does `npx` do?

Accepted Answer

Runs a package's binary, temporarily downloading it if missing

Answer

Installs a package globally and adds it to PATH

Answer

Publishes a package to the npm registry

Answer

Upgrades outdated dependencies to their latest versions

Question 45

Why can a `package.json` script call `eslint .` without eslint installed globally?

Accepted Answer

npm adds `node_modules/.bin` to PATH while running scripts

Answer

npm also installs every package globally during install

Answer

Node auto-downloads unknown commands from npm

Answer

Scripts run inside V8 rather than a shell

Question 46

In Express middleware, what happens if you neither call `next()` nor send a response?

Accepted Answer

The request hangs until the client times out

Answer

Express automatically moves to the next middleware

Answer

Express automatically sends a `404`

Answer

Express automatically sends a `500`

Question 47

Why is `req.body` `undefined` in an Express POST route?

Accepted Answer

Because no body-parsing middleware like `app.use(express.json())` is registered

Answer

Because Express only supports GET requests

Answer

Because the body must be read from `req.params`

Answer

Because `req.body` exists only in Express 5

Question 48

For route `/users/:id` and request `/users/7?sort=asc`, where are `7` and `asc`?

Accepted Answer

`req.params.id` and `req.query.sort`

Answer

`req.query.id` and `req.params.sort`

Answer

`req.body.id` and `req.body.sort`

Answer

`req.headers.id` and `req.headers.sort`

Question 49

Why does a Node script with a `setInterval` never exit on its own?

Accepted Answer

An active interval keeps the event loop alive until `clearInterval` or `unref`

Answer

Because `setInterval` spawns a new OS thread

Answer

Because Node always runs scripts as daemons

Answer

Because intervals run until memory fills, then stop

Question 50

What does `const cfg = require('./config.json')` do in CommonJS?

Accepted Answer

Parses the file once and caches the resulting object

Answer

Throws, because `require` only accepts `.js` files

Answer

Returns the raw file contents as a string

Answer

Re-reads the file from disk on every call to pick up changes