Certified Associate JavaScript Programmer key terms

One of the immutable building-block data types: string, number, bigint, boolean, undefined, symbol, or null. Primitives are compared by value and are not objects, so they have no methods of their own.

A value that points to an object stored elsewhere in memory, such as an object, array, or function. Assigning or passing it copies the reference, so two variables can affect the same underlying data.

The automatic or explicit conversion of a value from one type to another, as when a number is joined to a string with the plus operator. Implicit coercion follows loosely defined rules that often surprise beginners.

The comparison performed by === and !==, which returns true only when operands have the same type and the same value, with no coercion. Two distinct objects are never strictly equal because references differ.

The comparison performed by == and !=, which converts operands to a common type before comparing. It can produce true for values of different types, so many style guides prefer strict equality instead.

The behavior where declarations are processed before code runs, making function declarations callable earlier and var variables exist as undefined from the start of their scope. Let and const stay unusable until initialized.

The period between entering a scope and the point where a let or const binding is initialized. Reading or assigning the variable during that window throws a ReferenceError rather than yielding undefined.

The region of code where a particular binding is visible and can be referenced. JavaScript has global, function, block, and module scopes, and inner scopes can read names declared in enclosing scopes.

The visibility area created by a pair of curly braces, such as an if body or loop body. Variables declared with let and const are confined to it, while var ignores it and belongs to the surrounding function.

A function together with the lexical environment in which it was created, letting it keep reading outer variables after that outer function has returned. Closures power callbacks, factories, and private state patterns.

An immediately invoked function expression: a function defined and executed in the same expression, usually wrapped in parentheses. It creates a private scope so temporary variables do not leak into the surrounding environment.

A statement beginning with the function keyword followed by a name, which is hoisted so it can be called before its textual position. It creates a named binding in the enclosing scope.

A function created as part of an expression, often assigned to a variable or passed as an argument. Unlike a declaration, it is not fully hoisted, so it cannot be called before the assignment executes.

A compact function syntax using the => token that does not create its own this, arguments, or prototype. It inherits this from the enclosing scope, which makes it convenient for callbacks but unsuitable as constructors.

The value referenced by the this keyword inside a function, determined by how the function is called: as a method, plain call, constructor, or with call, apply, or bind. Arrow functions capture it lexically.

Function methods that invoke a function with an explicitly chosen this value. call passes arguments individually, while apply passes them as an array-like collection; both return the function's result.

A function method that returns a new function permanently tied to a given this value and optionally pre-filled leading arguments. The original function is not modified or invoked immediately.

A function that accepts another function as an argument, returns a function, or both. Array methods like map and filter and utilities like setTimeout are common examples in everyday code.

A function passed to other code so it can be invoked later, often after an operation finishes or when an event fires. Callbacks may be synchronous or asynchronous depending on the caller.

The linked series of prototype objects consulted when a property is not found on the object itself. Lookup walks upward until the property is found or the chain ends at null.

The mechanism by which objects inherit properties and methods from other objects through the prototype chain. It is delegation-based rather than class-copy-based, though class syntax builds on the same behavior.

A function intended to be called with the new keyword, which creates a fresh object, links it to the function's prototype, and runs the body with this bound to that object.

Syntax introduced in ES2015 for declaring constructors, methods, static members, and inheritance with extends and super. Classes are still functions under the hood and are not hoisted for use before definition.

A method that builds a new object using a supplied object as its prototype, optionally adding own property descriptors. It offers direct control over inheritance without invoking a constructor.

A comma-separated list of key-value pairs inside curly braces that produces a plain object. Keys may be identifiers, strings, computed expressions, or shorthand property names.

A syntax for extracting values from arrays or properties from objects into distinct variables in one statement. It supports defaults, renaming, and nesting, and is common in function parameter lists.

Three dots used to expand an iterable or object into individual elements or properties, as in function calls, array literals, and object literals. It produces a shallow copy of the expanded source.

A function parameter written with three dots that gathers any remaining arguments into a real array. It must be last in the parameter list and replaces the older arguments object for that purpose.

An array-like, iterable binding available inside non-arrow functions that holds all values passed to the call. It lacks array methods and is not created inside arrow functions.

A duplicate of a structure in which top-level values are copied but nested objects are still shared with the original. Editing a nested object through either reference affects both.

A duplicate that recursively clones nested structures so no data is shared with the source. It can be produced with structuredClone or careful recursion, but JSON-based tricks lose functions and special values.

An object representing the eventual result of an asynchronous operation, settling once as fulfilled or rejected. Handlers attach with then, catch, and finally, and state never changes after settling.

Syntax that lets asynchronous promise-based code read like synchronous code. An async function always returns a promise, and await pauses that function until the awaited promise settles.

The runtime mechanism that repeatedly takes queued work and runs it on the single main thread once the current call stack empties. It coordinates tasks, microtasks, rendering, and timers.

A short unit of work queued by promise reactions, queueMicrotask, or mutation observers. The entire microtask queue drains before the next task or render, so long chains can delay painting.

An opt-in mode enabled with the "use strict" directive that turns silent mistakes into errors, such as assigning to undeclared variables. It also changes how this behaves in plain function calls.

A temporary object the engine creates when a method is called on a primitive, such as a string or number. The primitive is boxed, the method runs, and the wrapper is discarded immediately.