JavaScript flashcards, generated for you.

var (function-scoped, hoisted), let (block-scoped, temporal dead zone), and const (block-scoped, cannot be reassigned). Use const by default, let when you need to reassign, avoid var in modern code.

== performs type coercion (e.g., '5' == 5 is true), while === checks both value and type without coercion (e.g., '5' === 5 is false). Always use === to avoid unexpected behavior.

Hoisting moves variable and function declarations to the top of their scope during compilation. var declarations are hoisted and initialized as undefined; let/const are hoisted but not initialized (temporal dead zone); function declarations are fully hoisted.

undefined means a variable has been declared but not assigned a value, or a function has no return statement. null is an explicit assignment meaning 'no value' and represents intentional absence. typeof undefined === 'undefined'; typeof null === 'object' (a famous bug).

Regular functions: 'this' is bound at call-time (depends on how the function is called). Arrow functions: 'this' is lexically bound to the enclosing scope and cannot be changed with call(), apply(), or bind().

map() returns a new array with transformed elements and can be chained. forEach() returns undefined, executes a callback for side effects only, and cannot be chained. Use map() when you need a result, forEach() for side effects.

Both == and === compare by reference, not by value. [1,2] === [1,2] is false because they are different objects in memory. Use JSON.stringify() for value comparison or libraries like lodash isEqual() for deep equality.

A closure is a function that has access to variables from its outer (enclosing) scope even after that outer function has returned. Inner functions retain access to their parent's variables, creating a persistent reference to those variables.

slice(start, end) returns a shallow copy of a portion of an array without modifying the original. splice(start, deleteCount, items) modifies the array in-place by removing/replacing elements and returns the removed elements.

Spread operator unpacks iterables (arrays, strings) or object properties. Common gotcha: [...obj] doesn't work because objects are not iterable; use {...obj} instead. Spread creates shallow copies—nested objects are still referenced, not cloned.