JSE Certified Entry-Level JavaScript Programmer key terms

A single complete instruction that the JavaScript engine executes, such as a variable declaration, an assignment, or a function call. Statements are usually separated by semicolons or line breaks and form the body of a program.

Any code fragment that evaluates to a single value, such as a literal, a variable name, a function call, or a combination joined by operators. Expressions can appear wherever a value is expected.

A group of statements wrapped in curly braces that runs as one unit. Blocks define the scope for variables declared with let and const and are used as loop and conditional bodies.

An opt-in execution mode enabled by the directive "use strict" that turns certain silent mistakes into thrown errors, forbids undeclared assignments, and changes how this behaves inside plain function calls.

The parser rule that inserts a missing semicolon at a line break when the code would otherwise be invalid. It can cause surprises, especially when a line begins with an opening parenthesis or bracket.

A statement that creates a named binding in a scope. The keywords var, let, and const differ in hoisting behavior, redeclaration rules, and whether the binding can be reassigned after initialization.

The engine behavior of registering declarations before code runs. Function declarations and var bindings are available early, while let and const bindings exist but stay unusable until their declaration line executes.

The period between entering a scope and reaching a let or const declaration, during which accessing that binding throws a ReferenceError instead of returning undefined.

One of the immutable, non-object data types: string, number, bigint, boolean, undefined, symbol, and null. Primitives are compared by value and are copied when assigned or passed to functions.

The automatic conversion of a value from one data type to another, performed by the engine when an operation expects a particular type, such as adding a number to a string.

A type change the engine performs on its own without any explicit call from the programmer, for example turning a number into a string during concatenation or a value into a boolean inside an if condition.

The boolean interpretation of any value in a condition. Falsy values are false, 0, -0, 0n, empty string, null, undefined, and NaN; every other value, including empty arrays and objects, is truthy.

A special number value meaning not-a-number, produced by failed numeric operations such as parsing text or dividing zero by zero. It is not equal to itself, so testing requires Number.isNaN or Object.is.

A symbol or keyword that combines operands into an expression, such as +, ===, typeof, or ?:. Operators differ in precedence and associativity, which determine the order in which parts of an expression are evaluated.

The ranking that decides which operator binds more tightly when several appear in one expression. Multiplication runs before addition, and grouping with parentheses overrides the default order.

The == and != operators, which compare after converting operands to a common type. Because the conversion rules are complex and surprising, most style guides require strict equality instead.

The === and !== operators, which compare values without any type conversion. Two operands of different types are simply unequal, and objects are compared by reference rather than by content.

The behavior of && and || that stops evaluating as soon as the result is known. They return one of the original operands rather than a boolean, which makes them useful for defaults and guards.

The operators &&, ||, and !, which combine or invert boolean-style conditions. The first two return an operand value, while ! always returns a boolean by converting its operand.

The ?? operator, which returns its right operand only when the left side is null or undefined. It differs from || because other falsy values such as 0 and empty strings are kept.

A structure that runs different code paths based on a test, written with if, else if, else, or switch. The test expression is converted to a boolean to decide which branch executes.

A multi-way branch that compares one expression against case labels using strict equality. Execution falls through to later cases unless a break or return ends the current case.

A construct that repeats a block while a condition holds or until a break occurs. Common forms are for, while, do...while, for...of for iterables, and for...in for property names.

One pass through the body of a loop. The loop's control expression is re-evaluated before or after each iteration depending on the loop type, which determines whether the body may run zero times.

Loop control keywords. break exits the nearest loop or switch immediately, while continue skips the rest of the current iteration and proceeds to the next one.

A named function defined with the function keyword as a statement. It is hoisted in full, so it can be called from code that appears earlier in the same scope.

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

A compact function syntax using => that does not create its own this, arguments, or prototype. It inherits this from the surrounding scope, which suits callbacks but not object methods that need their own this.

The region of code in which a binding can be referenced. JavaScript has global, function, and block scope, and inner scopes can read names from enclosing scopes through the scope chain.

A function together with the surrounding bindings it still references after the outer function has returned. Closures let inner functions keep private state and are the basis of many callback patterns.

The value that the keyword this refers to inside a function. It depends on how the function is called, except for arrow functions, which capture this from the enclosing lexical scope.

A function passed to another function so it can be invoked later, for example after an event fires or an asynchronous task completes. Callbacks are commonly used with array methods and DOM listeners.

An ordered, mutable collection of values accessed by numeric index starting at zero. Arrays have a length property and many built-in methods such as push, map, filter, and slice.

A zero-based numeric position used to read or write an element in an array or a character in a string. Reading a position that does not exist yields undefined rather than an error.

A mutable collection of key-value pairs where keys are strings or symbols. Objects are compared and copied by reference, and properties are read with dot or bracket notation.

A named entry on an object, consisting of a key and a value. It can be accessed with dot notation for valid identifiers or bracket notation for computed keys and keys containing special characters.

A function stored as an object property, called through that object so this refers to the object. Array helpers like map and string helpers like toUpperCase are methods on built-in prototypes.

The identity that links a variable to an object in memory. Assigning or passing an object copies only the reference, so changes made through one variable are visible through the other.

A text format for structured data that JavaScript can parse into objects and arrays or produce from them. JSON.parse and JSON.stringify convert between text and live values, and functions cannot be represented.

A built-in object type representing a runtime problem, typically created with new Error and thrown. It carries a message and stack, and subclasses such as TypeError identify specific failure categories.

A statement that interrupts normal execution and passes a value, usually an Error object, up the call stack until a matching catch handler is found.

A statement that runs code in a try block and handles any thrown value in a catch block, with an optional finally block that runs regardless of whether an error occurred.

An error thrown when a value is used in a way its type does not allow, such as calling a non-function or reading a property of undefined. It often signals a logic bug rather than a syntax problem.

An error thrown when code refers to a binding that does not exist in any accessible scope, or accesses a let or const binding before its declaration has been evaluated.

An error raised when code cannot be parsed at all, such as an unclosed brace or invalid token. It usually occurs before any statement runs, so try/catch cannot catch it.

The Document Object Model, an in-memory tree of nodes that represents an HTML document. Scripts read and modify this tree to change page content, structure, and attributes.

A node in the DOM tree that corresponds to an HTML tag, such as a div or a button. Elements expose properties like textContent, classList, and style, plus methods to find and change children.

A document or element method that finds the first node matching a CSS selector string, or all matches as a static NodeList. It returns null when nothing matches, so results need a null check.

A function registered on a target with addEventListener to run when a named event occurs. Listeners receive an event object and can be removed later with removeEventListener using the same reference.

The value passed to a listener that describes what happened, including the target element, event type, and methods such as preventDefault and stopPropagation.

The default propagation path in which an event fires on the target and then on each ancestor up to the document. Listeners can stop this with stopPropagation or observe it during the capture phase.