When a function is called with new
, the constructor's prototype
property will become the resulting object's prototype.
function Ctor() {}
const inst = new Ctor();
console.log(Object.getPrototypeOf(inst) === Ctor.prototype);
You can read Inheritance and the prototype chain for more information about the interactions between a constructor function's prototype
property and the resulting object's prototype.
A function having a prototype
property is not sufficient for it to be eligible as a constructor. Generator functions have a prototype
property, but cannot be called with new
:
async function* asyncGeneratorFunction() {}
function* generatorFunction() {}
Instead, generator functions' prototype
property is used when they are called without new
. The prototype
property will become the returned Generator
object's prototype.
In addition, some functions may have a prototype
but throw unconditionally when called with new
. For example, the Symbol()
and BigInt()
functions throw when called with new
, because Symbol.prototype
and BigInt.prototype
are only intended to provide methods for the primitive values, but the wrapper objects should not be directly constructed.
The following functions do not have prototype
, and are therefore ineligible as constructors, even if a prototype
property is later manually assigned:
const method = { foo() {} }.foo;
const arrowFunction = () => {};
async function asyncFunction() {}
The following are valid constructors that have prototype
:
class Class {}
function fn() {}
A bound function does not have a prototype
property, but may be constructable. When it's constructed, the target function is constructed instead, and if the target function is constructable, it would return a normal instance.
const boundFunction = function () {}.bind(null);
A function's prototype
property, by default, is a plain object with one property: constructor
, which is a reference to the function itself. The constructor
property is writable, non-enumerable, and configurable.
If the prototype
of a function is reassigned with something other than an Object
, when the function is called with new
, the returned object's prototype would be Object.prototype
instead. (In other words, new
ignores the prototype
property and constructs a plain object.)
function Ctor() {}
Ctor.prototype = 3;
console.log(Object.getPrototypeOf(new Ctor()) === Object.prototype);