Node.js Essentials: JavaScript for the Backend

1. JavaScript was originally designed to run only inside a web browser. Why can Node.js run on a server?

• Node.js is a completely different language with new syntax designed specifically for server-side functionality.
• Node.js embeds V8 and libuv, giving JavaScript access to the OS and networking outside the browser.
• Node.js compiles JavaScript to C++ before execution, which enables server usage just like any other compiled program would.
• Browser vendors updated their JavaScript runtimes to natively support server-side execution and filesystem access.

2. How do you run a Node.js script named app.js?

• ./app.js
• python app.js
• node app.js
• node --execute app.js

3. A student from a C++ background says: ‘JavaScript is just a browser scripting language, it cannot power a real backend.’ What is the flaw in this argument?

• JavaScript is a compiled language and has always been able to run anywhere
• Node.js gives JavaScript OS-level access via libuv.
• JavaScript has better memory management than C++ for server applications
• The student is correct — Node.js is only suitable for front-end tooling

4. A Python student writes this JavaScript and gets a syntax error. What is wrong?

if score >= 60:
    console.log("Pass")
else:
    console.log("Fail")

• JavaScript requires parentheses around the condition (score >= 60) and braces {} around blocks — not colons and indentation
• JavaScript does not support if/else — use a ternary operator instead
• The only problem is the missing semicolons after each console.log() call
• console.log needs to be replaced with print() in JavaScript

5. What does this code print?

const items = ["a", "b", "c"];
for (const item of items) {
    console.log(item);
}

• 0, 1, 2 (the indices)
• a, b, c (the values, each on a new line)
• ["a", "b", "c"] (the entire array)
• An error — const cannot be used in a for loop

1. Why does 1 == '1' evaluate to true in JavaScript, when the same comparison in Python or C++ would be false?

• JavaScript’s == coerces the string '1' to the number 1 before comparing
• The string '1' and number 1 are actually the same type in JavaScript’s type system
• This is a known bug in older JavaScript engines that has since been patched in ES6
• == in JavaScript compares memory addresses, which happen to be equal for small values

2. A student writes let MAX_RETRY = 3 but never reassigns it in 200 lines of code. Why is const MAX_RETRY = 3 a better choice?

• const variables are stored in a faster memory region than let variables, improving runtime performance
• const prevents accidental reassignment and signals intent to readers
• let variables are automatically garbage collected, while const variables persist across function calls
• There is no practical difference — const and let behave identically for primitive values

3. What is the JavaScript equivalent of Python’s f-string f"Welcome, {name}! Score: {score}"?

• 'Welcome, ${name}! Score: ${score}'
• "Welcome, " + name + "! Score: " + score
• `Welcome, ${name}! Score: ${score}`
• "Welcome, %s! Score: %d" % (name, score)

4. The tutorial says to avoid var and always use let or const. Why?

• var is slower than let and const because V8 cannot optimize hoisted declarations
• var ignores block scope and hoists declarations, violating the scoping rules from C++ and Python
• var was removed from JavaScript in ES6, so it causes syntax errors in modern Node.js versions
• var and let are identical in behavior — the advice is purely a coding style preference

5. Your teammate’s Discord bot code has if (userRole == 'admin') and it works in all their tests. Should you flag this in code review? Why or why not?

• No — both sides are strings so == and === behave identically, and there is no risk to flag
• Yes — using == hides a habit of relying on coercion, and a future change to a numeric role ID would silently introduce a bug
• Yes — == is measurably slower than === at runtime due to the type coercion step, which impacts performance
• No — == and === are identical for same-type operands, and linters will only flag cross-type comparisons

1. What does it mean that functions are ‘first-class values’ in JavaScript?

• Functions execute faster than other value types at runtime due to JIT optimization
• Functions can be stored in variables, passed as arguments, and returned from other functions
• Functions must always be declared at the top of a file before any other values
• Functions have a special protected memory region that prevents garbage collection

2. In Python, sorted(items, key=lambda x: x['grade']) sorts by grade. Which JavaScript expression is the direct equivalent?

• items.sort(key = x => x.grade)
• items.sort((a, b) => a.grade - b.grade)
• items.sort(function key(x) { return x.grade; })
• items.sort(by='grade')

3. What does [1, 2, 3, 4, 5].filter(n => n > 3) return?

• [1, 2, 3]
• [4, 5]
• [true, true, true, false, false]
• 3 (the count of elements that pass)

4. A student writes numbers.filter(isEven) where isEven is a function. Why does this work without calling isEven() with parentheses?

• JavaScript automatically detects when parentheses are missing and adds them at runtime
• isEven without () is a reference to the function — .filter() calls it for each element
• .filter() accepts both function references and immediate function calls interchangeably
• This is a bug — passing isEven without parentheses gives .filter() the value undefined

