JavaScript 原型继承：简洁的语法？

Question

有没有比三个不同的程序操作更简洁的方式来表达这一点？更像对象符号的东西，或者至少都在 Name 函数的主体中？

问题：

function Name(first, last) {
    this.first = first;
    this.last = last;
}

Name.prototype = new String;

Name.prototype.toString = function() {
   return this.last + ', ' + this.first;
};

测试：

console.log(new Name("jimmy", "dean").toString())
console.log(new Name() instanceof Name);
console.log(new Name() instanceof String);
console.log(new Name() instanceof Object);
console.log(Name.prototype.toString.call(new Name('jimmy', 'dean')));
console.log(Name.prototype.toString.call({
    first: 'jimmy',
    last: 'dean'
}));

预期输出：

< "dean, jimmy"
< true
< true
< true
< "dean, jimmy"
< "dean, jimmy"

Answer 1

Example

function Name(first, last) {
    this.partFirst = first;
    this.partLast = last;
    this.valueOf = this.toString = function() {
        return this.partLast + ', ' + this.partFirst;
    }
}
Name.prototype = new String();

Answer 2

我是这样做的：

function subclass(constructor, superConstructor) {
    function surrogateConstructor() { }

    surrogateConstructor.prototype = superConstructor.prototype;

    var prototypeObject = new surrogateConstructor();
    prototypeObject.constructor = constructor;

    constructor.prototype = prototypeObject;
}



/* Base object */
function BaseItem() {
    this.type = 'baseitem';
    this.obj = null;
}
BaseItem.prototype.render = function() {
    return "foo";
}



/* Sub class */
function InteractionArea() {
    BaseItem.call(this);
    this.type = 'interactionarea'
    this.obj = document.createElement('div')
}
subclass(InteractionArea, BaseItem);

//here come the overrides
InteractionArea.prototype.render = function() {
    return "foobar";
}
InteractionArea.prototype.render2 = function() {
    return "foobar";
}



/* Sub-sub class */
function InteractionArea2() {
    InteractionArea.call(this);
    this.type = 'interactionarea2';
    this.obj = false;
}
subclass(InteractionArea2, InteractionArea);

InteractionArea2.prototype.render = function() {
    return "bar";
}

Answer 3

当然。使用Object.create。

var Name = Object.create(String.prototype, {
  toString: { value: function _toString() {
    return this.partLast + ', ' + this.partFirst;
  } },
  constructor: { value: function _constructor(first, last) {
    this.partFirst = first;
    this.partLast = last;
    return this;
  } }
});

var name = Object.create(Name).constructor("foo", "bar");

现在ES5有点丑，可以用some mechanism for ES5 OO sugar，我们以pd为例：

var Name = pd.make(String.prototype, {
  toString: function _toString() {
    return this.partLast + ', ' + this.partFirst;
  },
  constructor: function (first, last) {
    this.partFirst = first;
    this.partLast = last;
  },
  beget: pd.Base.beget 
});

console.log(Name.beget("jimmy", "dean").toString())
console.log(Name.isPrototypeOf(Name.beget()));
console.log(String.prototype.isPrototypeOf(Name.beget()));
console.log(Object.prototype.isPrototypeOf(Name.beget()));
console.log(Name.toString.call(Name.beget('jimmy', 'dean')));
console.log(Name.toString.call({
    partFirst: 'jimmy',
    partLast: 'dean'
}));

当然输出如预期Live Example