JavaScript -- null 或 Object.prototype 中原型链的结尾是什么？

Question

I've been reading about the prototype chain in JavaScript and came to two slightly different definitions. It is said that every object in JavaScript has a prototype and that prototype in turn has another prototype.

The top prototype (Grand) may also have prototype and the chain can continue. Now the chain will stop at one last object. JavaScript: The Good Parts says the chain terminates at Object.prototype and MDN says null is the final link where the chain terminates.

Javascript: The Good Parts

Every object is linked to a prototype object from which it can inherit properties. All objects created from object literals are linked to Object.prototype , an object that comes standard with JavaScript.

---

MDN

Each object has an internal link to another object called its prototype. That prototype object has a prototype of its own, and so on until an object is reached with null as its prototype. null, by definition, has no prototype, and acts as the final link in this prototype chain .

• What is the end of prototype chain in JavaScript -- null or Object.prototype? Or are null and Object.prototype one and the same thing?
• Are objects, which are not created from object literals, not linked to Object.prototype ?
• Say I have an object var x = { len: 4, breadth: 5} . Would JavaScript automatically create its prototype x.prototype ? And how long would the prototype chain be? Would x.prototype have only one prototype, Object.prototype , making a 3 point chain?
• How does JavaScript internally create automatic prototypes?

Answer 1

What is the end of prototype chain in javascript

Null. The only authority on the language is ECMA-262 .

Are objects, which are not created from object literals, not linked to Object.prototype

They may or many not be, eg

var x = Object.create(null)

has a [[Prototype]] of null, whereas:

var y = {};

has a [[Prototype]] of Object.prototype.

Say I have an object var x = { len: 4, breadth: 5}. Would javascript automatically create it's proptotype x.prototype.

No. Function objects have default prototype objects. Plain objects have a default [[Prototype]] (ie internal prototype property) that is Object.prototype (unless constructed as above).

And how long would the prototype chain be? Would x.prototype have only one prototype Object.prototype making a 3 point chain?

Two values: Object.prototype and null .

How does javascript internally creates automatic prototypes?

However it likes, the language specification does not define implementation, only behaviour.

Answer 2

1. It is like, if New York has an envelop and inside, it says Colorado, and Colorado has an envelop, and inside, it says San Francisco, and San Francisco has an envelop, and inside, it says "none". So is San Francisco end of the chain, or is "none" the end of chain? It may depend on how you look at it. But one thing is for sure: it points up and up the chain, for inheritance purpose (prototypal inheritance), until it reaches null , which means can't go further up. And make sure you know that, to go up and up the chain, it is __proto__ . It is not prototype .

2. Object.prototype , Animal.prototype are different from x.__proto__ . The former are function objects (Object, Animal) having a prototype property pointing to a prototype object. And x.__proto__ is how the prototype chain is followed upward. To go up and up, it is x.__proto__.__proto__ and so on. See JavaScript's Pseudo Classical Inheritance diagram to understand it more.

3. Object.prototype refers to a prototype object. Quoted from MDN , null "represents the intentional absence of any object value. It is one of JavaScript's primitive values." So Object.prototype and null are not the same thing.

4. All JavaScript objects will have obj.__proto__ referring ultimately to what Object.prototype refers to. If it is not obj.__proto__ , then it is obj.__proto__.__proto__ . If not, just go up, and up, and it will reach the prototype object which Object.prototype refers to. And at this point, when you go up one level (by adding a .__proto__ , then you get null . You can try it in Google Chrome's developer's tool:

    x = { a : 1 } > Object {a: 1} x.__proto__ === Object.prototype > true x.__proto__.__proto__ > null Object.prototype.__proto__ > null 

Answer 3

What is the end of prototype chain in javascript -- null or Object.prototype ? Or are null and Object.prototype one and the same thing?

null . Consider this code in a normal JavaScript environment:

var o = {};
console.log(o.i_am_a_property_that_does_not_exist);

That property accessor operation ( o.i_am_a_property_that_does_not_exist ) ends up going to the OrdinaryGet abstract operation defined by the specification with O set to the o object above and P set to "i_am_a_property_that_does_not_exist" . That operation starts like this:

1. Assert: IsPropertyKey( P ) is true.
2. Let desc be ? O .[GetOwnProperty].

3. If desc is undefined , then

   a. Let parent be ? O .[GetPrototypeOf].

   b. If parent is null , return undefined .

   c. Return ? parent .[[Get]]( P , Receiver ).

4. ...

For my example above, that [[Get]] operation in 3.c. ends up calling OrdinaryGet recursively until we run out of prototypes. As we can see, the chain ends when we reach null .

Moreover, it's entirely possible to have an object with a prototype chain that doesn't include Object.prototype at all (we'll see some in a moment). So clearly Object.prototype can't be the end of the prototype chain.

Are objects, which are not created from object literals, not linked to Object.prototype ?

The vast majority will be linked to Object.prototype directly or indirectly. Consider:

function Thing() {
}
var t = new Thing();

t 's prototype is the object referenced by Thing.prototype . Thing.prototype 's prototype is Object.prototype . So t is linked to Object.prototype (indirectly).

But it's entirely possible for an object not to be linked to Object.prototype . Here's one way:

var o = Object.create(null);

Object.create lets us create an object with the prototype we specify in the first argument ( null in the above). So o above has no prototype, its [[Prototype]] internal slot (where objects remember their prototypes) is null .

Here's another:

function Thing() {
}
Thing.prototype = Object.create(null);
var t = new Thing();

In that case, although t has a prototype, its prototype's prototype is null; t isn't linked to Object.prototype at all.

Say I have an object var x = { len: 4, breadth: 5} . Would JavaScript automatically create it's prototype x.prototype .

An object's prototype is not a property called prototype , so no, the JavaScript engine wouldn't create x.prototype . An object's prototype is linked via its [[Prototype]] internal slot, which is not directly observable but can be retrieved via Object.getPrototypeOf . (And if the object derives from Object.prototype , then on browsers only [in theory], you can use the Annex B [browser-only] __proto__ property from Object.prototype to access it. But not all objects have that property, because...not all objects inherit from Object.prototype !)

The prototype property is just used on functions to determine what object to use as the [[Prototype]] of new objects created via new with that function. Non-function objects don't have it, and if they did, it wouldn't be any more special than a property called foo or bazinga .

And how long would the prototype chain be? Would x.prototype have only one prototype Object.prototype making a 3 point chain?

You're close, but again, the prototype property is not the prototype of the object, and non-function objects typically won't have a prototype property. For var x = { len: 4, breadth: 5} , the inheritance chain would be:

• x
• x 's [[Prototype]] (which is Object.prototype )
• Object.prototype 's [[Prototype]], which is null

So quite short; 1, 2, or 3 depending on whether you want to count x and whether you want to count null .

How does JavaScript internally creates automatic prototypes?

It doesn't, other than the ones defined by the spec (eg, Object.prototype and such). The closest it comes is that for all function functions, the JavaScript engine automatically creates an object and assigns that object to the function's prototype property just in case that function is used as a constructor (via new ). (It doesn't do this with arrow functions or generators.)

Answer 4

In the browser's console, try creating an object literal:

const myObject = 
{
  city: 'Madrid',
  greet() 
  {
    console.log(`Greetings from ${this.city}`);
  }
}

myObject.greet(); // Greetings from Madrid

This is an object with one data property, city , and one method, greet() .

If you type the object's name followed by a period into the console, like myObject. , then the console will pop up a list of all the properties available to this object.

You'll see that as well as city and greet, there are lots of other properties!

__defineGetter__
__defineSetter__
__lookupGetter__
__lookupSetter__
__proto__
city
constructor
greet
hasOwnProperty
isPrototypeOf
propertyIsEnumerable
toLocaleString
toString
toValueOf

Try accessing one of them:

myObject.toString(); // "[object Object]"

Copy to Clipboard

It works (even if it's not obvious what toString() does).