JavaScript MCQ

Explanation

let declares a block-scoped variable. const is also block-scoped but cannot be reassigned. var is function-scoped and hoisted.

Explanation

typeof null returns "object" — a historical bug in JavaScript that persists for backward compatibility.

Explanation

Floating-point arithmetic: 0.1 + 0.2 = 0.30000000000000004. Use Math.abs(result - 0.3) < Number.EPSILON for comparison.

Explanation

=== (strict equality) checks both value and type without coercion. 1 === "1" is false. == uses type coercion.

Explanation

Closures capture variables from enclosing scopes. function counter() { let n=0; return () => n++; } — the inner function closes over n.

Explanation

[...arr1, ...arr2] merges arrays. f(...args) passes array elements as arguments. {...obj, key: val} creates a new object with spread properties.

Explanation

When you click a button, the click event bubbles up from the button to its parent, grandparent, and so on. Call event.stopPropagation() to prevent bubbling.

Explanation

map() creates a new array. [1,2,3].map(x => x*2) returns [2,4,6]. The original array is not modified.

Explanation

var declarations and function declarations are hoisted. var is initialized to undefined; function declarations are fully hoisted. let/const are hoisted but not initialized (TDZ).

Explanation

let x; console.log(x) is fine, but console.log(x) before let x = 5 throws ReferenceError due to TDZ.

Explanation

Promises have three states: pending, fulfilled, and rejected. Chain with .then() and .catch(). Use async/await for cleaner syntax.

Explanation

JavaScript sets uninitialized variables to undefined. null is explicitly assigned to represent "no value." typeof undefined === "undefined"; typeof null === "object".

Explanation

[1,2,3,4].filter(x => x % 2 === 0) returns [2,4]. The original array is unchanged.

Explanation

Arrow functions don't have their own this. They capture this from the surrounding context, which avoids the classic callback this-binding problem.

Explanation

JSON.stringify({ a: 1 }) returns '{"a":1}'. JSON.parse() does the reverse. Functions and undefined values are omitted.

Explanation

When accessing a property, JS searches the object, then its prototype, then the prototype's prototype, up to null. This chain enables inheritance.

Explanation

[1,2,3].reduce((acc, x) => acc + x, 0) returns 6. The second argument is the initial accumulator value.

Explanation

(function() { /* code */ })() or (() => { /* code */ })() executes immediately. Used to avoid polluting global scope.

Explanation

event.preventDefault() stops default actions like form submission or anchor navigation while still allowing the custom handler to run.

Explanation

NaN is of type "number" but represents invalid computations like 0/0 or parseInt("abc"). Use Number.isNaN() to check (typeof does not work reliably).

Explanation

typeof function(){} returns "function". Functions are objects in JS but have a special typeof value.

Explanation

const { name, age } = user; or const [a, b] = arr; unpack values concisely.

Explanation

[5, 12, 8].find(x => x > 10) returns 12. findIndex() returns the index. filter() returns all matches.

Explanation

for (const v of [1,2,3]) gives values 1,2,3. for (const k in {a:1}) gives key "a". Avoid for...in on arrays due to inherited properties.

Explanation

`Hello, ${name}! You are ${age} years old.` is a template literal. They support multi-line and tagged template literals.

Explanation

user?.address?.city returns undefined (not TypeError) if user or address is null/undefined.

Explanation

1 == "1" is true (coercion); 1 === "1" is false. Always prefer === to avoid surprising coercion results.

Explanation

Object.keys({ a:1, b:2 }) returns ["a", "b"]. Object.values() returns [1,2]. Object.entries() returns [["a",1],["b",2]].

Explanation

new Set([1,2,2,3]) stores {1,2,3}. Sets support .add(), .has(), .delete(), .size, and are iterable.

Explanation

Map supports any key type (including objects), maintains insertion order, and has methods .get(), .set(), .has(), .delete().

Explanation

async function f() { const result = await fetchData(); } pauses at await without blocking the thread.

Explanation

Array.isArray([]) returns true. typeof [] returns "object", so Array.isArray() is the reliable way to check for arrays.

Explanation

const label = age >= 18 ? "adult" : "minor"; is a concise alternative to if/else.

Explanation

const prevents reassignment (not mutation). let and const are block-scoped with TDZ. var is function-scoped and should be avoided.

Explanation

"a,b,c".split(",") returns ["a","b","c"]. split("") returns an array of individual characters.

Explanation

new MyClass() creates an object, sets its __proto__ to MyClass.prototype, calls the constructor, and returns the new object.

Explanation

JavaScript is single-threaded. The event loop picks tasks from the queue (macrotasks, microtasks) and executes them when the call stack is empty.

Explanation

Object.assign({}, obj1, obj2) creates a shallow merge. It mutates and returns the target object.

Explanation

