prototypal-inheritance

I'm using this clone method for prototypal inheritance from Pro JavaScript Design Patterns which is basically the same as Crockford's object() function . (The only difference is that Crockford adds invoke parens, but since F is empty I'm not sure that it matters. I don't think that the issue.) clone = function(object) { function F() {} F.prototype = object; return new F; }; So, applying this, I'm looking to make two objects, one which inherits methods from the other. One is for viewport dimensions and one is for device dimensions. But both use similar math comparisons so I think it makes sense

I have been re-factoring someone else's JavaScript code. BEFORE: function SomeObj(flag) { var _private = true; this.flag = (flag) ? true : false; this.version="1.1 (prototype)"; if (!this._someProperty) this._init(); // leading underscore hints at what should be a 'private' to me this.reset(); // assumes reset has been added... } SomeObj.prototype.reset = function() { /* perform some actions */ } /* UPDATE */ SomeObj.prototype.getPrivate = function() { return _private; // will return undefined } /* ...several other functions appended via `prototype`...*/ AFTER: var SomeObj = function (flag) {

Background: The module query-string is for example able to parse key=value&hello=universe to an object {key: 'value', hello: 'universe'} . However, the module author has decided that the returned object does not have a prototype. In other words, this "bastard" object is created by Object.create(null) . Problem: It would be convenient to use parsed.hasOwnProperty('hello') but that is not possible without the default object prototype. Of course, one could Object.prototype.hasOwnProperty.call(parsed, 'hello') but I think we can all agree that such an expression is kill-immediately-after-birth

Identifying which objects are which is complicated in JavaScript, and figuring out which objects are arrays has something of a hacky solution . Fortunately, it manages to work in both of the following cases: Object.prototype.toString.call([]); // [object Array] Object.prototype.toString.call(new Array()); // [object Array] Great, no [object Object] in sight! Sadly, this method still manages to fail with this: var arr = Object.create(Array.prototype); Object.prototype.toString.call(arr); // [object Object] This is frustrating, so say the least. My arr object has all the methods of an array, it

Just experimenting with different inheritance techniques in JS, and came across something mildly discomfiting about Crockford's Prototypal Inheritance pattern: function object(o) { function F() {} F.prototype = o; return new F(); } var C, P = { foo:'bar', baz: function(){ alert("bang"); } } C = object(P); It's all good - except when you log to console - the object appears as F. I've seen classical emulation in which you can repoint the constructor - is there a similar method to coerce the objects (console) reference? The issue is that it's referring to the name of the constructor function.

I have observed that through the use of "prototype" property in Javascript (and indirectly setting up the prototype chain), one can implement multi-level inheritance in JavaScript. But is it possible to implement multiple inheritance in Javascript by some way? Any simple examples would be great. To implement simple inheritance you usually do MyClass.prototype = new MySuperClass(); but you could also copy the content of another "class" : MyClass.prototype = new MySuperClass(); var myOtherSuperClass = new MyOtherSuperClass(); for (var key in myOtherSuperClass) { MyClass.prototype[key] =