Subclassing a class with required parameters in Ja

问题:

If subclassing a "class" in JavaScript is done like so:

var ParentClass = function() {
    // something
};


var ChildClass = function() {
    // something
};

ChildClass.prototype = new ParentClass();

... what should I do when the parent class has required parameters?

var ParentClass = function(requiredParameter) {
    if (typeof requiredParameter === 'undefined') {
        throw new TypeError("'requiredParameter' is required!");
    }
};


var ChildClass = function() {
    // something
};

ChildClass.prototype = new ParentClass();
// ^ Throws TypeError

Thanks.

回答1:

Subclass it like this instead:

function clone (obj) {
  if (!obj) return;
  clone.prototype = obj;
  return new clone();
}

var ParentClass = function() {
    // something
};


var ChildClass = function() {
    // something
};

ChildClass.prototype = clone(ParentClass.prototype);
ChildClass.prototype.constructor = ChildClass; // if you want

Now you don't have to worry about it, because you don't have to call the parent constructor to subclass it :)

回答2:

This is how its done:

function Parent( a ) {
    this.a = a;
}

function Child( a, b ) {
    Parent.call( this, a ); // this is crucial
    this.b = b;
}

Child.prototype = Object.create( Parent.prototype );
Child.prototype.constructor = Child;

Live demo: http://jsfiddle.net/ECCgt/ (analyze the instances in the console)

---

The way you're doing it

ChildClass.prototype = new ParentClass();

is a dirty hack which is broken and should be avoided. Use Object.create to set up the inheritance relationship between the two prototype objects.

The second line

Child.prototype.constructor = Child;

is somewhat optional. We are correcting the constructor property because we had to overwrite Child.prototype in order to set up the inheritance. If you don't care about the constructor property, just leave out that line.

回答3:

A better way to inherit...

var inherit = (function () {
  var F = function () {}; // cache function
  return function (C, P) { // Accepts Constructor and Parent
    F.prototype = P.prototype;
    // faster prototype chain lookup than direct instantiation
    C.prototype = new F(); 
    C._super = P.prototype;
    C.prototype.constructor = C; // for checking instanceof
  };
}());