const sym = Symbol("desc"); creates a unique value. Symbol("a") !== Symbol("a"). Used for unique object property keys and protocol methods like Symbol.iterator.

Explanation

[1,2,3].some(x => x > 2) returns true. every() checks all elements. some() short-circuits on first match.

Explanation

After each macrotask, the entire microtask queue drains before the next macrotask runs. This means Promise .then() callbacks run before setTimeout callbacks.

Explanation

WeakMap keys must be objects. When the object is collected, the entry is removed automatically. WeakMap is not enumerable.

Explanation

function* gen() { yield 1; yield 2; } creates an iterator. Call gen().next() to get { value: 1, done: false }.

Explanation

const add = a => b => a + b; add(2)(3) returns 5. Currying enables partial application and functional composition.

Explanation

Object.freeze(obj) prevents mutation in strict mode (silently fails in non-strict). It is shallow — nested objects can still be mutated.

Explanation

f.call(ctx, a, b), f.apply(ctx, [a, b]) invoke f with ctx as this. f.bind(ctx, a) returns a new function with this permanently set.

Explanation

JS uses prototypal inheritance. ES6 classes are syntactic sugar over prototype chains. Object.create(proto) creates an object with proto as its prototype.

Explanation

Memoization trades memory for speed. const memo = {}; if (memo[n]) return memo[n]; ... memo[n] = result; return result;

Explanation

new Proxy(target, { get(t, k) { return Reflect.get(t, k); } }) intercepts property reads. Used for validation, logging, and reactive state.

Explanation

const shallow = { ...obj } shares nested object references. Deep copy: structuredClone(obj) (modern) or JSON.parse(JSON.stringify(obj)) (limited).

Explanation

Promise.all([p1, p2, p3]) resolves with an array of results. If any promise rejects, the whole thing rejects. Use Promise.allSettled for no-fail behavior.

Explanation

race() is first-settled (could be a rejection). any() ignores rejections and resolves with the first success, rejecting with AggregateError if all fail.

Explanation

The module pattern uses closures to create private state. ES6 modules (import/export) provide built-in module support.

Explanation

Implementing [Symbol.iterator]() on an object allows it to be used in for...of loops, spread, and destructuring.

Explanation

structuredClone() deep-copies objects including Date, Map, Set, ArrayBuffer, and circular references — unlike JSON.parse(JSON.stringify()).

Explanation

WeakRef allows checking if an object is still alive without preventing GC. Call .deref() — it returns the object or undefined if collected.

Explanation

const name = user.name ?? "Anonymous"; only falls back for null/undefined, not 0 or "" (unlike ||). Use ??= for assignment: x ??= default.

Explanation

Object.create(null) is a truly empty object with no inherited methods like hasOwnProperty, toString. Useful for safe dictionaries with no prototype interference.

Explanation

sql`SELECT * FROM users WHERE id = ${id}` calls sql(strings, id). Used by styled-components, graphql-tag, and SQL query builders.

Explanation

const registry = new FinalizationRegistry(value => { /* cleanup */ }); registry.register(obj, heldValue); fires callback when obj is GC'd.

Explanation

for...of loops can be exited with break or return, and work with any iterable (Set, Map, generator). forEach cannot be interrupted without throwing.

Explanation

Array.from("abc") = ["a","b","c"]. Array.of(3) = [3] (not [undefined, undefined, undefined] like new Array(3)).

Explanation

for await (const chunk of stream) processes a ReadableStream. Async iterables implement [Symbol.asyncIterator](). Used with streams, paginated APIs.

Explanation

Object.entries(obj).map(([k, v]) => [k, transform(v)]) then Object.fromEntries(...) is a common pattern for transforming object values.

Explanation

new Proxy({}, { set(t, k, v) { if (typeof v !== "number") throw TypeError(); return Reflect.set(t, k, v); } }) validates all assignments.

Explanation

Reflect.ownKeys(obj) = Object.getOwnPropertyNames(obj) + Object.getOwnPropertySymbols(obj). Complete low-level key introspection.

Explanation

An iframe in the same origin has a different realm. obj instanceof Array fails for arrays created in the iframe. Use Array.isArray() for cross-realm safety.

Explanation

throw new Error("fetch failed", { cause: originalError }) links errors. Access via err.cause, enabling better debugging of wrapped errors.

Explanation

a ||= b assigns b to a only if a is falsy. a ??= b assigns if a is null/undefined. a &&= b assigns if a is truthy.

Explanation

arr.at(-1) returns the last element. arr[arr.length-1] is equivalent but verbose. Also works on strings and TypedArrays.

Explanation

Object.hasOwn(obj, "key") is equivalent to Object.prototype.hasOwnProperty.call(obj, "key") but works correctly on objects with no prototype (Object.create(null)).

