JavaScript Reflection: Object.* and Reflect Methods Explained

JavaScript reflection lets you inspect and manipulate objects at runtime. In practice, that means reading property names, checking descriptors, copying values, defining properties, and using a safer, more explicit API for common object operations.

Quick answer: JavaScript reflection is the ability to examine and operate on an object’s properties dynamically. In modern JavaScript, you usually use Object.* methods for enumeration and descriptors, and Reflect methods for direct, function-style operations that return success values consistently.

Difficulty: Beginner to Intermediate

You'll understand this better if you know: basic objects, property access with dot and bracket notation, and how functions return values in JavaScript.

1. What Is Reflection in JavaScript?

Reflection is the ability to ask an object questions about itself and, in some cases, change how it behaves. Instead of only reading user.name or writing user.name = "Ava", reflection APIs let you inspect keys, look at property descriptors, check whether a property exists, and perform low-level object operations.

It works on runtime values, not just on code you write ahead of time.
It helps you inspect object structure without guessing property names.
It includes both descriptive APIs such as Object.keys() and operational APIs such as Reflect.get().
It is especially useful when you are writing generic utilities, libraries, proxies, serializers, or debugging tools.

In JavaScript, reflection is not one single feature. It is a family of built-in methods that expose object metadata and behavior.

2. Why Reflection Matters

Reflection matters because real programs often need to work with objects they did not hard-code. A form serializer, validator, logger, configuration loader, or proxy handler may need to discover properties dynamically instead of relying on fixed field names.

It also matters because JavaScript objects have details that are easy to miss. Two objects can both have a property named id, but one property may be writable, another may be read-only, and another may be inherited through the prototype chain. Reflection gives you the tools to see those differences.

Use reflection when you need flexibility, inspection, or generic behavior. Avoid it when a simple direct property access is clearer and easier to maintain.

3. Basic Syntax or Core Idea

Reflection in JavaScript usually falls into two groups:

Inspection helpers from Object, such as Object.keys(), Object.getOwnPropertyNames(), and Object.getOwnPropertyDescriptor().
Operation helpers from Reflect, such as Reflect.get(), Reflect.set(), and Reflect.has().

Here is the simplest pattern for reading a property through Reflect:

const profile = { name: "Mina", age: 28 };

const name = Reflect.get(profile, "name");

console.log(name); // "Mina"

The first argument is the target object, and the second argument is the property key. This is similar to bracket notation, but it fits better into APIs that need a consistent function form.

For object inspection, a common pattern is:

const keys = Object.keys(profile);

That returns an array of the object’s own enumerable string keys.

4. Step-by-Step Examples

Example 1: Listing keys with Object.keys()

When you need the visible property names on a plain object, Object.keys() is the most common starting point. It returns own enumerable string keys only.

const book = { title: "Clean Code", author: "Robert C. Martin" };

const keys = Object.keys(book);

console.log(keys); // ["title", "author"]

This is useful when you want to loop over fields or show them in a UI.

Example 2: Getting values and entries

If you want only the values, use Object.values(). If you want key-value pairs, use Object.entries().

const settings = { theme: "dark", compact: true };

console.log(Object.values(settings)); // ["dark", true]
console.log(Object.entries(settings)); // [["theme", "dark"], ["compact", true]]

These helpers are common in serialization, display logic, and data transformation.

Example 3: Inspecting a property descriptor

A descriptor tells you how a property behaves, not just what value it holds. That includes whether it can be written to, deleted, or enumerated.

const account = {};

Object.defineProperty(account, "id", {
  value: 123,
  writable: false,
  enumerable: true
});

const descriptor = Object.getOwnPropertyDescriptor(account, "id");

console.log(descriptor);

This is the reflection API you use when you need to understand property behavior precisely.

Example 4: Reading and writing with Reflect

Reflect methods are convenient when you want a consistent function-based API that returns a boolean or direct result. Here, Reflect.set() tries to write a property and returns whether it succeeded.

const point = { x: 10, y: 20 };

const wasSet = Reflect.set(point, "x", 15);

console.log(wasSet); // true
console.log(point.x); // 15

