Execution Model, Scope, and Memory

Execution Context

A temporary internal environment JavaScript creates to run code

Global Execution Context

The first execution context created when a program starts

Function Execution Context

A new execution context created every time a function is called

Call Stack

A stack of active execution contexts

Creation Phase

The setup phase where bindings and scope links are prepared before execution

Execution Phase

The phase where JavaScript runs code line by line

Hoisting

JavaScript setting up bindings before execution begins

var Hoisting

var declarations are initialized as undefined during creation phase

let Hoisting

let declarations are hoisted but uninitialized until declaration line

const Hoisting

const declarations are hoisted but uninitialized until declaration line

Temporal Dead Zone

The period where let/const exist in scope but cannot be accessed yet

Scope

Rules that determine where variables are accessible

Global Scope

Top-level scope of the runtime environment

Function Scope

Variables accessible only inside the function they were declared in

Block Scope

Variables accessible only inside a block using let/const

Module Scope

Each Node.js file has its own private scope

Lexical Scope

Variable lookup based on where code was defined not where called

Closure

A function that keeps access to variables from where it was created

Lexical Environment

The scope data structure a function can reference for variable lookup

Closure Memory Survival

Variables survive because a live function still references them

Shared Closure

Multiple references to same returned function share same closed-over state

Separate Closure

Separate factory calls create separate private environments

Counter Closure

A closure pattern using private state like count++

Primitive Value

A simple value like number string boolean null undefined bigint symbol

Primitive Copy

Assigning a primitive copies the value independently

Reference Value

A value that refers to an object in memory

Object Reference

Multiple variables can reference the same object

Mutation

Changing properties inside an existing object

Reassignment

Making a variable point to a new value or object

Mutation Effect

Mutating a shared object affects all references to it

Reassignment Effect

Reassigning one variable does not change other references

Pass By Value

JavaScript always passes arguments by value

Reference Illusion

Objects seem pass-by-reference because copied values are references

Stack Overflow

Error caused by too many nested calls on the call stack

Recursion

A function calling itself

Function Declaration Hoisting

Function declarations are available before their line executes within scope

Function Expression Hoisting

A variable may hoist but assigned function does not exist until assignment

var Block Behavior

var ignores block scope and uses function/global scope

let Block Behavior

let respects block scope

const Block Behavior

const respects block scope and requires initialization

Scope Chain

JavaScript searches current scope then outer scopes for variables

Closest Scope Rule

JavaScript uses nearest matching variable name first

Shadowing

Inner variable with same name hides outer variable

Node Module Privacy

File variables are private unless exported

Middleware Factory

A function returning middleware while capturing config values

Service Factory

A function creating services while capturing dependencies

Private State via Closure

Closure can hide internal data from outside access

Shared Config Bug

Mutating one shared object changes behavior elsewhere

var Loop Bug

var in async loop often prints final loop value repeatedly

Call Stack Push

A function call adds a new context to the stack

Call Stack Pop

When function finishes its context is removed

Synchronous Execution

JavaScript runs one stack frame at a time in order

Debugging Stack Trace

A stack trace shows nested calls leading to an error

Captured Variable

A variable referenced by an inner function from outer scope

Factory Function

A function that returns configured functions or objects

State Isolation

Creating new closures prevents accidental shared state