Not Changing Behavior—But Preserving It: Understanding Reflect in JavaScript

At first, Proxy feels powerful.

You intercept property access.

You control assignments.

You can redefine how objects behave.

It feels like you’ve taken control of JavaScript itself.

But very quickly, something subtle starts to break.

Not loudly.

Not obviously.

Just… incorrectly.

And that’s where Reflect quietly becomes essential.

The Moment Things Go Wrong

Consider a simple object:

const obj = {
  _name: "Rishi",
  get name() {
    return this._name
  }
}

Accessing it directly works as expected:

obj.name // "Rishi"

Because the getter runs with the correct context.

this points to the object itself.

Now wrap it in a Proxy:

const proxy = new Proxy(obj, {
  get(target, key) {
    return target[key]
  }
})

At first glance, this seems fine.

You’re simply forwarding the access.

But something has already shifted.

The Hidden Assumption

When you write:

target[key]

you are making an assumption:

That this is equivalent to normal JavaScript behavior

But it’s not.

Because JavaScript property access is not just about retrieving a value.

It involves:

• context (this)
• prototype chain
• getters and setters

And when you bypass that system—even slightly—you lose correctness.

Where It Becomes Visible

Consider this:

const obj = {
  get value() {
    return this
  }
}

Now through a Proxy:

const proxy = new Proxy(obj, {
  get(target, key) {
    return target[key]
  }
})

When you access:

proxy.value

You might expect it to return the proxy.

But it doesn’t.

It returns the original object.

Because this is no longer what you think it is.

Enter Reflect

Now change one line:

const proxy = new Proxy(obj, {
  get(target, key, receiver) {
    return Reflect.get(target, key, receiver)
  }
})

Now:

proxy.value === proxy // true

The behavior is restored.

Not changed.

Restored.

What Reflect Actually Does

Reflect is not adding new behavior.

It is exposing JavaScript’s existing behavior as functions.

Instead of:

obj[key]

You can write:

Reflect.get(obj, key)

Instead of:

obj[key] = value

You can write:

Reflect.set(obj, key, value)

At first, this seems unnecessary.

But inside a Proxy, it becomes critical.

Because Reflect ensures that operations behave exactly as JavaScript intends them to.

The Missing Piece in Proxy

A Proxy lets you intercept an operation.

But once you intercept it, you are responsible for continuing it correctly.

Without Reflect, you are reimplementing JavaScript behavior manually.

And that behavior is more complex than it appears.

With Reflect, you don’t reimplement.

You delegate.

You say:

“Do exactly what JavaScript would have done—just from here.”

A Subtle but Important Difference

The difference between:

target[key]

and:

Reflect.get(target, key, receiver)

is not about syntax.

It’s about correctness.

One assumes.

The other guarantees.

Why This Matters in Practice

Frameworks like Vue rely on this pattern:

get(target, key, receiver) {
  track(target, key)
  return Reflect.get(target, key, receiver)
}

They intercept access to track dependencies.

But they still need the original behavior to remain intact.

Without Reflect, subtle bugs would appear:

• incorrect this binding
• broken inheritance
• unexpected values

Not dramatic failures.

Just quiet inconsistencies.

A Different Way to See It

Think of Proxy as control.

And Reflect as trust.

Proxy says:

“I want to intervene.”

Reflect says:

“But let the system behave as it should.”

A Final Thought

Reflect is easy to overlook.

It doesn’t introduce new concepts.

It doesn’t feel powerful on its own.

But it exists to preserve something deeper:

The integrity of JavaScript’s behavior.

Because once you start intercepting the system,

you also take responsibility for not breaking it.

And Reflect is how you keep that promise.