On the prototype chain of an object, some objects' .constructor.prototype doesn't point to its [[prototype]], but points to that object itself

Question

The source object that printing the prototype chain can be various:

• [1, 2, 3] // array literal
• {a: 1} // object literal
• new Set() // built-in set
• new Promise( () =>{} ) // built-in Promise
• function foo(){} // a function as object
• window // global window object from DOM

In effect, any object will be okay.

My expectation is that this expression is always true:

anyObject.constructor.prototype === Object.getPrototypeOf(anyObject)

Here is the code to print prototype chain and the constructor of every objects on the chain, and a tip to elaborate where that constructor points to.

function chain(o) {
    while (o) {
        console.dir(o);

        let tip = '';
        if (o.constructor.prototype === Object.getPrototypeOf(o))
            tip = 'points to the next object on the chain, i.e. its [[prototype]].';

        else if (o.constructor.prototype === o)
            tip = 'points to the above object itself.';

        else tip = 'NEVER EXECUTED TO HERE';

        console.log('Its constructor:', o.constructor, tip)
        o = Object.getPrototypeOf(o);
    }
}

Example results:

According to the results, we can find out that not every object on the chain is as my expectation.

How to understand this design?

Answer 1

My expectation is that this expression is always true:

anyObject.constructor.prototype === Object.getPrototypeOf(anyObject)

Well that expectation is simply wrong.

const anyObject = {constructor: null};
const anyObject = {constructor: {prototype: "something"}};

are trivial examples where it fails, however it is more customary to see

const constructor = {prototype: null};
const prototype = {constructor};
constructor.prototype = prototype;

where prototype.constructor.prototype points back to prototype itself, and has nothing to do with the prototype chain that Obect.getPrototypeOf(prototype) inspects.

And really just this circular reference can be found on virtually any .prototype object of any class, be it (class {}).prototype, Array.prototype or Function.prototype.

Your expectation holds only for instances that inherit their .constructor property, whose .prototype in turn points to the [[prototype]] of the instance.