Visibility of prototype property of a function vs. object on console

Question

When we define these variables on console :

var a = function(){} ;
var b = {} ;
var c = new a();

and type the below expressions on console again :

a.prototype 
// we have an a object with properties constructor and __proto__
b.prototype
// no result and why ? Isn t the prototype the Object 
c.prototype
// no result here too.

So I know almost every type in js is an object and has the prototype of global object. Why don t we see the last two prototype properties ? Is it about the property descriptors or what ? I just assume it has a simple answer.

you mean `b.constructor.prototype` ? `c.constructor.prototype === a.prototype` — Hacketo, Dec 18 '15 at 08:26

jfriend00 · Accepted Answer · 2015-12-18T08:48:36.930

The property named .prototype is a property of a constructor function only. It is stored elsewhere for an actual object instance and is not accessible as .prototype there.

In modern browsers, you can use Object.getPrototypeOf(obj) to get the prototype of an object instance. See MDN for details.

In some older browsers, you could get to it with obj.__proto__.

There is no common reason to access the prototype itself on an object instance. It is meant to be the recipe by which new objects are created and THE place to access it is on the constructor as that controls how new objects are created. It is used internally by Javascript on an object instance so it is stored internally. If you're asking why a prototype-based language is designed that way, you're asking the wrong person - that's just how a prototype-based system is designed to be used.

You are meant to interact with the actual property values on an instance of an object, not with the prototype. The central place to access the prototype is via the constructor. There are some special cases of morphing an existing object instance by changing the prototype of an existing instance, but that is not a common design paradigm in prototype-based programming.

In C++ (which is not a prototype-based language, but shares some object oriented concepts), you change the class definition if you want to change how new objects of that type are created. You don't change one instance of a class and expect it to change how new objects of that type are created.

it's stored in [`.constructor.prototype`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor) — Hacketo, Dec 18 '15 at 08:45
@Hacketo - maybe, maybe not. the `.constructor` property is not always set properly. The ECMAScript specified way to get the prototype for a specific object instance is `Object.getPrototypeOf(obj)` or `obj.__proto__` for older browsers. — jfriend00, Dec 18 '15 at 08:49
@Hacketo - Yeah, but it isn't what the actual object uses and the `.constructor` property can be set to anything without changing the behavior of the object in any way. Whereas `Object.getPrototypeOf(obj)` goes right into the bowels of the object and gets the actual prototype that is being used by the live object. — jfriend00, Dec 18 '15 at 08:55

score 1 · Answer 2 · answered Dec 18 '15 at 09:44

First of all, you are right, every data structure in JavaScript has its own prototype. However, in language grammar level, only function has the prototype property.

What about others? Well you can't do it with a property key. What you thought of is actually an internal down to the language engine. If you read the ECMAScript spec, you will notice the [[Prototype]] in several sections.

Previously, some browsers provide a __proto__ property, which enables you to access the [[Prototype]], but it's a vendor feature, not part of the spec so unreliable.

Now in ES6 there's a new method for such purpose: Object.getPrototypeOf().

One more thing, think about instanceof operator. It's actually comparing an object's __proto__ to a constructor's prototype property.

Visibility of prototype property of a function vs. object on console

2 Answers2