Menu
In Javascript, any "function object" has a prototype
> F = function() {}
F()
> F.prototype
F {}
But "object" or "instance" doesn't have a prototype
> o = {}
Object {}
> o.prototype
undefined
> f = new F()
F {}
> f.prototype
undefined
However, the built-in object "Function" and "Object" have a prototype:
> Function.prototype
Empty()
> Object.prototype
Object {}
This looks quite confusing for me.
Function and "function object" have a prototype property
Object has a prototype property, but "object literal" and "instance object" doesn't have a prototype property
What does the prototype property actually mean? In the example above, shouldn't the prototype property of f be F?
Does anyone have ideas about how to explain this? Thanks!
728
Each and every JavaScript function will have a prototype property which is of the object type. You can define your own properties under prototype . When you will use the function as a constructor function, all the instances of it will inherit properties from the prototype object.
Both objectOne and objectTwo are non-function objects therefore they don't have a prototype property.
Note: Not all Function objects have the prototype property — see description.
Every object in JavaScript has a built-in property, which is called its prototype. The prototype is itself an object, so the prototype will have its own prototype, making what's called a prototype chain. The chain ends when we reach a prototype that has null for its own prototype.
Don't confuse the prototype attribute of a function with the internal prototype of an object (which places the object in the prototype chain).
Function and Object are constructor functions, as such, they have a prototype attribute, which will be assigned as the internal prototype of objects created with these constructor functions.
I recommend Eloquent Javascript's chapter "The secret life of objects", particularly for this quote:
It is important to note the distinction between the way a prototype is associated with a constructor (through its
prototypeproperty) and the way objects have a prototype (which can be retrieved withObject.getPrototypeOf). The actual prototype of a constructor is Function.prototype since constructors are functions. Itsprototypeproperty will be the prototype of instances created through it but is not its own prototype.
71
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