This pattern is especially helpful in generic code and proxy traps.

Example 5: Checking for a property with Reflect.has()

Reflect.has() works like the in operator, so it checks own and inherited properties.

const base = { kind: "base" };
const child = Object.create(base);
child.name = "item";

console.log(Reflect.has(child, "kind")); // true
console.log(Reflect.has(child, "name")); // true

This is useful when you want existence checks without manually walking the prototype chain.

5. Practical Use Cases

Building a form mapper that converts object fields into inputs.
Writing a logger that prints only enumerable data properties.
Creating a serializer that needs own keys and descriptors.
Implementing a validation library that inspects object shapes at runtime.
Writing a proxy that forwards operations to a target object correctly.
Copying or merging objects while preserving or checking property behavior.

Reflection is most valuable in utilities that must work across many object shapes instead of one known structure.

6. Common Mistakes

Mistake 1: Using Object.keys() and expecting inherited properties

Object.keys() only returns own enumerable string keys. It does not include properties from the prototype chain, so beginners sometimes think data is missing.

Problem: The code below expects kind to appear, but it was inherited from the prototype, so Object.keys() does not return it.

const base = { kind: "base" };
const child = Object.create(base);
child.name = "item";

console.log(Object.keys(child)); // ["name"]

Fix: Use Reflect.has() or the in operator when you need inherited property checks.

console.log(Reflect.has(child, "kind")); // true

The corrected version works because it checks the full property chain instead of only own keys.

Mistake 2: Treating all properties as enumerable data

Some properties are hidden from Object.keys() because they are non-enumerable. This is common with built-in objects and properties created through Object.defineProperty().

Problem: The code below expects secret to show up in key enumeration, but it is non-enumerable.

const data = {};

Object.defineProperty(data, "secret", {
  value: "hidden",
  enumerable: false
});

console.log(Object.keys(data)); // []

Fix: Use Object.getOwnPropertyNames() if you need own string keys regardless of enumerability.

console.log(Object.getOwnPropertyNames(data)); // ["secret"]

The corrected version works because it includes own string properties even when they are hidden from enumeration.

Mistake 3: Assuming Reflect.set() throws on failure

Reflect.set() returns a boolean instead of throwing in many normal failure cases. Beginners sometimes ignore the return value and assume the write succeeded.

Problem: This code tries to write to a read-only property. The write fails, but no exception is guaranteed, so checking the return value matters.

const item = {};

Object.defineProperty(item, "id", {
  value: 1,
  writable: false
});

Reflect.set(item, "id", 2);
console.log(item.id); // 1

Fix: Check the boolean result and handle failure explicitly.

const updated = Reflect.set(item, "id", 2);

if (!updated) {
  console.log("Could not update id");
}

The corrected version works because it treats reflection as an operation with an explicit success signal.

7. Best Practices

Practice 1: Use Object.* for inspection and Reflect for operations

Object.keys(), Object.entries(), and descriptor methods are best for inspection. Reflect.get(), Reflect.set(), and Reflect.has() are better when you are performing object operations in a generic way.

const user = { name: "Ada" };

const keys = Object.keys(user);
const name = Reflect.get(user, "name");

This separation keeps code easier to read because each API has a clear job.

Practice 2: Prefer own-property checks when you only care about local data

When you are working with data objects, inherited properties can be surprising. Use Object.hasOwn() or Object.prototype.hasOwnProperty.call() when you need a property that belongs directly to the object.

const record = Object.create({ shared: true });
record.value = 42;

console.log(Object.hasOwn(record, "value")); // true

This helps you avoid accidentally treating prototype data as user data.

Practice 3: Inspect descriptors before changing property behavior

Before you redefine or delete properties, inspect the descriptor first. This avoids surprises when a property is non-configurable or read-only.

const config = {};

Object.defineProperty(config, "mode", {
  value: "prod",
  configurable: false
});

const descriptor = Object.getOwnPropertyDescriptor(config, "mode");
console.log(descriptor.configurable); // false

That makes it clear whether a later change is allowed.

8. Limitations and Edge Cases