Explanation

The Structured Clone Algorithm cannot clone functions. Attempting to clone { fn: () => {} } throws DataCloneError. Plain data objects and most builtins work.

Explanation

[Symbol.toPrimitive](hint) { if (hint === "string") return "text"; return 42; } provides full control over coercion in different contexts.

Explanation

Temporal provides immutable, timezone-correct date-time types, fixing problems with Date: timezone handling, month numbering, and mutability.

Explanation

const { promise, resolve, reject } = Promise.withResolvers() replaces the deferred pattern. Useful when resolve/reject must be called from different places.

Explanation

function* gen() { yield* [1,2,3,4,5]; } gen().filter(x => x > 2).take(2).toArray() — lazy iterator operations without materializing to array first.

Explanation

Object.groupBy([{type:"a"},{type:"b"},{type:"a"}], x => x.type) returns { a: [...], b: [...] }. Map.groupBy() does the same for Map results.

Explanation

/[A-Z&&[^AEIOU]]/v matches uppercase consonants using set intersection. The v flag extends u flag with character class set algebra.

Explanation

@logged class Foo { @bound onClick() {} } — TC39 stage 3 decorators work differently from TypeScript decorators (legacy). They receive descriptor objects, not constructor/prototype.

Explanation

[1,2,3].flatMap(x => [x, x*2]) = [1,2,2,4,3,6] in one pass. .map().flat(1) does two iterations over the array.

Explanation

V8 assigns hidden classes (shapes) to objects with the same property sequence. Adding properties in a consistent order lets V8 optimize property access via static offsets.

Explanation

JavaScript is single-threaded. Browser Web APIs handle async work. Callbacks are placed in macrotask/microtask queues and processed by the event loop when the stack empties.

Explanation

Each realm has its own Array, Object, etc. An array from another realm fails instanceof Array in the main realm — use Array.isArray() for cross-realm checks.

Explanation

AbortController.signal is passed to fetch/streams/EventListeners. Calling controller.abort() cancels the operation. It is now available in Node.js as well.

Explanation

TCO was mandated by ES6 strict mode but only Safari implements it. A tail call is a function call as the last action with no further work after it returns.

Explanation

The Structured Clone Algorithm supports more types than JSON (Date, Map, Set, ArrayBuffer, circular refs) and is shared by structuredClone, postMessage, and storage APIs.

Explanation

Transferring an ArrayBuffer moves ownership to the worker (zero-copy). The original becomes detached. SharedArrayBuffer allows actual shared memory.

Explanation

Monomorphic ICs (one shape) are fastest. Polymorphic (few shapes) are acceptable. Megamorphic ICs (many shapes) degrade to slow hash lookups — keep object shapes consistent.

Explanation

Stage 0 is strawman; Stage 4 is finished (in the spec). Stage 3 is candidate (browsers start implementing). Features at Stage 3 are stable enough to use with transpilation.

Explanation

ESM is the standard. CJS is Node.js legacy. ESM enables tree shaking. ESM bindings are live (updating with the exported value). CJS require() is synchronous blocking.

Explanation

Number can't represent integers above 2^53-1 accurately. BigInt (42n) supports arbitrary size. BigInt and Number cannot be mixed in arithmetic without explicit conversion.

Explanation

JSON.stringify(obj, (k,v) => v instanceof Date ? v.toISO() : v) serializes dates. JSON.parse(str, (k,v) => /\d{4}-/.test(v) ? new Date(v) : v) restores them.

Explanation

V8 optimizes based on observed types. If an int-optimized function receives a string, it deoptimizes (bails out) back to bytecode interpretation. Avoid mixing types in performance-critical functions.

Explanation

The ECMAScript spec defines abstract operations. Engines may optimize freely as long as observable behavior (side effects, return values) matches. The spec itself runs on an abstract machine.

Explanation

Calling a base method in a derived constructor before super() that accesses the base's fields risks TDZ errors because field initialization happens as part of super().

Explanation

asyncLocalStorage.run({ requestId }, () => handler()) propagates requestId through all async continuations within that run, enabling request-scoped logging without prop drilling.

Explanation

V8 serializes compiled bytecode after a script's second visit to a page. Browsers store it alongside HTTP cache. Speeds up cold starts for large frameworks.

Explanation

worker_threads allow JavaScript code to run in parallel threads sharing SharedArrayBuffer. Unlike child_process, Workers share memory, making them efficient for CPU-bound work.

Explanation

WebAssembly.Memory grows in 64KB pages and exposes its underlying ArrayBuffer. JavaScript can read/write it directly. Can be declared as shared for multi-threaded WASM modules.

Explanation

({}) + [] = "[object Object]" when {} is an expression. At statement level, {} is a block and + [] = 0. This is one of JavaScript's most confusing coercion behaviors.