5. [Spaced Practice: Revisit Step 2] A student declares let API_URL = 'https://api.school.edu' and never reassigns it. What change should they make, and why?

• Change let to var — var is the standard keyword for declaring constant URLs in Node.js
• Change let to const — the value never changes, so const prevents accidental reassignment
• No change needed — let and const are interchangeable for string values in JavaScript
• Wrap it in a function to protect it from being modified by other parts of the program

1. What does const { name, grade } = student do if student = { name: 'Alice', grade: 95 }?

• Creates a shallow copy of the student object containing only the name and grade properties
• Declares two variables: name = 'Alice' and grade = 95, extracted from the object
• Modifies the original student object so it only retains the name and grade properties
• Throws a TypeError — objects in JavaScript cannot be destructured into separate variables

2. What does [10, 20, 30].reduce((acc, n) => acc + n, 0) evaluate to?

• An array: [10, 20, 30]
• The number 60
• The number 30 (only the last element)
• An error — .reduce() requires at least 4 elements

3. What is the key difference between .map() and .filter()?

• .map() transforms every element (same-length result); .filter() selects elements (shorter or equal result)
• .map() modifies the original array in place; .filter() creates a new copy of the entire array
• .map() only works with objects and arrays; .filter() only works with numbers and strings
• There is no meaningful difference — they are interchangeable aliases for the same operation

4. Arrange the lines to compute the average grade from an array of student objects using destructuring, .map(), and .reduce(). (arrange in order)

1. const students = [{ name: 'A', grade: 80 }, { name: 'B', grade: 90 }];
2. const grades = students.map(({ grade }) => grade);
3. const sum = grades.reduce((acc, g) => acc + g, 0);
4. const avg = sum / grades.length;
5. console.log(avg.toFixed(1));

• const grades = students.filter(({ grade }) => grade);
• const sum = grades.reduce((acc, g) => acc + g);

5. [Spaced Practice: Revisit Step 3] A student writes const result = students.filter(s => s.grade >= 60).map(s => s.name). What does this expression produce?

• An array of the full student objects whose grade is at least 60
• An array of name strings for students with grade >= 60
• A single comma-separated string of all passing student names
• An error — .filter() and .map() cannot be chained together on the same expression

6. [Spaced Practice: Revisit Step 2] A function receives a user ID from a form field. The code uses if (userId == 42) to check for the admin. The ID arrives as the string '42'. Will this check correctly identify the admin? Should you keep it as-is?

• Yes, it works and is safe to keep — the comparison is correct and there is no risk
• Yes, it works via coercion, but use === with Number() to make the intent explicit
• No, == will return false here because strings and numbers are never equal in JavaScript
• No, the code will throw a TypeError at runtime

1. In app.get('/', (req, res) => { res.send('Hi'); }), what is the arrow function (req, res) => { ... }?

• A standalone function that runs immediately when the server file is first loaded into memory
• A callback that Express calls when someone visits the '/' URL
• A constructor that creates and configures a new Express route object for the path
• A middleware function that modifies the global Express application configuration

2. What do req and res represent in an Express route handler?

• req is the request from the user (URL, headers, data); res is the response you send back
• req is a requirement check; res is the resolution of that check
• req and res are Express configuration objects for the server
• req is the result of the previous route; res is the response from the database

3. Why does app.listen(3000) need to be called?

• It compiles all route handler functions into optimized machine code for faster HTTP processing
• It starts the server on port 3000 — without it, no requests reach your routes
• It validates that all routes are syntactically correct and have valid callbacks before starting
• It is optional — Express servers automatically begin listening when routes are first defined

4. [Spaced Practice: Revisit Step 3] Why is the Express route handler (req, res) => { ... } conceptually the same as the .filter() callback n => n > 2?

• Both are arrow functions, but they serve completely different purposes in practice
• Both are callbacks — you provide a function, and someone else calls it later
• Both modify the original data structure (the array / the HTTP request) in place
• Both must return a boolean value to determine what the caller does next

5. [Spaced Practice: Revisit Step 2] In the Express route res.send(Score: ${grade}), what JavaScript feature makes the ${grade} work?

• Regular string concatenation using the + operator applied automatically by V8
• Template literals — backtick strings with ${expression} interpolation
• A special Express templating engine that detects and processes ${} syntax at runtime
• Object destructuring that extracts the grade property from the enclosing scope

1. A developer has a route app.get('/students/:id', handler) and a student sends GET /students/3. Inside handler, they write if (req.query.id === '3'). What is wrong with their code and what should they write instead?

