prototypal-inheritance

问题 I am attempting to pass a test suite utilizing inheritance through JavaScript. Below is a snippet of the code I have so far: var Infant = function() { this.age = 0; this.color = \'pink\'; this.food = \'milk\'; }; Infant.prototype.eat = function(){ return this.eat; } var Adolescent = function() { this.age = 5; this.height = \'short\'; this.job = \'keep on growing\'; }; I would like to inherit the food property from the Infant class and the eat method but my attempts have fallen short. my

问题 I have a JavaScript function object as; var addNum = function(num1, num2) { return num1 + num2; } Now if I try to access addNum.divide() I wanted to understand the prototype chain for the above code. I read that in the above example, addNum would be searched for divide(), followed by Function.prototype and finally Object.prototype. But my question is in the above example, how can addNum would be searched for divide() Does it refer to something like ; var addNum = function(num1, num2) { this

问题 This figure again shows that every object has a prototype. Constructor function Foo also has its own __proto__ which is Function.prototype, and which in turn also references via its __proto__ property again to the Object.prototype. Thus, repeat, Foo.prototype is just an explicit property of Foo which refers to the prototype of b and c objects. var b = new Foo(20); var c = new Foo(30); What are the differences between __proto__ and prototype ? The figure was taken from dmitrysoshnikov.com. 回答1

问题 I\'ve been reading \"Javascript: The Good Parts\" by Douglas Crockford - and while it\'s a bit extreme, I\'m on board with a lot of what he has to say. In chapter 3, he discusses objects and at one point lays out a pattern (also found here) for simplifying & avoiding some of the confusion/issues that come with the use of the built-in \"new\" keyword. if (typeof Object.create !== \'function\') { Object.create = function (o) { function F() {} F.prototype = o; return new F(); }; } newObject =

问题 The API Reference Scope page says: A scope can inherit from a parent scope. The Developer Guide Scope page says: A scope (prototypically) inherits properties from its parent scope. So, does a child scope always prototypically inherit from its parent scope? Are there exceptions? When it does inherit, is it always normal JavaScript prototypal inheritance? 回答1: Quick answer : A child scope normally prototypically inherits from its parent scope, but not always. One exception to this rule is a

问题 Every JS opinion leader says that extending the native objects is a bad practice. But why? Do we get a perfomance hit? Do they fear that somebody does it \"the wrong way\", and adds enumerable types to Object , practically destroying all loops on any object? Take TJ Holowaychuk\'s should.js for example. He adds a simple getter to Object and everything works fine (source). Object.defineProperty(Object.prototype, \'should\', { set: function(){}, get: function(){ return new Assertion(Object(this