Node.js Quiz ( Intermediate ) - All Questions

This intermediate-level Node.js quiz is designed for developers who understand the basics and want to test real-world, applied concepts. It focuses on asynchronous behavior, event loop internals, modules, streams, error handling, and backend design patterns commonly asked in interviews.

Question 1: How does Node.js handle multiple concurrent requests?

By creating a new thread for each request
By using the event loop and non-blocking I/O
By running synchronous code
By using worker threads only

Explanation: Node.js uses an event-driven, non-blocking I/O model to handle concurrency.

Question 2: What is the main purpose of the Event Loop?

Execute synchronous code only
Manage memory allocation
Handle asynchronous callbacks
Create child processes

Explanation: The event loop processes asynchronous callbacks in Node.js.

Question 3: Which phase of the event loop handles setTimeout callbacks?

Poll phase
Check phase
Timers phase
Close callbacks phase

Explanation: setTimeout callbacks are executed in the timers phase.

Question 4: What is the difference between setImmediate and setTimeout(fn, 0)?

They behave exactly the same
setImmediate runs in the check phase
setTimeout runs before I/O events
setImmediate blocks the event loop

Explanation: setImmediate callbacks run in the check phase of the event loop.

Question 5: Which API is used to create child processes in Node.js?

cluster
worker_threads
child_process
os

Explanation: The child_process module allows spawning new processes.

Question 6: What problem does the cluster module solve?

Memory leaks
Single-core CPU usage
Slow file access
Event loop blocking

Explanation: Cluster enables Node.js to use multiple CPU cores.

Question 7: Which statement about Node.js is true?

It is multi-threaded by default
It blocks on I/O operations
It uses a single-threaded event loop
It cannot scale

Explanation: Node.js uses a single-threaded event loop with async I/O.

Question 8: What is backpressure in Node.js streams?

Excess memory usage
Slow network requests
When writable stream cannot handle data speed
Event loop delay

Explanation: Backpressure occurs when data is produced faster than it can be consumed.

Question 9: Which stream type is fs.createReadStream?

Writable
Readable
Duplex
Transform

Explanation: fs.createReadStream creates a readable stream.

Question 10: What is a Transform stream?

Only reads data
Only writes data
Modifies data while streaming
Buffers entire data

Explanation: Transform streams modify data as it passes through.

Question 11: Which method connects readable and writable streams?

connect()
join()
pipe()
link()

Explanation: pipe() connects readable streams to writable streams.

Question 12: Why are streams preferred over fs.readFile for large files?

They are easier to write
They consume less memory
They block the event loop
They are synchronous

Explanation: Streams process data in chunks, reducing memory usage.

Question 13: What does util.promisify do?

Converts promises to callbacks
Converts callbacks to promises
Handles errors automatically
Improves performance

Explanation: util.promisify converts callback-based functions into promises.

Question 14: Which error type is thrown for synchronous code?

Promise rejection
Callback error
Try-catch error
Event error

Explanation: Synchronous errors can be caught using try-catch.

Question 15: How should async errors be handled with async/await?

if-else blocks
try-catch
callbacks
event listeners

Explanation: Async errors are handled using try-catch with async/await.

Question 16: What happens if an unhandled promise rejection occurs?

Node ignores it
Node crashes silently
Node emits a warning or crashes
It is automatically retried

Explanation: Unhandled promise rejections can cause warnings or crashes.

Question 17: Which object is used to emit and listen to custom events?

Stream
EventEmitter
Process
Callback

Explanation: EventEmitter is used for custom event handling.

Question 18: What does process.nextTick do?

Runs code in the timers phase
Schedules a macro task
Executes before the event loop continues
Delays execution

Explanation: process.nextTick runs callbacks before the next event loop phase.

Question 19: Which API provides multi-threading in Node.js?

cluster
child_process
worker_threads
events

Explanation: worker_threads enable true multi-threading.

Question 20: When should worker threads be used?

For I/O tasks
For CPU-intensive tasks
For routing
For async callbacks

Explanation: Worker threads are ideal for CPU-heavy computations.

Question 21: Which statement about require cache is true?

