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 inObject.prototype.toString()
.
Static methods
Reflect.apply()
-
Calls a
target
function with arguments as specified by theargumentsList
parameter. See alsoFunction.prototype.apply()
. Reflect.construct()
-
The
new
operator as a function. Equivalent to callingnew target(...argumentsList)
. Also provides the option to specify a different prototype. Reflect.defineProperty()
-
Similar to
Object.defineProperty()
. Returns a boolean that istrue
if the property was successfully defined. Reflect.deleteProperty()
-
The
delete
operator as a function. Equivalent to callingdelete 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 istrue
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 istrue
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
- The
Proxy
global object - The
Proxy()
constructor