功能的JavaScript原型等效

Question

I am reading JavaScript: Good parts by Douglas Crockford. I came across this following useful trick.

Function.prototype.method = function (name, func) {
    if (!this.prototype[name]) {
        this.prototype[name] = func;
    }
};

Based on the above code snippet, what I understood is, as all functions are objects of Function and as the above function adds the 'method' method to prototype of Function , there will be a method method available on all functions.

var pfun = function(name){
    this.name = name;
};

Consider the following log statements

console.log(Function.prototype.isPrototypeOf(pfun));//true - Thats fine
console.log(pfun.prototype == Function.prototype);//false - why?

I couldn't understand why the above logs contradict each other.

Here pfun is a functions which has the method method available from its prototype. So I can call the following.

pfun.method("greet",function(){
      console.log(this.name);
});

Now as method method runs, it adds the greet method to pfun 's prototype. If the above logs doesn't contradict each other, then greet method should be available to all functions.

My question is, why the above logs are contradicting each other?

Answer 1

They don't contradict each other. Your pfun has a prototypal inheritance from Function , but it's not a reference to Function's prototype. It has its own prototype (that is derived from Function's one).

So, when you ask if Function.prototype.isPrototypeOf(pfun) , you get true , because pfun 's prototype is derived from Function's one. But when you ask if pfun.prototype is equal to Function.prototype , you get false , because it's false, pfun has its own prototype.

The method greet is added only to the pfun 's prototype, and not to the Function 's one.

But if you do:

Function.prototype.method('greet', function() {
  console.log(this.name);
});

Then, all the function 's prototypes (that will be derived from Function.prototype ) will have the greet method in its prototype, because of the prototypal inheritance.

Answer 2

isPrototypeOf checks to see if an object is referenced by the internal [[Prototype]] property of another object.

All ECMAScript native functions inherit from Function.prototype therefore:

Function.prototype.isPrototypeOf(pfun))

returns true.

Every native function created by the Function constructor has a default public prototype property that is a plain object (see ECMAScript §13.2 #16 ). So when you do:

pfun.prototype == Function.prototype

you are comparing this plain object to Function.prototype ¹ , which are different objects.

This confusion is brought about in discussion because the public and private prototype properties are often only distinguished by the context in which the term is used. All native Functions have both, and only for the Function constructor are they the same object by default, ie

Object.getPrototypeOf(Function) === Function.prototype

returns true. This relationship can be established for other Objects, but it doesn't happen by default (and I can't think of an example or sensible reason to do it).

¹ The Function.prototype object is a bit of an oddity. It has an internal [[Class]] value of "function" and is callable, so in that regard it's a function. However, its internal [[Prototype]] is Object.prototype , so it can probably be called an instance of Object. When called, it ignores all arguments and returns undefined .