javascript

Understanding arrays in javascript

Promises represent eventual completion or failure of async operations with three states (pending, fulfilled, rejected), and async/await provides syntactic sugar for writing promise-based code that reads like synchronous code.

A closure is a function that retains access to variables from its outer (enclosing) scope even after the outer function has returned, enabled by JavaScript's lexical scoping.

A Single Page Application loads one HTML document and uses JavaScript to dynamically rewrite content and manage navigation via the History API, avoiding full page reloads.

ES6 introduced Map and Set as specialized alternatives to plain objects and arrays — Map allows any key type with guaranteed order, while Set stores unique values with O(1) lookups.

JavaScript has 7 primitive types (string, number, bigint, boolean, undefined, null, symbol) that are immutable and passed by value, plus Object as the non-primitive reference type.

Destructuring extracts values from arrays (by position) and objects (by property name) into variables. The spread operator (...) expands iterables, while the rest operator (...) collects remaining elements.

The Document Object Model (DOM) is a tree-structured programming interface that lets JavaScript read, modify, and respond to a web page's content, structure, and styles in real time.

JavaScript provides try/catch/finally for synchronous error handling and .catch() or try/catch with async/await for asynchronous errors, with built-in error types like TypeError, ReferenceError, and SyntaxError.

DOM events flow through three phases — capture, target, and bubble — and event delegation leverages bubbling to handle events on dynamic child elements with a single parent listener.

Arrow functions lexically bind 'this' from their enclosing scope and have concise syntax, while regular functions dynamically bind 'this' based on how they're called and can be used as constructors.

Generators are functions that can pause and resume execution using yield, producing values on demand. They implement the iterator protocol, enabling lazy evaluation, infinite sequences, and custom iteration with for...of.

Hoisting is JavaScript's behavior of moving declarations to the top of their scope during compilation — var is initialized as undefined, let/const enter a Temporal Dead Zone, and function declarations are fully available before their code position.

JavaScript automatically manages memory through garbage collection using a mark-and-sweep algorithm — objects are freed when they become unreachable from root references, but common patterns like forgotten timers and detached DOM nodes cause memory leaks.

Proxy intercepts fundamental operations on objects (property access, assignment, function calls) through handler traps, while Reflect provides the default behavior for each trap — together they enable validation, reactive systems, and transparent wrappers.

ES Modules use static import/export resolved at parse time (enabling tree-shaking), while CommonJS uses dynamic require()/module.exports resolved at runtime — ESM is the modern standard, but both coexist in 2025.

Objects are reference types — assigning or passing them shares the same memory reference. Shallow copies duplicate top-level properties while deep copies (structuredClone) create fully independent clones at all nesting levels.

== performs type coercion before comparison (loose equality), while === compares both value and type without coercion (strict equality). The ternary operator is an expression that returns a value, unlike if-else which is a statement.

Currying transforms a function with multiple arguments into a sequence of single-argument functions, while partial application fixes some arguments upfront and returns a function expecting the rest.

Debounce delays execution until a pause in events, while throttle limits execution to a fixed interval — both are essential for controlling high-frequency event handlers.

Every JavaScript object has an internal [[Prototype]] link forming a chain — property lookups walk this chain until found or null. ES6 classes are syntactic sugar over this prototypal inheritance model.

JavaScript is single-threaded with one call stack — the event loop enables async behavior by processing microtasks (promises) before macrotasks (setTimeout) between each cycle of the call stack.

JavaScript strings are immutable primitives with a rich set of built-in methods. Template literals (backticks) enable interpolation, multi-line strings, and tagged templates for custom processing.

The this keyword is dynamically bound based on how a function is called — four binding rules (new, explicit, implicit, default) determine its value, with arrow functions being the exception that inherits this lexically.

JavaScript automatically converts types during operations (implicit coercion) — the + operator favors strings, other arithmetic operators favor numbers, and there are exactly 8 falsy values.

var is function-scoped and hoisted with undefined, let is block-scoped and reassignable, const is block-scoped and cannot be reassigned — modern JavaScript favors const by default and let when reassignment is needed.

JavaScript uses lexical scoping where variable access is determined by code structure at write time — the engine walks up the scope chain from inner to outer scopes until it finds the variable or reaches the global scope.

An IIFE is a function expression that is defined and executed immediately. Before ES6 modules, IIFEs were the primary mechanism for creating private scope and avoiding global namespace pollution.

CORS (Cross-Origin Resource Sharing) is a browser-enforced security mechanism that uses HTTP headers to control whether JavaScript on one origin can access resources from a different origin.