Suggest an edit

Improve this article

Refine the answer for “How does Reflect differ from Object?”. Your changes go to moderation before they’re published.

Approval required

Content

What you’re changing

Title (EN)

Short answer (EN)

Shown above the full answer for quick recall.

Answer (EN)

`Reflect` and `Object` really are similar (both work with object properties), but they are **built for different purposes**. The difference between them is in **philosophy, behavior, and use**.

Let's break it down step by step:

---

## Short answer

| Criterion | `Object` | `Reflect` |
|---|---|---|
| Main purpose | Working with objects (creation, prototypes, properties) | Metaprogramming - "controlling the behavior" of objects |
| Appeared | Since the start of JS | In ES6 (ES2015) |
| Behavior on error | Throws exceptions | Returns `true` / `false` |
| Used in | regular code | Proxy, safe calls, internal operations |
| Return type | Varies (object, value, etc.) | Almost always boolean or a primitive |
| Status | "old" API | "modern, reflective" API |

---

## Example - defineProperty

### Object:

```javascript
try {
  Object.defineProperty({}, 'x', { value: 1, writable: false });
  console.log('ok');
} catch {
  console.log('Error!');
}
```

If the operation fails (for example, the object is frozen), it throws an **error**.

---

### Reflect:

```javascript
const obj = Object.freeze({});
const result = Reflect.defineProperty(obj, 'x', { value: 1 });
console.log(result); // false (no error)
```

`Reflect.defineProperty()` simply returns `false` instead of interrupting the program.

---

## Example - removing a property

### Via delete

```javascript
const user = { name: 'Tim' };
delete user.name; // true
```

### Via Reflect (safer)

```javascript
const user = { name: 'Tim' };
console.log(Reflect.deleteProperty(user, 'name')); // true
console.log(Reflect.deleteProperty(Object.freeze({x: 4}), 'x')); // false
```

`Reflect.deleteProperty()` does the same thing, but **does not throw errors** and returns a **boolean result**.

---

## Example - calling a function

```javascript
function greet(msg) {
  console.log(msg, this.name);
}

const user = { name: 'Tim' };

Reflect.apply(greet, user, ['Hi']); // "Hi Tim"
```

`Reflect.apply()` is an analog of `Function.prototype.apply()`, but more explicit and convenient for Proxy traps and metaprogramming.

---

## Example - creating an object

```javascript
class User {
  constructor(name) {
    this.name = name;
  }
}

const tim = Reflect.construct(User, ['Tim']);
console.log(tim.name); // "Tim"
```

`Reflect.construct()` is a "reflective" version of `new`, useful when you need to dynamically create a class instance.

---

## Example - checking a property

```javascript
const user = { name: 'Tim' };

console.log('name' in user);              // true
console.log(Reflect.has(user, 'name'));   // true
```

`Reflect.has()` is the same as the `in` operator, but as a function (convenient for dynamic calls).

---

## Example - getting and setting a property

```javascript
const user = { name: 'Tim' };

Reflect.set(user, 'name', 'Oleh');
console.log(Reflect.get(user, 'name')); // "Oleh"
```

An analog of `user.name = ...` and `user.name`, but in a "functional" form (convenient to use in Proxy).

---

## Error behavior

| Method | `Object` | `Reflect` |
|---|---|---|
| `Object.defineProperty(frozen, 'x', {...})` | throws an error | returns `false` |
| `Object.getPrototypeOf(null)` | TypeError | returns `false` |
| `Object.setPrototypeOf(sealed, ...)` | throws an error | returns `false` |

So `Reflect` is a "quiet" and predictable variant of `Object` methods.

---

## Methods that Object does not have

| Reflect method | What it does | Analog |
|---|---|---|
| `Reflect.apply()` | Calls a function with the given `this` and arguments | `func.apply()` |
| `Reflect.construct()` | Analog of the `new` operator | - |
| `Reflect.get()` / `Reflect.set()` | Gets / sets a property value | `obj[key]` |
| `Reflect.has()` | Checks for a property | `'key' in obj` |
| `Reflect.deleteProperty()` | Deletes a property | `delete obj.key` |
| `Reflect.ownKeys()` | Returns all keys (including `Symbol`) | `Object.getOwnPropertyNames()` + `Object.getOwnPropertySymbols()` |

---

## Real-world example - Proxy

`Reflect` works perfectly together with `Proxy` to pass through the default standard behavior.

```javascript
const user = { name: 'Tim' };

const proxy = new Proxy(user, {
  get(target, key) {
    console.log(`Reading ${key}`);
    return Reflect.get(target, key); // safely delegate
  }
});

console.log(proxy.name);
// Output:
// Reading name
// "Tim"
```

Without `Reflect.get()` you would have to manually write `target[key]`, which can cause errors in more complex cases (accessors, prototypes, etc.).

---

## Summary

| Criterion | `Object` | `Reflect` |
|---|---|---|
| Purpose | Working with properties and prototypes | Metaprogramming, "reflecting" behavior |
| Appeared | Since the start of JS | ES6 (2015) |
| On error | Throws an exception | Returns `false` |
| Return value | Varies | Predictable |
| Proxy support | No | Yes |
| Convenience in functional calls | Medium | High |

Markdown · drag & drop images · ⌘B / ⌘I shortcuts730 words

For the reviewer

Note to the moderator (optional)

Visible only to the moderator. Helps review go faster.