• Nothing is wrong — req.query.id and req.params.id are equivalent for URL path segments
• The 3 is a route parameter, so it lives in req.params.id, not req.query.id
• They should use req.body.id instead, because request bodies are more reliable than URLs
• The condition should use == instead of === when comparing route parameter strings

2. A route is defined as app.get('/users/:userId/posts/:postId', handler). What does req.params contain for GET /users/42/posts/7?

• { userId: 42, postId: 7 } (numbers)
• { userId: '42', postId: '7' } (strings)
• { id: '42/7' } (single concatenated string)
• { 0: '42', 1: '7' } (indexed array)

3. When should you use POST instead of GET?

• When you want the request to be processed faster by the Express event loop
• When sending data that creates/modifies a resource or is sensitive
• When the server is running on HTTPS instead of HTTP, since POST is required for encryption
• POST and GET are interchangeable — the distinction is purely a cosmetic convention

4. [Spaced Practice: Revisit Step 3] In app.get('/students', (req, res) => { ... }), if a student writes app.get('/students', handler()) with parentheses on handler, what goes wrong?

• Nothing — JavaScript treats handler and handler() identically in this context
• handler() calls the function now and passes the return value, not the function
• Express throws a TypeError because route handlers cannot be named function declarations
• The parentheses cause the route to match POST requests instead of GET requests

5. [Technique Selection — Interleaving] Match each Express data source to its use case:

• Task A: Filter a product list by category
• Task B: Retrieve a specific user by their ID
• Task C: Submit a new blog post with title and content

• A: req.params, B: req.query, C: req.body
• A: req.query, B: req.params, C: req.body
• A: req.body, B: req.params, C: req.query
• A: req.query, B: req.body, C: req.params

6. [Spaced Practice: Revisit Step 2] A Twitch-like streaming API has req.query.maxViewers as the string '500'. A developer writes if (stream.viewers < req.query.maxViewers). Will this comparison work correctly?

• Yes — JavaScript automatically converts the string to a number for the < comparison
• It works for most cases due to type coercion, but it is fragile. Convert explicitly with Number(req.query.maxViewers) to be safe and clear.
• No — comparing a number to a string always returns false in JavaScript
• No — this will throw a TypeError at runtime

1. Why is express.Router() better than putting all routes in one file?

• Routers execute routes faster because they have a separate Event Loop
• Routers organize related routes into modules — each file handles one domain (students, courses, professors), making the codebase maintainable
• Routers automatically add authentication to all routes
• Routes only work inside Routers — app.get() is deprecated

2. If router.get('/:id', handler) is mounted with app.use('/api/books', router), what full URL does the route match?

• /:id
• /api/books/:id
• /api/:id
• /books/:id

3. [Evaluate] A student forgets module.exports = router in studentRoutes.js but writes correct routes. When they send GET /api/students, they get Cannot GET /api/students. Why?

• The routes are syntactically invalid without the export statement at the bottom
• Without module.exports, require() returns an empty object — app.use() mounts nothing, so no routes match
• Express requires a special registerRouter() call instead of module.exports
• The missing export causes a runtime crash in app.js before the server starts

4. [Spaced Practice: Revisit Step 6] In a route handler, how do you access a query parameter ?sort=name vs. a URL parameter /students/42?

• Both use req.params — query and URL parameters are stored in the same object
• Query parameters use req.query.sort; URL parameters use req.params.id — they are separate objects
• Query parameters use req.body.sort; URL parameters use req.params.id
• Both use req.query — Express merges all parameter types into one object

5. [Technique Selection — Interleaving] For each Express operation, which method do you define on the router?

• Task A: Fetch a list of courses
• Task B: Create a new enrollment
• Task C: Get details for one specific course

• A: router.get('/'), B: router.post('/'), C: router.get('/:id')
• A: router.post('/'), B: router.get('/'), C: router.get('/:id')
• A: router.get('/'), B: router.get('/:id'), C: router.post('/')
• A: router.get('/:id'), B: router.post('/'), C: router.get('/')

6. [Spaced Practice: Revisit Step 3] Inside router.get('/', (req, res) => { ... }), what role does the arrow function play?

• It creates the router object
• It is a callback — the function that Express calls when a matching request arrives
• It defines the URL pattern for the route
• It configures the router’s middleware stack

7. [Evaluate] A teammate is building a quick 3-route prototype for a hackathon demo. They put all routes in app.js without using express.Router(). Should you ask them to refactor into a Router? Why or why not?

• Yes — routes must always use express.Router() or Express cannot process them correctly
• No — for a 3-route prototype, the organizational overhead of a Router is unnecessary. Routers pay off when the codebase grows to many routes across multiple domains
• Yes — app.get() is deprecated in modern Express and only router.get() is supported
• No — Routers are slower than app.get() because they add an extra layer of middleware processing

