Interview 2 — JavaScript

JavaScript is a programming language; ECMAScript is the standard defining its core behavior.

They are separate languages. Similar names do not imply the same type system, runtime, or object model.

Undefined, null, boolean, number, bigint, string, and symbol.

Primitives are immutable values. Objects have identity and can contain mutable properties.

Values have types; a variable can hold values of different types over time.

Null usually expresses intentional absence; undefined commonly means a value has not been provided.

Use typeof for most primitives, Array.isArray for arrays, and value === null for null.

It is a historical language quirk. Null is still a primitive.

NaN represents an invalid numeric result. Number.isNaN(value) checks without coercion.

Number.isNaN checks the value directly; global isNaN converts it to a number first.

Falsy: false, 0, -0, 0n, empty string, null, undefined, NaN; also legacy document.all in browsers. Other values are truthy.

Yes. Their emptiness does not affect their boolean conversion.

A unique primitive often used as a property key or to customize built-in protocols.

For integers beyond Number's safe range. Most arithmetic cannot mix BigInt and Number directly.

Binary floating-point cannot represent these decimals exactly. Compare using a tolerance appropriate to the calculation.

Var is function- or global-scoped; let and const are block-scoped. Const prevents reassignment.

No. It prevents rebinding the variable; the object's properties may still change.

They determine where a binding is accessible: globally, within a function, or within a block.

A function's access to outer bindings depends on where it is defined in the source.

Declarations affect bindings before their source line runs; initialization rules differ by declaration type.

The period from entering a scope until a let, const, or class binding is initialized; accessing it throws.

An inner binding uses the same name as an outer binding, hiding it within that scope.

== may convert types; === compares without type coercion. Objects are compared by identity.

Object.is treats NaN as equal to itself and distinguishes +0 from -0.

JavaScript automatically converts a value for an operation, such as converting a number during string concatenation.

|| falls back for any falsy value; ?? falls back only for null or undefined.

?. returns undefined if the value being accessed is null or undefined, instead of continuing that access.

&&, ||, and ?? evaluate the right operand only when needed and return an operand value.

Rest collects remaining values; spread expands an iterable or copies an object's own enumerable properties.

Destructuring extracts values into bindings; template literals support interpolation and multiline strings.

A declaration initializes its function before execution in its scope; an expression creates a function when evaluated.

Arrows capture surrounding this and arguments, cannot be constructors, and have no own prototype property.

They can be assigned, passed as arguments, and returned from other functions.

A function that accepts functions, returns a function, or both.

A function passed to another operation to be invoked; callbacks can be synchronous or asynchronous.

A function together with access to its surrounding lexical bindings, even after the outer function returns.

For private state, configured callbacks, function factories, and remembering values between calls.

Callbacks share one var binding. Let creates a separate binding for each loop iteration.

A function expression called immediately, often to create a private scope.

A function whose result depends only on its inputs and that causes no observable side effects.

An observable change outside a function's returned value, such as mutation, logging, or a network request.

Transforming a function with multiple arguments into a sequence of functions taking one argument each.

Currying changes the calling structure; partial application fixes some arguments to produce a new function.

Caching results by input to avoid repeated work; consider cache size and changing dependencies.

A function calls itself on a smaller problem. Missing termination or excessive depth can overflow the stack.

By how it is called: as a method, constructor, explicit binding, or plain call.

Undefined, unless the function is bound; arrow functions instead capture their surrounding this.

The original receiver is lost unless the caller supplies it; bind it or wrap the call.

Call and apply invoke with a chosen this; apply takes array-like arguments. Bind returns a bound function.

Creates an object, links its prototype, and calls the constructor with that this; an explicit object return can replace it.

Property lookup checks an object, then successive prototypes, until a match or null.

The constructor's .prototype usually becomes the internal prototype of instances created with new.

Use Object.create(proto); Object.create(null) creates an object without a prototype.

Classes provide syntax and rules over prototype-based inheritance; instance methods normally live on the prototype.

Extends establishes inheritance; super accesses parent behavior and calls the parent constructor in a derived constructor.

Instance methods are called on instances; static methods are called on the class itself.

Fields beginning with # are only accessible from permitted code inside the declaring class.

Accessor functions that run when a property is read or assigned.

Normally, whether a constructor's prototype appears in the object's prototype chain; cross-realm checks can surprise you.

When behavior is easier to combine through smaller objects or functions than a rigid class hierarchy.

Arguments are passed by value. An object value is a reference: mutation is shared, parameter reassignment is not.

A shallow copy shares nested objects; a deep copy recreates supported nested data.

Use { ...object } or Object.assign({}, object); nested values remain shared.

