Question

问候，

阅读以下文章后，我有一个问题： https://developer.mozilla.org/en/Introduction_to_Object-Oriented_JavaScript

在继承示例中，Person构造函数不接受任何参数。如果我要添加一个并从Student构造函数中调用它，那么同样的例子怎么样？

谢谢！

Answer 1

嗯，您可以使用Person或call重新调用function Person(gender) { this.gender = gender; } function Student(gender) { Person.apply(this, arguments); } Student.prototype = new Person(); // make Student inherit from a Person object Student.prototype.constructor = Student; // fix constructor property var foo = new Student('male'); foo.gender; // "male" foo instanceof Student; // true foo instanceof Person; // true构造函数的逻辑，例如：

Person

如果你想在没有参数的情况下阻止执行Student.prototype = new Person();构造函数（比如行function Person(gender) { if (arguments.length == 0) return; // don't do anything this.gender = gender; }），你可以检测到它，例如：

{{1}}

Answer 2

接受的答案似乎不正确。基于Mozilla says about OO JavaScript，正确的方法是：

var Person = function(firstName) {
    this.firstName = firstName;
};

function Student(firstName, subject) {
  // Call the parent constructor, making sure (using Function#call)
  // that "this" is set correctly during the call
  Person.call(this, firstName);

  // Initialize our Student-specific properties
  this.subject = subject;
};

// Create a Student.prototype object that inherits from Person.prototype.
// Note: A common error here is to use "new Person()" to create the
// Student.prototype. That's incorrect for several reasons, not least 
// that we don't have anything to give Person for the "firstName" 
// argument. The correct place to call Person is above, where we call 
// it from Student.
Student.prototype = Object.create(Person.prototype); // See note below

// Set the "constructor" property to refer to Student
Student.prototype.constructor = Student;

// Example usage:
var student1 = new Student("Janet", "Applied Physics");

正如您可以清楚地看到的，Mozilla指定使用“new Person（）”创建Student.prototype是一个常见错误。因此，接受的答案具有误导性。

我已经在我正在进行的项目中对此进行了测试，并且Mozilla的方式是正确的，而上述答案不起作用。

Answer 3

// define the Person Class
function Person(name) {
    this.personname = name;
}

Person.prototype.walk = function(){};
Person.prototype.sayHello = function(){
  alert (this.personname );
};

https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/constructor

完整代码：

<script>
// define the Person Class
function Person(name) {
    this.personname = name;
}

Person.prototype.walk = function(){};
Person.prototype.sayHello = function(){
  alert (this.personname );
};

// define the Student class
function Student() {}

// inherit Person
Student.prototype = new Person("test");

// correct the constructor pointer because it points to Person
Student.prototype.constructor = Student;

// replace the sayHello method
Student.prototype.sayHello = function(){
  alert('hi, I am a student and my name is \'' + this.personname + '\'' );
}

// add sayGoodBye method
Student.prototype.sayGoodBye = function(){
  alert('goodBye');
}

var student1 = new Student();
student1.sayHello();
student1.sayGoodBye();
</script>

Answer 4

通过所有其他评论，我创建了一个适合我的例子。由于我没有明确使用原型，我希望我不会错过重要的一点。

// variable for tracking instantiations and checking the uniqueness of the objects
var instances = 0;

var Generic = function() {
    this.instanceId = ++instances;
    this.toString = function() {return 'Generic [iid='+ this.instanceId +']'};
    console.log('constructor-invoke: Generic ('+ this.instanceId +')');
};

var SpecificName = function(inName) {
    Generic.call(this);
    this.getName = function() { return inName; };       
    var superToString = this.toString.bind(this); // binds the inner function 'this' to this SpecificName instance
    this.toString = function() {
        return 'SpecificName [iid='+ this.instanceId +', name='+ this.getName() +', super.toString='+ superToString() +']'
    }
    console.log('constructor-invoke: SpecificName ('+ this.instanceId +')');
};

var SpecificNames = function(inFirstName, inLastName) {
    SpecificName.call(this, inLastName +', '+ inFirstName );
    var superToString = this.toString.bind(this);
    this.toString = function() {
        return 'SpecificNames [iid='+ this.instanceId +', name='+ this.getName() +', super.toString='+ superToString() +']'
    }
    console.log('constructor-invoke: SpecificNames ('+ this.instanceId +')');
};

var g = new Generic(); 
var sn = new SpecificName('Run Forest Run');
var sns = new SpecificNames('Forest','Gump');

console.log('g:   '+ g.toString());
console.log('sn:  '+ sn.toString());
console.log('sns: '+ sns.toString());

导致此输出：

constructor-invoke: Generic (1)
constructor-invoke: Generic (2)
constructor-invoke: SpecificName (2)
constructor-invoke: Generic (3)
constructor-invoke: SpecificName (3)
constructor-invoke: SpecificNames (3)
g:   Generic [iid=1]
sn:  SpecificName [iid=2, name=Run Forest Run, super.toString=Generic [iid=2]]
sns: SpecificNames [iid=3, name=Gump, Forest, super.toString=SpecificName [iid=3, name=Gump, Forest, super.toString=Generic [iid=3]]]

如何使用参数调用继承的JavaScript构造函数？

4 个答案: