JavaScript Junior

var and let are global-scoped; const is block-scoped and always reassignable.

var is block-scoped; let and const are function-scoped, and let can't be reassigned.

All three are block-scoped, but only const is hoisted to the top of its block.

var is function-scoped; let and const are block-scoped, and const can't be reassigned.

Global covers a file; function scope covers blocks; block scope covers modules only.

Global is per module; function scope is global; block scope covers entire functions.

Global is per file; function scope is per block; block scope applies only to loops.

Global is accessible everywhere; function scope is per function; block scope is per {}.

A constant is reassigned and its previous value is hidden by the engine

A variable is referenced before its declaration is hoisted within the scope

A global variable is silently created when an assignment omits a keyword

An inner scope declares a variable with the same name as one in an outer scope

undefined is a deliberate empty value, while null means a missing variable

null and undefined are identical and both indicate a deleted object reference

null is reserved for numbers, while undefined applies to all object types

null is an intentional absence of value, while undefined means not yet assigned

Both return "object"; null had a type tag of zero in early implementations

Arrays return "array" and null returns "null", reflecting their distinct value tags

Arrays return "object" and null returns "undefined" due to a parser limitation

Both return "object" because null was deliberately defined as an empty object reference

string, number, boolean, null, object, symbol, array

string, number, boolean, object, array, function, date

string, number, float, boolean, undefined, symbol, bigint

string, number, boolean, null, undefined, symbol, bigint

JavaScript stores all numbers as integers, so the decimal fractions get truncated on addition

The addition operator rounds each operand to one digit before combining the two values

Floating-point math is performed in base ten but limited to fifteen significant digits total

These decimals cannot be represented exactly in binary floating-point, causing rounding error

=== coerces types and == does not, making == faster and safer for nearly all comparisons.

Neither coerces types, but === also compares object identity, so the two are equivalent.

== coerces types and === does not, but == null usefully checks both null and undefined.

Both compare identically, so === merely exists for backward compatibility with older code.

A function defined at the top level of a module, such as parseInt, isNaN, and encodeURI.

A function that mutates the array it is called on in place, such as push, pop, and splice.

A function that accepts a function argument or returns one, such as map, filter, and reduce.

A function that runs faster because the engine optimizes it, like sort and join.

Arrow functions create a new this bound to whatever object invokes them at call time.

Arrow functions have no own this and inherit it from the enclosing lexical scope.

Both resolve this dynamically, but arrow functions can be rebound later with bind.

Regular functions inherit this lexically, while arrow functions resolve it dynamically.

Both are hoisted identically, but only declarations can be assigned to a variable name.

A declaration is hoisted with its body, while an expression's name is not usable before definition.

An expression is hoisted with its body, while a declaration must be defined before it is called.

Neither is hoisted, but expressions are evaluated earlier during the parsing phase.

map transforms into a new array, forEach returns nothing, filter selects, reduce yields one value.

map mutates in place, forEach copies it, filter sorts, and reduce reverses the array.

map returns a value, forEach returns an array, filter counts, and reduce groups items.

map and forEach both return new arrays, while filter and reduce mutate the original.

Waiting, settled, and rejected.

Pending, fulfilled, and rejected.

Started, completed, and failed.

Pending, resolved, and cancelled.

preventDefault cancels the browser's default action; stopPropagation stops the event from propagating further

preventDefault delays the default action briefly; stopPropagation prevents the event from being dispatched at all

preventDefault stops the event bubbling to parents; stopPropagation cancels the browser's default behavior entirely

preventDefault removes all listeners on the element; stopPropagation pauses the event loop until the handler returns

Declaring variables with the private keyword inside a function body to hide them

An outer function holds variables and returns inner functions that can access them

Marking variables as const so external code cannot read or reassign them

Using the # prefix on variables declared at the top level of a module

All values including primitives are passed as references to the original

Primitives are passed by reference while objects are passed by their value

All values including objects are deeply copied when passed into a function

Primitives are passed by value while objects are passed by their reference

?? returns the right side only when the left is null or undefined

|| returns the right side only when the left is null or undefined

?? returns the left side only when the right is null or undefined

?? returns the right side whenever the left is any falsy value such as 0

It returns undefined yet keeps evaluating the rest of the chain anyway

It returns undefined and stops evaluating when a reference is null or undefined

It returns null and stops evaluating when a reference is any falsy value at all

It throws an error but stops evaluating when a reference is null or undefined

Both collect multiple arguments into a single array passed into the function

Both expand iterables into individual elements depending on where they are used

Spread expands an iterable into elements; rest collects arguments into one array

Rest expands an iterable into elements; spread collects arguments into one array

It unpacks array values by position and object values by matching property names

It copies entire arrays and objects into new variables without unpacking them

It merges multiple arrays and objects into one combined destination variable

It unpacks array values by property name and object values by their position

for...in runs synchronously while for...of runs asynchronously over the iterator protocol

for...in iterates enumerable property keys; for...of iterates values of iterable objects

for...in iterates array values; for...of iterates only the numeric index keys of objects

for...in works on iterables only; for...of works on any plain object with enumerable keys