To deeply clone supported data, including cycles, Maps, and Dates; functions and DOM nodes are not supported.

It loses unsupported values and types, fails on cycles, and normally throws on BigInt.

Use Object.hasOwn(object, key); the in operator also checks inherited properties.

Arrays of own enumerable string-keyed property names, values, or key-value pairs.

Use Object.fromEntries(iterableOfPairs).

Dot uses a fixed identifier; brackets accept an expression, including dynamic strings and symbols.

Use delete object.key; assigning undefined keeps the property present.

Both prevent adding or removing properties; freeze also makes data properties nonwritable. Both are shallow.

Metadata controlling writability, enumerability, configurability, or getter/setter behavior.

=== checks identity. Comparing contents requires a definition of equality and a suitable comparison function.

JSON is a text data format with limited types; objects are runtime values that can contain behavior.

Proxy intercepts object operations; Reflect provides functions for performing many of those operations.

Map transforms into a new array; forEach visits elements and returns undefined; filter selects matching elements.

Combines elements into an accumulator. An explicit initial value handles empty arrays safely.

Find returns the first match; findIndex its index; some checks any match; every checks all.

Slice copies a range; splice changes the original array by removing, replacing, or inserting elements.

Push, pop, shift, unshift, splice, sort, reverse, fill, and copyWithin.

Use numbers.sort((a, b) => a - b); default sorting compares string representations.

Use toSorted()/toReversed(), or copy first and then sort/reverse.

For...in visits enumerable string property keys, including inherited ones; for...of consumes iterable values.

Map accepts arbitrary keys, exposes size, and is directly iterable; object property keys are strings or symbols.

Storing unique values and checking membership; distinct objects remain distinct even with identical contents.

Weak collections do not keep their weakly held keys/values alive and cannot be enumerated.

Iterables provide an iterator; iterators return next results; generators use function* and yield to produce them.

No. String operations return new values; indexed assignment does not change a string.

Split turns a string into an array; join combines array elements; trim removes surrounding whitespace.

They describe text patterns. Use regex.test(text) for a boolean; match or exec for match details.

Synchronous steps finish in sequence; asynchronous operations allow a result to be handled later.

It represents an eventual outcome: pending, fulfilled, or rejected. Settled means fulfilled or rejected.

Yes. The function passed to new Promise runs immediately; .then handlers run asynchronously.

Each .then returns a new promise that adopts the handler's returned value or promise, or rejects if it throws.

Catch handles rejection; finally runs cleanup and normally preserves the outcome unless it throws or returns a rejecting promise.

Always a promise: returned values fulfill it; uncaught throws reject it.

Pauses that async function or module until a value settles; it does not block the whole JavaScript thread.

Use try/catch around awaited operations, or let rejection propagate to a caller that handles it.

Collects results in input order; rejects on the first rejection. It does not cancel the remaining operations.

Waits for all inputs to settle and returns each fulfillment value or rejection reason.

Race follows the first settlement; any follows the first fulfillment and rejects only if all reject.

Start them before awaiting their combined results, often with Promise.all.

ForEach ignores callback return values. Use for...of for sequencing or Promise.all(array.map(...)) for concurrency.

The chain cannot wait for that operation or track its outcome unless you return or otherwise handle it.

For fetch, pass an AbortSignal and call its controller's abort(). Promises themselves have no universal cancellation method.

One agent runs one piece of JavaScript at a time; hosts and workers can perform other work concurrently.

The stack of active function calls; a call pushes a frame, and returning removes it.

Coordinates queued work with JavaScript execution, letting asynchronous callbacks run when execution can proceed.

Timers and events queue tasks; promise reactions queue microtasks, drained at checkpoints before the next task.

No. It schedules a later task; current execution and queued microtasks run first.

No. The delay is a threshold; busy execution and browser throttling can postpone it.

SetInterval schedules repeatedly; recursive setTimeout can schedule the next run after the previous work completes.

For visual updates aligned with the browser's rendering cycle; use its timestamp for animation progress.

It blocks the main thread, delaying input, rendering, and callbacks.

A separate execution context for background JavaScript; it communicates through messages and cannot directly access the DOM.

Yes. Continually queueing microtasks can delay tasks and rendering.

Try runs code, catch handles thrown errors, and finally performs cleanup as control leaves the construct.

No. The callback runs later; catch inside it or propagate the error through a handled promise.

Error is general; TypeError signals an invalid type-related operation; ReferenceError signals an invalid binding reference.

It hides failures and can leave invalid state. Recover explicitly or report and propagate with useful context.

The browser's object representation of a document, which scripts can inspect and change.

