• Arrow Function: Concise function syntax using =>, with lexical this binding.
• AST (Abstract Syntax Tree): Tree representation of source code structure.
• Async/Await: Syntactic sugar over Promises for writing async code that looks synchronous.

• BigInt: Numeric primitive for integers larger than 2⁵³-1.
• Block Scope: Variables declared with let/const are confined to {} blocks.
• Bubbling: Event propagation from target element up to the document root.

• Callback: Function passed as an argument to be executed later.
• Call Stack: LIFO data structure tracking function calls.
• Class: ES6 syntactic sugar over prototypal inheritance.
• Closure: Function that retains access to its lexical scope even after the outer function returns.
• Coercion: Implicit type conversion by JavaScript.
• Currying: Transforming f(a, b, c) into f(a)(b)(c).

• Debounce: Rate-limiting pattern that executes after a pause.
• Destructuring: Extracting values from arrays/objects into variables.
• DOM: Document Object Model — browser’s interface to HTML.
• Dynamic Import: import() for lazy-loading modules.

• Event Loop: Mechanism enabling async concurrency in single-threaded JS.
• Execution Context: Environment where JavaScript code is evaluated.
• Event Delegation: Single parent listener handling events for multiple children.

• First-Class Functions: Functions treated as values (assigned, passed, returned).
• Function Expression: Function assigned to a variable (not hoisted).

• Generator: Function (function*) that can be paused and resumed with yield.
• Garbage Collection: Automatic memory reclamation (mark-and-sweep in V8).

• Hoisting: JS behavior of moving declarations to scope top during compilation.
• Higher-Order Function: Function that takes or returns another function.
• Hidden Class: V8’s internal object shape tracking for optimization.

• IIFE: Immediately Invoked Function Expression — runs immediately after definition.
• IndexedDB: Client-side NoSQL database for structured data.
• Iterable: Object with Symbol.iterator method.
• Iterator: Object with next() method returning { value, done }.

• JIT (Just-In-Time): Compilation approach combining interpretation and compilation.

• Lexical Scope: Scope determined by code structure at author-time.
• LocalStorage: Persistent key-value storage (~5-10MB).

• Map: Collection with any key types, preserves insertion order.
• Microtask: High-priority task (Promise callbacks) processed before the next macrotask.
• Module: Encapsulated file with its own scope using import/export.

• NaN: “Not a Number” — result of invalid math operations.
• Nullish Coalescing: ?? — returns right side only for null/undefined.

• Optional Chaining: ?. — safe nested property access.
• Prototype: Internal reference for inheritance.

• Promise: Object representing eventual completion/failure of async operation.
• Pure Function: Function with no side effects, same input → same output.

• Reflow: Layout recalculation (expensive).
• Repaint: Visual update without layout changes.

• Set: Collection of unique values.
• Scope Chain: Hierarchy of scopes for variable resolution.
• Symbol: Unique, immutable primitive for property keys.
• SessionStorage: Storage cleared when tab closes.

• TDZ (Temporal Dead Zone): Period between let/const hoisting and initialization.
• Throttle: Rate-limiting that executes at maximum N times per interval.
• Tree Shaking: Dead code elimination during bundling.

• WeakMap: Map with weak references (keys are objects, no iteration).
• WeakSet: Set with weak references (objects only, no iteration).
• Web Worker: Background thread for parallel JavaScript execution.

• V8: Google’s open-source JavaScript engine (Chrome, Node.js).