CKTIS / JavaScript
Function.prototype versus a function's prototype property
Functions inherit invocation methods from `Function.prototype`. With ordinary `new Ctor()`, the value of `Ctor.prototype` becomes the new instance's prototype only if it is an object.
Version: ECMAScript and Web APIs; exact feature edition and browser support reviewed per entry; Node 24 in repository does not prove browser API support
Syntax
Function.prototype
fn.call(thisArg, ...args)
fn.apply(thisArg, argArray)
fn.bind(thisArg, ...args)
Ctor.prototype
Object.getPrototypeOf(fn)
Object.getPrototypeOf(instance)Function.prototype is a shared object in functions' prototype chains. An ordinary declaration function Ctor() {} creates a function for which Object.getPrototypeOf(Ctor) === Function.prototype. Function.prototype itself is callable and returns undefined, but does not support new.
A function's own Ctor.prototype property (the function instance prototype property) serves a different purpose: with ordinary new Ctor(), its value becomes the internal prototype of the instance being created only if that value is an object. If the value is a primitive, including null, construction uses the intrinsic Object.prototype of the constructor's realm instead. Ctor.prototype does not determine the prototype of the function Ctor itself. The default Ctor.prototype object has a constructor property pointing to Ctor.
Function.prototype.call invokes a function with a supplied thisArg and separate arguments; Function.prototype.apply accepts arguments as an array-like object. Function.prototype.bind does not invoke the function immediately: it creates a new function with a fixed thisArg and optional leading arguments. These methods cannot change an arrow function's lexical this.
Having .prototype does not prove support for new: generators have this property but are not constructors. Arrow functions do not have it by default. A function bound with bind also lacks its own .prototype, but can support new if its target is a constructor; in that case, the bound thisArg is ignored.
Examples
"use strict";
function Counter(value) {
this.value = value;
}
Counter.prototype.add = function (amount) {
return this.value + amount;
};
const counter = new Counter(10);
const add = Counter.prototype.add;
const addTwo = add.bind(counter, 2);
console.log(Object.getPrototypeOf(Counter) === Function.prototype);
console.log(Object.getPrototypeOf(counter) === Counter.prototype);
console.log(Counter.prototype === Function.prototype);
console.log(add.call(counter, 2));
console.log(add.apply(counter, [2]));
console.log(addTwo());Result
true true false 12 12 12
The displayed code and declared result were verified in an isolated environment using the method recorded in the verification evidence for this exact version.