QuerySelector returns the first match or null; querySelectorAll returns a static NodeList of matches.

A live collection updates with DOM changes; a static collection preserves its membership from query time.

TextContent handles text; innerText reflects rendered text; innerHTML parses or serializes markup.

Use document.createElement(), set properties, then append or insert it into the document.

Capturing travels toward the target; bubbling travels back through ancestors for events that bubble.

An ancestor handles descendant events, often using closest() to identify the relevant child.

Target identifies the event's target; currentTarget is the element whose listener is currently running.

PreventDefault cancels a cancelable default action; stopPropagation stops travel to other nodes.

It also prevents later listeners for that event on the same element.

Use removeEventListener with the same type, function, and capture value, or abort its registered signal.

It promises not to call preventDefault(), allowing the browser to handle actions such as scrolling without waiting for cancellation.

DOMContentLoaded follows parsing and deferred/module script execution; window load also waits for dependent resources such as images.

Async executes when ready without ordering guarantees; defer executes after parsing in document order, before DOMContentLoaded.

Debouncing groups nearby calls, often waiting for quiet; throttling limits execution frequency over time.

Await fetch, check response.ok, then await response.json(); handle request and parsing failures.

No. HTTP error responses normally fulfill it; check response.ok or status yourself.

Set method to POST, Content-Type to application/json, and body to JSON.stringify(data).

A browser protocol where server headers determine whether scripts may read cross-origin responses.

It usually produces an opaque response whose body and status JavaScript cannot read.

The combination of scheme, hostname, and port.

LocalStorage persists; sessionStorage is scoped to a tab's session; matching cookies can be sent automatically with requests.

For larger structured data and asynchronous transactions; localStorage is synchronous and stores strings.

Untrusted content executes as script in a site's context. Use safe text rendering and appropriate sanitization for allowed HTML.

It parses input as markup and can enable XSS. Use textContent for plain text.

A malicious site causes unwanted authenticated requests. Mitigations include appropriate SameSite cookies, CSRF tokens, and origin validation.

They restrict script access, transport to HTTPS, and cross-site sending, respectively.

Users can inspect downloaded code and requests. Keep privileged secrets on a trusted server.

Older responses may arrive later and overwrite newer results; cancel stale requests or check a request identifier.

Use bounded retries with backoff for suitable operations; avoid blindly repeating non-idempotent actions.

Files with explicit imports and exports, their own scope, and strict-mode behavior.

Named exports are imported by exported name; a default export can be given any local import name.

Static imports declare dependencies upfront; import() loads a module on demand and returns a promise.

ESM uses import/export and live bindings; CommonJS uses require/module.exports and typically loads synchronously.

A transpiler rewrites syntax; a polyfill supplies a missing runtime API.

Bundling combines modules; tree shaking removes unused code; code splitting separates code for selective loading.

It rejects some previously silent mistakes, forbids accidental globals, and changes plain-call this to undefined.

The engine reclaims memory that is no longer reachable; the exact timing is not guaranteed.

Unwanted reachable data, such as retained listeners, timers, detached DOM nodes, or unbounded caches.

Reproduce it, profile the bottleneck, measure a targeted change, and check for regressions.

Repeated DOM writes followed by layout reads can force extra layout; batch reads and writes.

They share the language but expose different host APIs: browsers provide the DOM; Node provides server and filesystem APIs.

Unit tests check small units; integration tests check interactions; end-to-end tests check complete user flows.

Return or await the operation, assert outcomes and failures, and control timers or external dependencies when needed.

Reproduce it, reduce the case, inspect state and stack traces, test a hypothesis, and verify the fix.

Use [...new Set(values)]; decide separately how object duplicates should be identified.

Accumulate counts in a Map, incrementing the count for each value.

Define normalization rules, then compare characters from both ends or compare with a reversed copy.

Normalize as required and compare character frequencies, or sort and compare their characters.

Use flat(depth), or recursively visit nested arrays. Choose whether all nesting should be flattened.

Keep a timer in a closure; clear it on each call, then schedule the callback with the latest arguments and receiver.

Track the last execution or a pending timer; define whether leading and trailing calls should run.

Return a function that closes over a local count and increments it on each call.

Accumulate arrays in a Map keyed by that property; append each object to its group.

'52' and 3. Addition concatenates when a string operand is involved; subtraction converts to numbers.

false, false. The arrays have different identities; NaN is not strictly equal to itself.

2. Both variables refer to the same object.

undefined. The var binding exists before its initializer runs.

A ReferenceError: x is accessed during its temporal dead zone.

A, D, C, B: synchronous logs, then the promise microtask, then the timer task.