问题
I understand javascript prototype inheritance through the __proto__ property. However I notice that when I do var f = function() {} f will now have a prototype property in addition to the __proto__ property. It would seem that prototype does not participate in property chaining. What exactly does it do?
回答1:
It gets assigned as the prototype of objects created by using that function via the new keyword.
So for instance:
function Foo() {
}
Foo.prototype.bar = 47;
var obj = new Foo();
alert(obj.bar); // alerts 47, via `obj`'s prototype
The reference between obj and the object assigned to Foo.prototype is a live one, and so adding further things to Foo.prototype will make them show up on obj's prototype:
Foo.prototype.charlie = 62;
alert(obj.charlie); // alerts 62
Naturally, if you replace Foo.prototype (which I discourage), then you're pointing Foo.prototype at a different object. obj will still refer to the old one:
Foo.prototype = {delta: 77}; // Not recommended
alert(obj.delta); // alerts "undefined"
Gratuitous live example
Regarding __proto__: __proto__ is non-standard. Prior to ECMAScript5 (which is just a year and a half old), there was no standard way to interact directly with an object's prototype, you could only assign them at object creation time, and only indirectly via a constructor function's prototype property. __proto__ is a proprietary extension in some JavaScript engines (most notably Mozilla's SpiderMonkey, the engine in Firefox). It's not in any standard, and according to the ECMAScript committee, it won't be. (Instead, ECMAScript5 provides functions for interacting with an object's prototype.) __proto__ is now deprecated by Mozilla.
回答2:
the _proto_ property is a property of an instance of an object (the object being, in this case, a function), it refers to prototype of the instance. You should note that this property is non-standard and depreciated, use Object.getPrototypeOf(ref) instead: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/Proto
prototype, in contrast, is a property of a function declaration (not an instance), and is the prototype for all instances of the function. Check out the docs: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/prototype
When you create a new instance of a function (using the new keyword), a function object is created, as defined by the prototype. After it is instantiated (var myNewObject = new Foo()), a call to Object.getPrototypeOf(myNewObject) will return a reference to the prototype upon which the instance is based.
To sum it up: __proto__ is what something IS, prototype is what something CAN BE (or might already be).
来源：https://stackoverflow.com/questions/6256321/what-does-a-js-functions-prototype-property-used-for