Reflect

Reflect is a built-in object that provides methods for interceptable JavaScript operations. The methods are the same as those of proxy handlers. Reflect is not a function object, so it's not constructible.

Description

Unlike most global objects, Reflect is not a constructor. You cannot use it with a new operator or invoke the Reflect object as a function. All properties and methods of Reflect are static (just like the Math object).

The Reflect object provides a collection of static functions which have the same names as the proxy handler methods. Some of these methods are also the same as corresponding methods on Object, although they do have some subtle differences between them.

The major use case of Reflect is to provide default forwarding behavior in Proxy handler traps. A trap is used to intercept an operation on an object — it provides a custom implementation for an object internal method. The Reflect API is used to invoke the corresponding internal method. For example, the code below creates a proxy p with a deleteProperty trap that intercepts the [[Delete]] internal method. Reflect.deleteProperty() is used to invoke the default [[Delete]] behavior on targetObject directly. You can replace it with delete, but using Reflect saves you from having to remember the syntax that each internal method corresponds to.

const p = new Proxy({}, {
  deleteProperty(targetObject, property) {
    // Custom functionality: log the deletion
    console.log("Deleting property: ", property);

    // Execute the default introspection behavior
    return Reflect.deleteProperty(targetObject, property);
  }
});

The Reflect methods also allow finer control of how the internal method is invoked. For example, Reflect.construct() is the only way to construct a target function with a specific new.target value. If you use the new operator to invoke a function, the new.target value is always the function itself. This has important effects with subclassing. For another example, Reflect.get() allows you to run a getter with a custom this value, while property accessors always use the current object as the this value.

Static properties

Reflect[@@toStringTag]

The initial value of the @@toStringTag property is the string "Reflect". This property is used in Object.prototype.toString().

Static methods

Reflect.apply()

Calls a target function with arguments as specified by the argumentsList parameter. See also Function.prototype.apply().

Reflect.construct()

The new operator as a function. Equivalent to calling new target(...argumentsList). Also provides the option to specify a different prototype.

Reflect.defineProperty()

Similar to Object.defineProperty(). Returns a boolean that is true if the property was successfully defined.

Reflect.deleteProperty()

The delete operator as a function. Equivalent to calling delete target[propertyKey].

Reflect.get()

Returns the value of the property. Works like getting a property from an object (target[propertyKey]) as a function.

Reflect.getOwnPropertyDescriptor()

Similar to Object.getOwnPropertyDescriptor(). Returns a property descriptor of the given property if it exists on the object, undefined otherwise.

Reflect.getPrototypeOf()

Same as Object.getPrototypeOf().

Reflect.has()

Returns a boolean indicating whether the target has the property. Either as own or inherited. Works like the in operator as a function.

Reflect.isExtensible()

Same as Object.isExtensible(). Returns a boolean that is true if the target is extensible.

Reflect.ownKeys()

Returns an array of the target object's own (not inherited) property keys.

Reflect.preventExtensions()

Similar to Object.preventExtensions(). Returns a boolean that is true if the update was successful.

Reflect.set()

A function that assigns values to properties. Returns a boolean that is true if the update was successful.

Reflect.setPrototypeOf()

A function that sets the prototype of an object. Returns a boolean that is true if the update was successful.

Examples

Detecting whether an object contains certain properties

const duck = {
  name: "Maurice",
  color: "white",
  greeting() {
    console.log(`Quaaaack! My name is ${this.name}`);
  },
};

Reflect.has(duck, "color");
// true
Reflect.has(duck, "haircut");
// false

Returning the object's own keys

Reflect.ownKeys(duck);
// [ "name", "color", "greeting" ]

Adding a new property to the object

Reflect.set(duck, "eyes", "black");
// returns "true" if successful
// "duck" now contains the property "eyes: 'black'"

Specifications

Specification
ECMAScript Language Specification
# sec-reflect-object

Browser compatibility

BCD tables only load in the browser

See also