How to organize inheritance in Javascript so that static methods are inherited?

Question

JavaScript

My inheritance works like this:

var Parent = function(){
    this.foo='foo';
};
Parent.prototype.method = function(){
    console.log('i am not static');
};
Parent.staticMethod = function(){
    console.log('i am static');
}

var Child = function(){
    Parent.apply(this, arguments);  
    this.bar = 'bar';
};
Child.prototype = new Parent();

var kid = new Child();
kid.method();//все оукей
Child.staticMethod();//undefined is not a function

As you noticed, Child.staticMethod === undefined.
I know what can be done:
Child.staticMethod = Parent.staticMethod
This solution does not eliminate me, because there are a lot of static methods, the class hierarchy will constantly grow and I don’t want to add a line of code for each class and method.
Please share your ideas for implementing inheritance in javascript, in which you can conveniently inherit static methods.

Answer 1

extend?
function extend(target, source) {
for (var prop in source) {
if (source.hasOwnProperty(prop)) {
target[prop] = source[prop];
}
}
return target;
}

Answer 2

And who needs a little perversion? Our functions are first-class citizens :)

var SuperClass = function (callback) {
  callback.staticMethod = function () {
    console.log('I\'m static');
  };
  return callback;
};

var Parent = SuperClass(function () {
  this.foo = 'foo';
});
Parent.prototype = {
  method: function () {
    console.log('I\'m not static');
  }
};

var Child = SuperClass(function () {
  Parent.apply(this, arguments);
  this.bar = 'bar';
});
Child.prototype = Object.create(Parent.prototype);

var kid = new Child();

console.log(kid.foo);
console.log(kid.bar);
kid.method();
Parent.staticMethod();
Child.staticMethod();

And by the way, because of this:
you get the foo property in the Parent prototype. Are you sure this is what you wanted?

Answer 3

I like the way it's done in Backbone .

Answer 4

We send IE10 to hell - and all inheritance, both prototype and static methods, boils down to:

Child.__proto__ = Parent;
Child.prototype.__proto__ = Parent.prototype;