Extend descendent object in javascript

I've been learning more about javascript's prototypal inheritance. I know there is a somewhat fierce debate on whether to extend native objects and I'd like to side step that whole debate entirely in this qu开发者_开发技巧estion.

Is it possible to extend only descendent object in javascript?

To extend all objects I can do this:

Object.prototype.size = function(){
      var length = 0;
      for(var i in this){
           if(this.hasOwnProperty(i)){
              length++;
           }
      }
      return this;
 }

But the problem is that It extends all objects. What I'd like to do is have this:

var MyNameSpace = function(){

};

MyNameSpace.Object.prototype.size = function(){
     var length = 0;
     for(var i in this){
         if(this.hasOwnProperty(i)){
             length++;
         }
     }
     return this;
}

That way I would only be extending the native objects in the scope of my global object.

any suggestions would be great thanks

Update:

In response to a few comments I'm adding more code to clarify what I'm trying to do.

I think i may have not phrased my question correctly, or maybe my thinking is incorrect, but what i'd like to be able to do is this:

    var my = new MyNameSpace();
    var my.name = {firstName : 'Hello', lastName : 'World'};
    var nameCount = my.name.size(); // 2

the code you provided will allow me to get the size of each MyNameSpace object I create, but not the object literals that are properties of the MyNameSpace object

You could use "pseudo-classical" inheritance style to achieve it:

var MyNameSpace = function() {
  this.v1 = null;
  this.v2 = null;
}

MyNameSpace.prototype.size = function() {
  var length = 0;
  for(var i in this){
    if(this.hasOwnProperty(i)){
      length++;
    }
  }
  return this;
}

var my = new MyNameSpace(); // create new object based on MyNameSpace
my.size(); // length would be 2

What you define on a function object's prototype would be inherited by all the function objects created via new operator.

Updated code, according to your added requirements,

var obj = {};

var MyNameSpace = function(props) {
  for(var name in props) {
    this[name] = props[name];
  }
}

MyNameSpace.prototype.size = function() {
  var length = 0;
  for(var i in this){
    if(this.hasOwnProperty(i)){
      length++;
    }
  }
  return this;
}

obj.name = new MyNameSpace({firstName : 'Hello', lastName : 'World'});
obj.name.size(); // length would be 2

In your code

var my = new MyNameSpace();
var my.name = {firstName : 'Hello', lastName : 'World'};
var nameCount = my.name.size(); // 2

my.name is obviously traversable from my, but the opposite is not true. That means that properties of my cannot be accessed from my.name, and my is nowhere to be found in the prototype chain of my.name. If you don't want to inherit directly from MyNameSpace you have to explicitly "hang on" whatever functions you would like to inherit.

You could do

my.name.size = my.size;

alternatively (without having to instantiate MyNameSpace):

my.name.size = MyNameSpace.prototype.size;

if you have only few functions to "inherit". Or you could define an inherit function in MyNameSpace as follows:

MyNameSpace.prototype.addToNameSpace = function(obj) {
  obj.size = this.size;
  // obj.propertyI = this.propertyI, etc.
}

Note that I don't use for..in here as that would add the addToNameSpace function as well.

Hope this helps