What is the difference between global, function, and block scope?

Scope is the region of code where a name can be used. Think of it as a boundary: a declaration outside a function or block is at the surrounding top level; a declaration inside a function may be limited to that function; and a declaration inside a smaller brace-delimited block may be limited to that block.

For the declarations in your question, the key distinction is that var is scoped to its containing function or top-level scope, not to an ordinary nested block. let and const are limited to their block. [S1] [S2]

One qualification: “global” does not mean every file or module can automatically access a name. The cited description of var includes module scope, so a declaration at a module’s top level belongs to that module’s scope. [S1]

Here is a small example. Assume the condition is true, so the declarations run:

if (true) {
  var count = 1;
  let label = "inside";
  const fixed = "also inside";
}

console.log(count); // 1
console.log(label); // ReferenceError
console.log(fixed); // ReferenceError

count can be referenced after the if block because var does not become block-scoped just because it appears between those braces. label and fixed are block-scoped, so they are unavailable outside that block. [S1] [S2]

The comments describe what happens as each line runs in order. If you run the whole snippet, execution stops at the first error; test the later references separately if you want to see each result.

A function’s braces mark a function boundary. A var declared inside the function is confined to that function, even if its declaration sits inside an if block within the function. The let and const declarations in the if block remain confined to that smaller block.

function showValues() {
  if (true) {
    var total = 3;
    let note = "temporary";
  }

  console.log(total); // 3
  console.log(note);  // ReferenceError
}

showValues();
console.log(total); // ReferenceError

Inside showValues, total is available after the if because it uses var. Outside the function, it is unavailable because its containing function sets its scope. note is limited to the if block. These examples apply the function-scope rule for var and block-scope rule for let and const. [S1] [S2]

Use this comparison as a starting point:

• Global or module level: A declaration outside a function is in the surrounding top-level scope. In module code, do not assume that means it is available in unrelated modules.
• Function scope: var is available within its containing function, not just the nearest ordinary block. [S1]
• Block scope: let and const are available only within the block where they are declared. [S2]

To check code, mark the braces for each function and each if, loop, or other block. Find the declaration, then ask: is the reference still within its containing function or top-level scope for var, or inside the specific block for let and const? If not, treat it as out of scope. A reference outside its scope produces an error when evaluated. This comparison focuses on scope, not every JavaScript rule that affects when declarations can be used.