The Quiet Lifecycle Every Value Goes Through in JavaScript

Every value you create in JavaScript has a kind of life.

Not in a visible way.

Not something you usually track.

But from the moment it appears to the moment it disappears, there’s a process quietly happening underneath.

Most of the time, you don’t notice it.

Until something stays longer than expected.

It Starts With Creation

Every time you write something like:

let user = { name: "Rishi" }

something new is created in memory.

This is often described as “allocation”.

But what really matters is simpler:

Something now exists that the JavaScript engine needs to keep track of.

It has entered the system.

Staying Alive Isn’t About Time

Once something is created, it doesn’t disappear just because time passes.

It stays.

And it keeps staying.

Until one specific condition changes.

That condition is not:

• how often you use it
• whether you still care about it
• whether it feels “done”

It’s this:

Whether it is still reachable.

Alive → still reachable
Dead  → no longer reachable

This is the rule that actually determines the lifecycle.

What “Reachable” Really Means

It helps to imagine your program not as a sequence of variables, but as a network.

Global → user → { name: "Rishi" }

As long as there is a path from somewhere active (like the global scope or a running function) to that object, it remains part of the system.

It’s still alive.

But if that path is removed:

user = null

Global → user (null)

{ name: "Rishi" }  ← isolated

Now the object is disconnected.

And once something is disconnected, its lifecycle begins to end.

Ending Doesn’t Happen Immediately

This is where things get a bit unintuitive.

Even after something becomes unreachable, it doesn’t disappear right away.

Instead, it becomes:

eligible for garbage collection

Which means:

It will be removed — but not necessarily now.

The engine decides when.

This delay exists because constantly cleaning memory would slow everything down.

So cleanup happens in the background, when it’s efficient to do so.

The Lifecycle Is Not Linear

We often describe memory like this:

Allocate → Use → Release

But that makes it feel like a clean sequence.

In reality, it’s closer to this:

Created → Connected → Still connected → Disconnected → Eventually removed

The important transitions are not about time.

They’re about connections.

Where It Becomes Subtle: Closures

Closures make this lifecycle less obvious.

They are often explained as functions that “remember” their outer variables.

Which can lead to the assumption:

Everything in the outer scope stays alive

But what actually matters is more precise:

Only what is referenced stays alive

Consider this:

function outer() {
  let data = { big: true }

  return function inner() {
    console.log("hi")
  }
}

Here, inner does not use data.

So there is no connection:

inner → (no reference to data)

Which means:

data can disappear

But change it slightly:

function outer() {
  let data = { big: true }

  return function inner() {
    console.log(data.big)
  }
}

Now:

inner → data

There is a path.

So the lifecycle continues.

The same structure — but a different connection.

Why Things Stay Longer Than Expected

The most confusing cases are not when data disappears.

They’re when it doesn’t.

You might stop using something.

You might forget about it entirely.

And yet, it remains in memory.

This happens because:

Something is still pointing to it

Not intentionally. Just structurally.

A closure.

An event listener.

A long-lived object.

From JavaScript’s perspective, everything is still connected.

So everything stays alive.

A Different Way to Think About Memory

At some point, the question changes.

Instead of asking:

“Why is this still in memory?”

You start asking:

“What is still connected to this?”

Because that’s the only question the system actually answers.

The Bigger Insight

Memory lifecycle in JavaScript is not about creation and destruction.

It’s about connection and disconnection.

Things come into existence.

They become part of a network.

They stay as long as that network reaches them.

And once they are no longer connected, they don’t disappear immediately.

But their lifecycle has already ended.

The rest is just cleanup.