When “Nothing” Doesn’t Mean the Same Thing: Understanding void vs never in TypeScript

There’s a moment when learning TypeScript where two words start to blur together.

void and never.

At first glance, they seem to describe the same idea:

“This function doesn’t return anything.”

But that intuition turns out to be misleading.

Because in TypeScript, they are not describing the same thing at all.

The Subtle Misunderstanding

The confusion usually comes from how we think about functions.

We tend to think in terms of values:

• Does this function return something?
• Or does it return nothing?

So we map:

void  → returns nothing
never → also returns nothing

And that’s where things go wrong.

Because TypeScript is not modeling values here.

It’s modeling control flow.

What void Actually Means

When a function is typed as void, it doesn’t mean:

“This function returns nothing”

It means:

“This function returns, but whatever it returns is irrelevant”

In JavaScript, every function technically returns something.

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

This returns undefined.

TypeScript simply tells you:

“Don’t rely on the return value.”

So a void function is one that:

Completes normally → and execution continues

What never Actually Means

never describes something very different.

It means:

“This function does not return at all”

Not “returns nothing”.

But:

“There is no point after this function”

function fail(): never {
  throw new Error("Something went wrong")
}

Or:

function loop(): never {
  while (true) {}
}

In both cases:

Execution never reaches the end

The Real Difference

The difference becomes clearer when you stop thinking about values and start thinking about flow.

void  → function ends → program continues
never → function does not end → program does not continue

This is not about what is returned.

It’s about whether execution can move forward.

Why This Distinction Matters

Consider this:

function getValue(x: string | null): string {
  if (x === null) {
    throw new Error("Invalid")
  }

  return x
}

This works because TypeScript understands something subtle:

throw → never → execution stops

So after that condition:

x is guaranteed to be a string

If that function were treated like void, TypeScript would assume:

execution might continue

And suddenly, the type safety breaks down.

Where the Confusion Comes From

Part of the confusion is that both void and never often appear in places where “nothing” seems to happen.

function log(): void {}
function fail(): never {}

They look similar.

But they describe two completely different realities:

void  → “I finish, but don’t give you anything useful”
never → “I never finish at all”

A Shift in Thinking

The key shift is this:

Stop asking:

“Does this function return a value?”

Start asking:

“Does execution continue after this function?”

That one question separates void from never.

The Bigger Insight

This distinction reveals something deeper about TypeScript.

Types are not just about values.

They are also about:

What paths of execution are possible

void represents a normal path.

never represents an impossible one.

And once you see that, the confusion disappears.

Because you’re no longer thinking about “nothing”.

You’re thinking about what can happen next.