1. A developer writes setTimeout(sendEmail, 0) and expects sendEmail to fire instantly. Immediately after, a for loop runs 10 million iterations. What actually happens?

• sendEmail runs immediately because the delay parameter specifies exactly 0 milliseconds of wait time
• sendEmail runs in a separate worker thread while the for-loop continues in the main thread
• sendEmail waits in the Task Queue until the for-loop finishes and the call stack empties
• The for-loop is paused mid-iteration so the Event Loop can execute sendEmail first

2. What is the output order of this code?

console.log('A');
setTimeout(() => console.log('B'), 0);
console.log('C');

• A, B, C
• B, A, C
• A, C, B
• C, A, B

3. Two Express route handlers are registered: (A) app.get('/slow', ...) runs a 3-second synchronous loop. (B) app.get('/fast', ...) just calls res.send('ok'). A user hits /slow, and 0.5 seconds later another user hits /fast. Analyze what happens — when does the /fast user get their response?

• The /fast user gets an instant response — Express handles requests in separate threads
• The /fast user waits ~2.5s — the sync loop blocks the Call Stack
• Express detects the blocked route and automatically switches to the /fast handler
• The /fast user responds immediately because /fast was registered before /slow

4. [Spaced Practice: Revisit Step 5] An Express route handler has a 5-second synchronous loop. During those 5 seconds, 100 other requests arrive. What happens to them?

• Express spawns new worker threads to handle each of the 100 incoming requests in parallel
• All 100 requests wait — the call stack is occupied and no callbacks can run
• Express automatically drops stale requests and returns 503 Service Unavailable errors
• The other requests execute interleaved between iterations of the slow handler’s loop

5. [Technique Selection — Interleaving] You are building a Discord bot. For each of these tasks, which array method is the best fit?

• Task A: Get only the messages from a specific channel
• Task B: Convert each message object into a display string
• Task C: Count the total character length of all messages

• A: .map(), B: .filter(), C: .reduce()
• A: .filter(), B: .map(), C: .reduce()
• A: .reduce(), B: .filter(), C: .map()
• A: .filter(), B: .reduce(), C: .map()

6. [Spaced Practice: Revisit Step 7] Does express.Router() create a separate thread or Event Loop for handling its routes?

• Yes — each Router gets its own Event Loop, which is how Express handles concurrent requests efficiently
• No — Routers are a code organization tool. All routes still execute on the same single-threaded Event Loop
• Yes — but only when mounted with app.use(), which spawns a worker thread
• No — Routers bypass the Event Loop entirely and use synchronous processing

1. What does await actually do inside an async function?

• It blocks the entire Node.js process until the Promise resolves, like a synchronous call in C++
• It suspends only this async function and frees the call stack, letting the Event Loop process other work until the Promise resolves
• It creates a new thread to wait for the Promise, similar to std::thread in C++
• It converts the Promise into a synchronous value by canceling the async operation

2. Two independent API calls each take 100ms. Which approach is faster?

// Option A
const a = await fetchA();
const b = await fetchB();

// Option B
const [a, b] = await Promise.all([fetchA(), fetchB()]);

• Option A — sequential awaits are optimized by V8 to run in parallel
• Both are the same — await does not affect execution time
• Option B — Promise.all starts both operations concurrently, so total time is ~100ms instead of ~200ms
• Option A — Promise.all adds overhead that makes it slower for only two Promises

3. Arrange the lines to write an async Express route handler that fetches students from a database and returns them as JSON. (arrange in order)

1. app.get('/students', async (req, res) => {
2. try {
3. const students = await fetchFromDatabase();
4. res.json(students);
5. } catch (err) {
6. res.status(500).json({ error: err.message });
7. }
8. });

• const students = fetchFromDatabase();
• } finally {

4. [Spaced Practice: Revisit Step 8] What is the output order?

async function demo() {
    console.log('A');
    await new Promise(r => setTimeout(r, 0));
    console.log('B');
}
demo();
console.log('C');

• A, B, C
• A, C, B
• C, A, B
• A, B, C — await with 0ms resolves instantly

5. [Spaced Practice: Revisit Step 7] An Express Router has three async route handlers that each query a database. How many threads are used to execute these handlers?

• Three — one thread per route handler for parallel execution
• One — all route handlers execute on the single-threaded Event Loop, but await frees the call stack between database queries
• It depends on how many requests arrive simultaneously
• Zero — async functions run outside the main thread

6. [Spaced Practice: Revisit Step 3] In the Promise constructor new Promise((resolve, reject) => { ... }), what are resolve and reject?

• Global variables provided by Node.js for error handling
• Callbacks — functions passed as arguments that you call to signal success or failure
• Special keywords in JavaScript that only work inside Promise constructors
• Return values from the async operation that are automatically assigned