这是一个子类还是新实例？ 我知道JavaScript继承与典型的OO语言（java，C++等）有很大的不同。四处搜索，似乎也有许多不同的方法来创建类和类层次结构。正因为如此，我对JavaScript继承感到困惑

给定以下代码

if (!com) var com = {};
if (!com.foobar) com.foobar = {};

com.foobar.Foo = {
        foo : "foo",
        bar : "bar",
        baz : function () {
        return true;
        }
};

为什么不允许出现以下情况？为什么com.foobar.Foo不是构造函数？是不是因为Foo不是一个函数，而是一个对象

var baz = new com.foobar.Foo();

既然我不能做上述工作，我该如何创建一个新的Foo

如果我想扩展Foo，我想我会这样做：

var bar=Object.create（com.foobar.Foo，{buz:{value:“neat”}）

。。但是bar是Foo的子类型还是Foo的实例？我倾向于使用Foo实例，因为下面的打印“未定义”

console.log（bar.prototype）

---

您无法实例化Foo，因为它是一个对象，而不是一个函数。您可以通过创建函数并使用prototype设置实例方法来实现这一点：

// constructor method
com.foobar.Foo = function() {
    this.foo = 'foo'
    this.bar = 'bar'
}

com.foobar.Foo.prototype.baz = function() {
    return true
}

---

看看它在JSFIDLE上运行的情况：

您无法实例化Foo，因为它是一个对象，而不是一个函数。您可以通过创建函数并使用prototype设置实例方法来实现这一点：

// constructor method
com.foobar.Foo = function() {
    this.foo = 'foo'
    this.bar = 'bar'
}

com.foobar.Foo.prototype.baz = function() {
    return true
}

---

看看它在JSFIDLE上运行的情况：

您无法实例化Foo，因为它是一个对象，而不是一个函数。您可以通过创建函数并使用prototype设置实例方法来实现这一点：

// constructor method
com.foobar.Foo = function() {
    this.foo = 'foo'
    this.bar = 'bar'
}

com.foobar.Foo.prototype.baz = function() {
    return true
}

---

看看它在JSFIDLE上运行的情况：

您无法实例化Foo，因为它是一个对象，而不是一个函数。您可以通过创建函数并使用prototype设置实例方法来实现这一点：

// constructor method
com.foobar.Foo = function() {
    this.foo = 'foo'
    this.bar = 'bar'
}

com.foobar.Foo.prototype.baz = function() {
    return true
}

---

看看它在JSFIDLE上运行的情况：

您是正确的，您不能执行

var baz=new com.foobar.Foo（）Foo

是一个对象，而不是一个函数

Object.create

用于设置变量的原型（即

bar.prototype=Object.create（/*etc*/）

）。有关更多信息，请参阅MDN页面：

使用

Object.create

正确的结果是

bar

成为另一个具有

Foo的
prototype
的对象。这意味着
Foo
拥有的任何东西都可以在
bar
上使用，例如
bar.bar==='bar'
（如果有意义的话）。对
Foo
的更改将反映在
bar
中，但不是相反。它不完全是一个亚型。（JS很奇怪，但令人高兴的是。）

有关这方面的更多信息，请查看MDN:
您是正确的，您不能执行
var baz=new com.foobar.Foo（）Foo
是一个对象，而不是一个函数

Object.create
用于设置变量的原型（即
bar.prototype=Object.create（/*etc*/）
）。有关更多信息，请参阅MDN页面：

使用
Object.create
正确的结果是
bar
成为另一个具有
Foo的
prototype
的对象。这意味着
Foo
拥有的任何东西都可以在
bar
上使用，例如
bar.bar==='bar'
（如果有意义的话）。对
Foo
的更改将反映在
bar
中，但不是相反。它不完全是一个亚型。（JS很奇怪，但令人高兴的是。）

有关这方面的更多信息，请查看MDN:
您是正确的，您不能执行
var baz=new com.foobar.Foo（）Foo
是一个对象，而不是一个函数

Object.create
用于设置变量的原型（即
bar.prototype=Object.create（/*etc*/）
）。有关更多信息，请参阅MDN页面：

使用
Object.create
正确的结果是
bar
成为另一个具有
Foo的
prototype
的对象。这意味着
Foo
拥有的任何东西都可以在
bar
上使用，例如
bar.bar==='bar'
（如果有意义的话）。对
Foo
的更改将反映在
bar
中，但不是相反。它不完全是一个亚型。（JS很奇怪，但令人高兴的是。）

有关这方面的更多信息，请查看MDN:
您是正确的，您不能执行
var baz=new com.foobar.Foo（）Foo
是一个对象，而不是一个函数

Object.create
用于设置变量的原型（即
bar.prototype=Object.create（/*etc*/）
）。有关更多信息，请参阅MDN页面：

使用
Object.create
正确的结果是
bar
成为另一个具有
Foo的
prototype
的对象。这意味着
Foo
拥有的任何东西都可以在
bar
上使用，例如
bar.bar==='bar'
（如果有意义的话）。对
Foo
的更改将反映在
bar
中，但不是相反。它不完全是一个亚型。（JS很奇怪，但令人高兴的是。）

有关这方面的更多信息，请查看MDN:
Javascript没有类，只有对象。当您创建一个对象时，它也可以有一个原型，这是另一个对象，创建的对象将使用它来委托调用它自己不理解的属性（或函数）

这或多或少类似于经典继承，因为子类也委托调用它不理解的超类

因此，首先，您希望为您创建的其他对象制作
Foo
原型
Foo
的行为有点像对象的超类

您已经知道的一个方便的函数是
对象。create
。您可以使用它创建具有特定原型的新对象，如下所示：

var bar = Object.create(com.foobar.Foo, {buz: {value: "neat"}});

这意味着
bar
将具有
Foo
的原型，并且还将具有
buz
的自有属性（即不在原型中）

现在，
bar
的原型指向
Foo