Modules are reloaded every time
Modules are cached after first load
Cache cannot be cleared
Cache only works for JSON

Explanation: Node.js caches modules after the first require.

Question 22: How can you share data between modules safely?

Using global variables
Using module exports
Using environment variables only
Using process.argv

Explanation: module exports allow controlled data sharing.

Question 23: Which pattern helps structure large Node.js applications?

Spaghetti code
MVC
Inline scripting
Monolithic functions

Explanation: MVC helps organize code cleanly.

Question 24: What does middleware typically do in Node.js frameworks?

Render UI
Handle requests before controllers
Manage databases
Compile code

Explanation: Middleware processes requests before final handlers.

Question 25: Which HTTP status code indicates a client error?

Explanation: 4xx status codes represent client errors.

Question 26: What is the main benefit of using async/await?

Faster execution
Cleaner asynchronous code
Multi-threading
Better memory usage

Explanation: Async/await improves readability of async code.

Question 27: Which object provides information about the current process?

global
module
process
runtime

Explanation: process contains runtime information.

Question 28: What does process.exit(1) indicate?

Successful exit
Restart process
Error exit
Paused execution

Explanation: A non-zero exit code indicates an error.

Question 29: Why should blocking code be avoided in Node.js?

It increases memory
It blocks the event loop
It breaks modules
It causes syntax errors

Explanation: Blocking code prevents handling other requests.

Question 30: Which approach improves Node.js application performance?

Using synchronous APIs
Blocking the event loop
Using streams and async I/O
Heavy computation on main thread

Explanation: Async I/O and streams improve performance.

Question 31: Which module helps manage environment variables securely?

fs
dotenv
path
crypto

Explanation: dotenv loads environment variables securely.

Question 32: What does the Buffer class handle?

Text data
Binary data
HTML data
JSON data

Explanation: Buffers handle raw binary data.

Question 33: Which statement about Node.js memory is true?

Unlimited memory by default
Managed by V8 garbage collector
Manual memory allocation only
Not garbage collected

Explanation: V8 manages memory using garbage collection.

Question 34: Which HTTP method is idempotent?

POST
PATCH
PUT
CONNECT

Explanation: PUT is idempotent by design.

Question 35: What is the role of package-lock.json?

Defines scripts
Locks dependency versions
Stores environment variables
Runs npm commands

Explanation: package-lock.json ensures consistent installs.

Question 36: Which tool helps monitor Node.js application performance?

npm
PM2
nodemon
eslint

Explanation: PM2 helps monitor and manage Node.js apps.

Question 37: Why is nodemon used during development?

Optimize production builds
Restart server on file changes
Improve security
Handle clustering

Explanation: nodemon restarts the server automatically.

Question 38: Which concept allows handling many connections with few resources?

Thread pooling
Blocking I/O
Event-driven architecture
Synchronous execution

Explanation: Event-driven architecture enables scalability.

Question 39: What does process.on('exit') allow you to do?

Restart app
Run cleanup code
Handle HTTP requests
Catch async errors

Explanation: It allows cleanup before process exit.

Question 40: Which scenario is NOT suitable for Node.js?

Real-time apps
API servers
CPU-heavy image processing
Streaming services

Explanation: CPU-heavy tasks block the event loop.

Question 41: Which module helps generate hashes?

fs
hash
crypto
buffer

Explanation: crypto provides hashing functionality.

Question 42: What does asynchronous programming mainly improve?

Code size
Responsiveness
Syntax simplicity
Thread safety

Explanation: Async programming improves responsiveness.

Question 43: Which pattern helps avoid callback hell?

Nested callbacks
Promises and async/await
Global variables
Synchronous APIs

Explanation: Promises and async/await flatten async code.

Question 44: Which file typically contains application startup logic?

package.json
index.js
README.md
node_modules

Explanation: index.js often acts as the entry point.

Question 45: What is the main goal of Node.js architecture?

High CPU usage
Efficient handling of I/O
Complex threading
Client-side rendering

Explanation: Node.js is designed for efficient I/O handling.

Back to programming Quizzes

Node.js Quiz ( Intermediate )

Questions

~10

Minutes

Min Limit