试图通过.prototype属性理解/学习/使用javascript中的继承

我试图理解javascript继承/原型

我这样做：

函数Foo（par）{
这是PROP= PAR；
这是PROF2= PAR；
}
功能条（par）{
这个p=par；
}
Bar.prototype=new Foo（）；

如果我这样做：

var myBar=新条（“值”）；

---

myBar.propTwo

未定义（我假设这是因为即使覆盖原型，我也显式使用

Bar

的“构造函数”您需要在Bar的“上下文”（或范围）中调用Foo函数。其效果类似于将Foo作为父构造函数调用

function Foo(par){
        this.prop= par;
        this.propTwo = par;
    }
function Bar(par){
        this.p=par;
        Foo.apply(this,arguments);
    }
Bar.prototype = new Foo();

var myBar = new Bar("value");

console.log(myBar);

---

您需要在Bar的“context”（或scope）中调用Foo函数。其效果类似于将Foo作为父构造函数调用

function Foo(par){
        this.prop= par;
        this.propTwo = par;
    }
function Bar(par){
        this.p=par;
        Foo.apply(this,arguments);
    }
Bar.prototype = new Foo();

var myBar = new Bar("value");

console.log(myBar);

---

您需要在Bar的“context”（或scope）中调用Foo函数。其效果类似于将Foo作为父构造函数调用

function Foo(par){
        this.prop= par;
        this.propTwo = par;
    }
function Bar(par){
        this.p=par;
        Foo.apply(this,arguments);
    }
Bar.prototype = new Foo();

var myBar = new Bar("value");

console.log(myBar);

---

您需要在Bar的“context”（或scope）中调用Foo函数。其效果类似于将Foo作为父构造函数调用

function Foo(par){
        this.prop= par;
        this.propTwo = par;
    }
function Bar(par){
        this.p=par;
        Foo.apply(this,arguments);
    }
Bar.prototype = new Foo();

var myBar = new Bar("value");

console.log(myBar);

---

如果我正确理解了您的问题，您会想，当您声明

Bar

为

Foo

的子类时，为什么

prop

和

propTwo

没有在

myBar

中设置

答案是构造函数不会自动调用其原型的构造函数。我认为您可能想要的是：

// parent class
function Foo(par){
    this.prop = par;
    this.propTwo = par;
}

// subclass
function Bar(par){
    Foo.call(this, par);  // invoke parent class constructor
    this.p = par;         // custom construction
}
Bar.prototype = new Foo()

正如Bergi在下面的评论中指出的那样，通过将子类的原型设置为父类的新实例来进行子类化可能是您想要的：这使得所有子类型实例都从父类的实例继承，而不是从父类的原型继承。如果您希望模拟经典继承，最好的选择是使用

对象。创建
方法：

Bar.prototype = Object.create(Foo.prototype);
Bar.prototype.constructor = Bar;

有关更多信息，请参阅。您可能还想阅读和。
如果我正确理解您的问题，您会想知道，当您声明
Bar
为
Foo
的子类时，为什么
prop
和
propTwo
没有在
myBar
中设置

答案是构造函数不会自动调用其原型的构造函数。我认为您可能想要的是：

// parent class
function Foo(par){
    this.prop = par;
    this.propTwo = par;
}

// subclass
function Bar(par){
    Foo.call(this, par);  // invoke parent class constructor
    this.p = par;         // custom construction
}
Bar.prototype = new Foo()

正如Bergi在下面的评论中指出的那样，通过将子类的原型设置为父类的新实例来进行子类化可能是您想要的：这使得所有子类型实例都从父类的实例继承，而不是从父类的原型继承。如果您希望模拟经典继承，最好的选择是使用
对象。创建
方法：

Bar.prototype = Object.create(Foo.prototype);
Bar.prototype.constructor = Bar;

有关更多信息，请参阅。您可能还想阅读和。
如果我正确理解您的问题，您会想知道，当您声明
Bar
为
Foo
的子类时，为什么
prop
和
propTwo
没有在
myBar
中设置

答案是构造函数不会自动调用其原型的构造函数。我认为您可能想要的是：

// parent class
function Foo(par){
    this.prop = par;
    this.propTwo = par;
}

// subclass
function Bar(par){
    Foo.call(this, par);  // invoke parent class constructor
    this.p = par;         // custom construction
}
Bar.prototype = new Foo()

正如Bergi在下面的评论中指出的那样，通过将子类的原型设置为父类的新实例来进行子类化可能是您想要的：这使得所有子类型实例都从父类的实例继承，而不是从父类的原型继承。如果您希望模拟经典继承，最好的选择是使用
对象。创建
方法：

Bar.prototype = Object.create(Foo.prototype);
Bar.prototype.constructor = Bar;

有关更多信息，请参阅。您可能还想阅读和。
如果我正确理解您的问题，您会想知道，当您声明
Bar
为
Foo
的子类时，为什么
prop
和
propTwo
没有在
myBar
中设置

答案是构造函数不会自动调用其原型的构造函数。我认为您可能想要的是：

// parent class
function Foo(par){
    this.prop = par;
    this.propTwo = par;
}

// subclass
function Bar(par){
    Foo.call(this, par);  // invoke parent class constructor
    this.p = par;         // custom construction
}
Bar.prototype = new Foo()

正如Bergi在下面的评论中指出的那样，通过将子类的原型设置为父类的新实例来进行子类化可能是您想要的：这使得所有子类型实例都从父类的实例继承，而不是从父类的原型继承。如果您希望模拟经典继承，最好的选择是使用
对象。创建
方法：

Bar.prototype = Object.create(Foo.prototype);
Bar.prototype.constructor = Bar;

<> p>参见更多信息。您也可能想读取该代码的可能的副本，因为它将在BAR的构造函数中产生一个引用错误：<代码> PROP>代码>未定义。这是一个键入吗？应该是<代码>这个.p= PAR；< /Cord>？并且您正在执行<代码>（）。
没有参数..因此
this.prop
和
this.propTwo
将只是未定义…键入“this.p=par”，谢谢，还有“Foo（）”这对于将导致两个字段都未定义的FooObject来说是正确的，但从我了解到，不必发送参数来替换/重写原型，实际上我不知道会产生什么影响。不幸的是，您并不真的想在那里调用它。此代码的可能重复将在c中产生引用错误BAR的结构：<代码> PROP<代码>未定义。这是一个键入吗？这应该是<代码>。p= PAR；< /Cord>？并且您没有执行任何代码>代码（>代码）。没有代码。所以，代码< >代码> >代码>。这对于将导致两个字段都未定义的FooObject来说是正确的，但从我了解到，不必发送参数来替换/重写原型，实际上我不知道会产生什么影响。不幸的是，您并不真的想在那里调用它。此代码的可能重复将在c中产生引用错误BAR的结构：<代码> PROP<代码>未定义。这是一个键入吗？应该是<代码>这个.p= PAR；< /Cord>？并且您没有执行PARAM.<代码> > <代码> >