JavaScript Reflect.construct() Method

Beginner
6 min read
Updated: Nov 2026
3 examples
Static method

Definition

Reflect.construct(target, argumentsList) creates a new object from a constructor, just like new target(...argumentsList). The difference is that it is a normal function call, and the arguments come as an array.

An optional third argument, newTarget, lets you choose which constructor the new object should belong to. In everyday code you will mostly use the two-argument form.

Remember
Reflect.construct(target, argumentsList, newTarget)

target         → a constructor (class or function)
argumentsList  → an array of arguments
newTarget      → optional: who the object is an instance of

same as: new target(...argumentsList)
arrow functions are not constructors

Syntax

Pass a constructor and an array of arguments. The result is a new object.

JavaScript
class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}

const p = Reflect.construct(Point, [1, 2]);
console.log(p.x + ", " + p.y);        // 1, 2
console.log(p instanceof Point);      // true
CallWhat it does
Reflect.construct(Point, [1, 2])The same as new Point(1, 2).
Reflect.construct(Array, [3])Build built-in objects too, for example an array with length 3.
Reflect.construct(A, [], B)Run the constructor of A, but make the object an instance of B.
new Point(...args)The spread syntax is the shorter way when you do not need newTarget.

A standard JavaScript static method (ES2015) of the Reflect object: call it as Reflect.construct(). No import required. Siblings: Reflect.apply(), Reflect.defineProperty(), Reflect.deleteProperty(), Reflect.get(), Reflect.getOwnPropertyDescriptor(), Reflect.getPrototypeOf(), Reflect.has(), Reflect.isExtensible(), Reflect.ownKeys(), Reflect.preventExtensions(), Reflect.set(), Reflect.setPrototypeOf().

Library declarations
JavaScript
// ECMAScript 2015 (ES6)
Reflect.construct(target, argumentsList)
Reflect.construct(target, argumentsList, newTarget)

// target        : a constructor
// argumentsList : an array-like object
// newTarget     : optional constructor
// returns       : the new object
// throws        : TypeError if target or newTarget is not a constructor

Parameters

ParameterDescription
targetRequired. The constructor to run, such as a class, a function, or a built-in like Map. Arrow functions and methods are not constructors and throw a TypeError.
argumentsListRequired. An array, or an array-like object, with the arguments for the constructor. Use [] for none.
newTargetOptional. A constructor that decides the prototype of the new object and what new.target is. It defaults to target.

Return Value

Return ValueDescription
ObjectThe new object that the constructor created. Its prototype comes from newTarget (or from target if you did not pass one).
TypeError (thrown)target or newTarget is not a constructor, or argumentsList is not an object.

JavaScript Examples

Example 1 — Create an Object from a Class

Create a Point object with Reflect.construct() and check that it is a real instance.

JavaScript
class Point {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
}

const args = [1, 2];
const p = Reflect.construct(Point, args);

console.log("x, y: " + p.x + ", " + p.y);
console.log("Instance of Point: " + (p instanceof Point));
console.log("Same as new: " + (JSON.stringify(p) === JSON.stringify(new Point(1, 2))));
Try It Yourself

How It Works

  1. Pass the arguments as an array. Reflect.construct(Point, args) runs the Point constructor with 1 and 2.
  2. A real instance. The new object has the right properties and instanceof Point is true.
  3. Same as new. Comparing the two objects as text shows that new Point(1, 2) gives the same result.

Example 2 — Create Built-in Objects

Constructors that come with JavaScript work too. The arguments always go inside an array.

JavaScript
const list = Reflect.construct(Array, [3]);
console.log("Array length: " + list.length);

const error = Reflect.construct(Error, ["Something broke"]);
console.log("Error message: " + error.message);
console.log("Is an Error: " + (error instanceof Error));

const map = Reflect.construct(Map, [[["a", 1], ["b", 2]]]);
console.log("Map size: " + map.size);
console.log("Value of b: " + map.get("b"));
Try It Yourself

How It Works

  1. One argument, one array. [3] is the argument list for Array, so it works like new Array(3), an array with 3 empty slots.
  2. Error. The message goes in the argument list, and the result is a real Error object.
  3. Map. A Map takes one argument, a list of pairs. That list must be wrapped in the argument array, so you see a double pair of brackets.

Example 3 — Use newTarget and Check the Errors

Run one constructor but make the object an instance of another class. Then see what is not allowed. The catch block prints the error type only.

JavaScript
class A {
  constructor() {
    this.kind = new.target.name;
  }
}
class B {}

const obj = Reflect.construct(A, [], B);
console.log("kind: " + obj.kind);
console.log("Instance of B: " + (obj instanceof B));
console.log("Instance of A: " + (obj instanceof A));

try {
  Reflect.construct(() => {}, []);
} catch (err) {
  console.log("Arrow function: " + err.name);
}
Try It Yourself

How It Works

  1. A different newTarget. The constructor of A runs, but new.target inside it is B, so kind is "B".
  2. The prototype follows newTarget. The object gets the prototype of B, so it is an instance of B and not of A.
  3. Not a constructor. An arrow function cannot be used with new, so Reflect.construct() throws a TypeError for it as well.

Browser & Runtime Support

Reflect.construct() is part of ES2015 (ES6), together with the Reflect object. Every current browser and Node.js has it.

✓ ES2015 · Widely supported

Reflect.construct()

Supported in Chrome 49+, Edge 12+, Firefox 42+, Safari 10+, Opera 36+ and Node.js 6+. Internet Explorer never got it.

ES2015 Standard since
Google Chrome 49+ · Desktop & Mobile
Full support
Microsoft Edge 12+ · Chromium and legacy
Full support
Mozilla Firefox 42+ · Desktop & Mobile
Full support
Apple Safari 10+ · macOS & iOS
Full support
Opera 36+ · Chromium based
Full support
Samsung Internet Recent versions · Android
Supported
Android WebView 49+ · Chromium based
Supported
Node.js 6+ · Server runtime
Supported
Deno Supported · JavaScript runtime
Supported
Bun Supported · JavaScript runtime
Supported
Internet Explorer No native support
Not supported
Reflect.construct() Excellent

Bottom line: Safe to use in every current browser and in Node.js. The only thing to plan for is Internet Explorer, which has no Reflect at all.

Frequently Asked Questions

It creates a new object from a constructor, like the new keyword, but as a function call. The arguments are passed as an array, and you can optionally choose the newTarget.
new Point(1, 2) is a special syntax. Reflect.construct(Point, [1, 2]) is a normal function, so you can pass it around, build the argument list in code, and also set newTarget. For simple cases, new is shorter.
It decides which constructor the new object belongs to. The target constructor still runs, but the object gets the prototype of newTarget, and new.target inside the constructor is newTarget. Libraries use it for subclassing and in Proxy traps.
Only constructors: classes, regular functions and built-ins like Array, Map or Error. Arrow functions and object methods are not constructors, so they throw a TypeError.
A Proxy can intercept new with a construct trap. Inside the trap, Reflect.construct(target, args, newTarget) creates the object in the normal way, so you can add logging or checks around it.

Next: Reflect.defineProperty()

Learn how to add or change a property with full control, and get true or false instead of an error.

Reflect.defineProperty() tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

10 people found this page helpful