Amazon Interview JavaScript Interview Questions

JavaScript is a high-level, interpreted programming language used to create interactive web pages.

• Runs on browsers for client-side scripting.
• Used on servers via Node.js.
• Powers mobile, desktop, and game applications.

• var: function-scoped, redeclarable, hoisted with undefined.
• let: block-scoped, cannot redeclare in same scope, hoisted but uninitialized.
• const: block-scoped, cannot reassign, must initialize.

Hoisting moves variable and function declarations to the top of their scope before execution. Only declarations are hoisted, not initializations.

Synchronous: Executes line-by-line and blocks.

Asynchronous: Non-blocking; uses callbacks, promises, async/await.

A closure is a function that retains access to its lexical scope even after the outer function has returned.

Primitive: String, Number, Boolean, Null, Undefined, Symbol, BigInt.

Non-primitive: Object, Array, Function.

== compares values with type coercion.

=== compares value and type strictly. Prefer strict equality.

The event loop handles asynchronous callbacks, allowing JavaScript to remain non-blocking despite being single-threaded.

null: explicitly assigned to indicate no value.

undefined: declared but not assigned.

Functions in JavaScript are treated as values, enabling assignment, passing as arguments, and returning from functions.

Declaration is hoisted and callable before definition; expression is assigned at runtime and not hoisted the same way.

this refers to current execution context. Arrow functions inherit this from their parent scope.

• call: invoke with arguments list.
• apply: invoke with arguments array.
• bind: returns a new function with bound this.

Every object has a prototype from which it can inherit methods and properties.

ES6 adds let/const, arrow functions, classes, modules, promises, destructuring, template literals, and more.

Promises represent asynchronous results with states: pending, fulfilled, rejected.

Async/await simplifies working with promises, making asynchronous code readable and sequential.

Shallow copy duplicates top-level properties; deep copy recursively duplicates all nested data.

Inside loop, let creates a new binding for each iteration, preventing closure-related bugs.

Event delegation uses a single parent listener to manage events for child elements using event bubbling.

Function scope: Variables declared with var are accessible throughout the function.

Block scope: Variables declared with let or const are limited to the enclosing braces {}.

Block scope reduces bugs and prevents variable leakage.

A closure is a function that retains access to its outer scope even after the outer function has finished executing.

Use cases: private variables, memoization, function factories, event handlers.

The DOM represents HTML as objects. JavaScript can select, modify, create, and remove elements using DOM APIs.

Bubbling: Events propagate from child to parent.

Capturing: Events propagate from parent to child.

Controlled using addEventListener(..., true).

• innerHTML: Reads/writes HTML.
• innerText: Visible text only, respects CSS.
• textContent: Raw text without parsing HTML.

Use backticks for multi-line strings and interpolation.

`Hello ${name}`

Arrow functions have shorter syntax, do not have their own this, and cannot be used as constructors.

Functions that receive or return other functions. Used in map, filter, reduce, and event handling.

• forEach: executes callback but returns undefined.
• map: returns a new transformed array.
• filter: returns items that match a condition.

setTimeout: runs code once after delay.

setInterval: runs repeatedly at intervals.

Synchronous DOM updates block rendering. Asynchronous updates use Promises or requestAnimationFrame to avoid UI jank.

A promise represents future completion. Chaining uses .then() and .catch() for sequential async workflows.

localStorage: persistent key-value.

sessionStorage: session-limited key-value.

cookies: small data sent with requests, used for auth.

Synchronous blocks the main thread; asynchronous uses callbacks/promises and does not block.

Browsers enforce CORS. Servers must send headers allowing specific origins.

Attach listener to parent instead of each child. Better performance and supports dynamic elements.

• call: invoke with this + args list.
• apply: invoke with this + args array.
• bind: returns a new function with bound this.

== compares with coercion; === compares type + value strictly.

null: intentional empty value.

undefined: declared but not assigned.

IIFEs run immediately after creation. They isolate scope and avoid global pollution.

ES6 modules allow splitting code into separate files using export and import.

• Better code organization
• No global namespace pollution
• Supports tree shaking for optimized builds