Object.keys(), Object.values(), and Object.entries() only include own enumerable string properties. They skip symbols and inherited properties.
Object.getOwnPropertyNames() includes non-enumerable string properties, but not symbols.
Object.getOwnPropertySymbols() is needed for symbol keys.
Reflect.ownKeys() returns both string and symbol keys, enumerable or not.
Reflect.has() checks the prototype chain, so it can return true for inherited properties you may not want to treat as local data.
Proxy objects can change the apparent result of reflection calls, so the returned values may reflect proxy behavior rather than the raw target.
Non-configurable or non-writable properties may not be changed, and in strict mode some direct assignments can throw a TypeError.

Note: If you need a complete picture of an object’s own keys, Reflect.ownKeys() is the broadest built-in option, but you still need to filter the results yourself.

9. Practical Mini Project

Let’s build a small object inspector that prints only an object’s own keys and shows whether each key is writable. This is a realistic use of reflection for debugging and introspection.

const product = {};

Object.defineProperties(product, {
  name: {
    value: "Keyboard",
    enumerable: true,
    writable: true
  },
  sku: {
    value: "KB-100",
    enumerable: true,
    writable: false
  }
});

function inspectObject(obj) {
  return Reflect.ownKeys(obj).map((key) => {
    const descriptor = Object.getOwnPropertyDescriptor(obj, key);

    return {
      key,
      value: obj[key],
      writable: !!(descriptor && descriptor.writable)
    };
  });
}

console.log(inspectObject(product));

This example combines key discovery with descriptor inspection, which is a very typical reflection workflow. It works because it uses the broad key list from Reflect.ownKeys() and then asks the object about each property’s behavior.

10. Key Points

Reflection means inspecting and manipulating objects at runtime.
Object.* methods are usually best for listing keys, values, and descriptors.
Reflect.* methods are useful for direct operations that return predictable results.
Own properties and inherited properties are not the same thing, so choose your API carefully.
Descriptors tell you how a property behaves, not only what value it stores.
Reflect.ownKeys() is the most complete built-in key listing method for strings and symbols.

11. Practice Exercise

Create an object with at least three properties, including one non-enumerable property.
Write a function that returns only the object’s own enumerable keys.
Write a second function that returns all own keys, including non-enumerable ones.
Use a descriptor lookup to report whether one property is writable.

Expected output: The first function should hide the non-enumerable property, while the second function should include it. The descriptor check should report the correct writable status.

Hint: Use Object.keys() for enumerable keys, Reflect.ownKeys() for all own keys, and Object.getOwnPropertyDescriptor() for property behavior.

Solution:

const profile = {};

Object.defineProperties(profile, {
  name: {
    value: "Nina",
    enumerable: true,
    writable: true
  },
  age: {
    value: 31,
    enumerable: true,
    writable: false
  },
  secret: {
    value: "hidden",
    enumerable: false,
    writable: false
  }
});

function getEnumerableKeys(obj) {
  return Object.keys(obj);
}

function getAllOwnKeys(obj) {
  return Reflect.ownKeys(obj);
}

function isWritable(obj, key) {
  const descriptor = Object.getOwnPropertyDescriptor(obj, key);
  return !!(descriptor && descriptor.writable);
}

console.log(getEnumerableKeys(profile)); // ["name", "age"]
console.log(getAllOwnKeys(profile)); // ["name", "age", "secret"]
console.log(isWritable(profile, "age")); // false

This solution uses the right reflection tool for each job, which is the main skill this topic teaches.

12. Final Summary

JavaScript reflection is the set of built-in APIs that let you inspect and manipulate objects at runtime. The most useful tools are the Object.* methods for listing keys, values, entries, and descriptors, plus the Reflect.* methods for direct property operations with predictable return values.

For everyday code, direct property access is still the simplest option. Use reflection when you need generic object handling, debugging tools, serializers, validators, or proxy logic. The key to using it well is choosing the right API for the exact question you are asking about the object.

Next, try combining reflection with Proxy or property descriptors in a small utility so you can see how runtime inspection changes the way you design object-based code.