What Is the Temporal Dead Zone?

The temporal dead zone is the window between the moment a scope is entered and the moment a let, const or class declaration in that scope actually executes. The binding for the name exists during that window, because the engine creates all bindings up front, but it has no value yet. Reading it throws a ReferenceError.

console.log("start");

try {
  console.log(later);   // ReferenceError - the binding exists but is not ready
} catch (err) {
  console.log("caught:", err.name);   // "ReferenceError"
}

let later = "declared further down";
console.log(later);

It applies to let, const and class declarations. It does not apply to var, because a var binding is given its empty value immediately, and it does not apply to function declarations, because the whole function is created up front.

What makes the dead zone confusing is that it turns an ordinary ordering mistake into a crash at runtime. The code reads as though the variable were simply not there yet, but instead of a blank value you get an exception, and the message names the variable rather than telling you it was used too early. The fix is almost always to move the declaration above its first use, or to restructure the code so the declaration runs first.

The zone also explains a confusing detail about typeof. The typeof operator is safe on a name that was never declared at all, which is the basis of feature detection. Inside the dead zone it still throws, because the binding exists and the engine refuses to read a binding that has not been initialised.

They look similar in the source but behave differently at runtime, and the difference matters when you are reading an error message.

A variable declared with var and never assigned holds the empty value. Reading it is perfectly legal and gives you that empty value. Nothing throws. A parameter you never pass a value for behaves the same way, and so does a property that was never added to an object.

A let or const declaration that has not executed yet is in the temporal dead zone, and reading it throws a ReferenceError. The binding is reserved but uninitialised. The engine is deliberately refusing to hand you a value it does not have, because a blank value there would hide a genuine ordering bug in your code.

There is a third case worth distinguishing: a name that was never declared at all. Reading that throws a ReferenceError too, because there is no binding to look up. The difference shows up with the typeof operator, which is safe for a name that does not exist but throws for a name that exists inside the dead zone. That asymmetry surprises people the first time they hit it.

So the practical rule is that a blank value means the variable exists and is empty, while a ReferenceError means either the declaration has not run yet or the name does not exist. When you see one, look at where the declaration sits relative to the use, not at whether the value was assigned.