Previous Exam Questions on JavaScript

This topic gathers the kind of code-tracing and short-answer questions that recur across JavaScript course exams. Rather than testing definitions in isolation, most of these questions ask you to predict exact output or explain why a piece of code behaves the way it does — the same skill tested in technical interviews. Work through each one by tracing the code by hand before reading the given answer, then use the Quick Reference to review right before your exam.

javascript for (var i = 0; i < 3; i++) { setTimeout(() => console.log(i), 0); } for (let j = 0; j < 3; j++) { setTimeout(() => console.log(j), 0); } Output: 3, 3, 3, 0, 1, 2. With var, there is a single shared binding for i across all iterations, so by the time the callbacks run (after the loop finishes), i is 3 for all of them. With let, each iteration gets its own fresh binding for j, so each callback captures the value from its own iteration: 0, 1, 2`.

typeof [] → 'object' (arrays are objects); typeof {} → 'object'; typeof null → 'object' (a long-standing language quirk); typeof function(){} → 'function'; typeof undefined → 'undefined'. To distinguish an array from a plain object, use Array.isArray(value) rather than typeof.

javascript const result = [1, 2, 3, 4, 5] .map(n => n * 2) .filter(n => n > 4) .reduce((sum, n) => sum + n, 0); console.log(result); Trace: map doubles each value → [2, 4, 6, 8, 10]. filter keeps values greater than 4 → [6, 8, 10]. reduce sums them starting from 0 → 6 + 8 + 10 = 24. Output: 24`.

A function declaration (function foo() {}) is fully hoisted — it can be called before its textual position in the code. A function expression assigned to a variable (const foo = function() {} or const foo = () => {}) only hoists the variable binding (as undefined for var, or into the TDZ for let/const), not the function body, so calling it before the assignment line throws a TypeError (var) or ReferenceError (let/const).

Both evaluate to false. Objects (including arrays) are compared by reference, not by structural value, for both == and ===. Two separately created objects are never equal even if their contents are identical, unless they refer to the exact same object in memory.

javascript async function run() { console.log('start'); try { await Promise.reject(new Error('fail')); } catch (err) { console.log('caught:', err.message); } console.log('end'); } run(); console.log('after call'); Output: start, after call, caught: fail, end. The async function runs synchronously until the first await, printing start. Control then returns to the caller, which logs after call. Once the rejected promise settles (on a microtask), execution resumes inside the catch block, printing caught: fail, then end`.

javascript const a = { x: 1, y: 2 }; const b = { y: 5, z: 3 }; console.log({ ...a, ...b }); Output: { x: 1, y: 5, z: 3 }. Spread copies own enumerable properties in order; later sources overwrite matching keys from earlier ones, so b's y: 5 wins over a's y: 2`.

The bug occurs when a loop uses var and schedules a closure (e.g. a setTimeout callback) inside it — all closures share one i binding that ends at its final value. Fixes: (1) replace var with let, giving each iteration its own binding; or (2) wrap the loop body in an IIFE that takes i as a parameter, creating a new scope per iteration; or (3) use Array.prototype.forEach, whose callback parameter is a fresh binding per call.

javascript const original = { a: 1, nested: { b: 2 } }; const shallow = { ...original }; shallow.nested.b = 99; console.log(original.nested.b); Output: 99. Spread (and Object.assign) only copies top-level properties; nested objects are still shared by reference, so mutating shallow.nested.b also changes original.nested.b. A true deep copy (e.g. structuredClone(original)) would copy nested objects recursively, leaving original` untouched.

NaN === NaN evaluates to false — NaN is the only value in JavaScript that is not equal to itself, by IEEE 754 specification. The correct way to test for it is Number.isNaN(value), which checks strictly without type coercion (unlike the legacy global isNaN(), which coerces its argument to a number first, e.g. isNaN('foo') is true).