在我最熟悉的 C++ 语言中，通常会像这样声明一个对象:

class foo
{
public:
    int bar;
    int getBar() { return bar; }
}

调用 getBar() 工作正常(忽略 bar 可能未初始化的事实)。 getBar()中的变量bar在类foo的范围内，所以不用说this-> bar 除非我真的需要明确指出我指的是类的 bar 而不是参数。

现在，我正在尝试开始使用 Javascript 中的 OOP。因此，我查看了如何定义类并尝试了同样的事情:

function foo()
{
     this.bar = 0;
     this.getBar = function() { return bar; }
}

它给了我 bar is undefined。将 bar 更改为 this.bar 解决了这个问题，但是对每个变量都这样做会使我的代码变得相当困惑。这对每个变量都是必要的吗？由于我找不到与此相关的任何问题，这让我觉得我做的事情从根本上是错误的。

编辑:是的，所以，从评论中我得到的是 this.bar，一个对象的属性，引用了不同于 bar 的东西，一个局部变量。有人能说出为什么会这样吗，就范围和对象而言，以及是否有另一种方法来定义一个不需要这样做的对象？

最佳答案

JavaScript 没有基于classes 类的对象模型。它使用更强大的原型(prototype)继承，它可以模仿类，但不太适合它。万物皆对象，对象[可以]继承自其他对象。

构造函数只是一个将属性分配给新创建的对象的函数。可以通过 new keyword 引用对象(通过调用 this keyword 创建) (这是函数的局部)。

方法也只是一个函数，在 一个对象上调用 - 再次使用 this 指向该对象。至少当该函数作为对象的属性被调用时，使用 member operator (点，括号)。这会给新手带来很多困惑，因为如果您传递该函数(例如，传递给事件监听器)，它就会与访问它的对象“分离”。

现在遗产在哪里？ “类”的实例继承自相同的原型(prototype)对象。方法被定义为该对象的函数属性(而不是每个实例一个函数)，您调用它们的实例仅继承该属性。

例子:

function Foo() {
    this.bar = "foo"; // creating a property on the instance
}
Foo.prototype.foo = 0; // of course you also can define other values to inherit
Foo.prototype.getBar = function() {
    // quite useless
    return this.bar;
}

var foo = new Foo; // creates an object which inherits from Foo.prototype,
                   // applies the Foo constructor on it and assigns it to the var
foo.getBar(); // "foo" - the inherited function is applied on the object and
              // returns its "bar" property
foo.bar; // "foo" - we could have done this easier.
foo[foo.bar]; // 0 - access the "foo" property, which is inherited
foo.foo = 1;  // and now overwrite it by creating an own property of foo
foo[foo.getBar()]; // 1 - gets the overwritten property value. Notice that
(new Foo).foo;     // is still 0

因此，我们只使用了该对象的属性并且对此感到满意。但它们都是“公开的”，可以覆盖/更改/删除!如果这对你来说不重要，那么你很幸运。您可以通过在属性名称前加上下划线来指示属性的“隐私性”，但这只是对其他开发人员的提示，可能不会被遵守(尤其是在错误时)。

因此，聪明的头脑找到了一种解决方案，将构造函数用作闭包，允许创建私有(private)“属性”。 javascript 函数的每次执行都会为局部变量创建一个新的变量环境，一旦执行完成，这些变量可能会被垃圾回收。在该范围内声明的每个函数也可以访问这些变量，并且只要可以调用这些函数(例如，通过事件监听器)，环境就必须持续存在。因此，通过从构造函数中导出本地定义的函数，您可以使用只能由这些函数访问的局部变量来保留变量环境。

让我们看看它的实际效果:

function Foo() {
    var bar = "foo"; // a local variable
    this.getBar = function getter() {
        return bar; // accesses the local variable
    }; // the assignment to a property makes it available to outside
}

var foo = new Foo; // an object with one method, inheriting from a [currently] empty prototype
foo.getBar(); // "foo" - receives us the value of the "bar" variable in the constructor

这个在构造函数中定义的 getter 函数现在称为“特权 方法”，因为它可以访问“私有(private)”(本地)“属性”(变量)。 bar 的值永远不会改变。当然，你也可以为它声明一个 setter 函数，然后你可以添加一些验证等。

请注意，原型(prototype)对象上的方法无法访问构造函数的局部变量，但它们可能会使用特权方法。让我们添加一个:

Foo.prototype.getFooBar = function() {
    return this.getBar() + "bar"; // access the "getBar" function on "this" instance
}
// the inheritance is dynamic, so we can use it on our existing foo object
foo.getFooBar(); // "foobar" - concatenated the "bar" value with a custom suffix

因此，您可以结合使用这两种方法。请注意，特权方法需要更多内存，因为您创建具有不同作用域链(但代码相同)的不同函数对象。如果您要创建大量的实例，您应该只在原型(prototype)上定义方法。

当您设置从一个“类”到另一个“类”的继承时，它会变得更加复杂 - 基本上您必须使子原型(prototype)对象继承自父对象，并将父构造函数应用于子实例以创建“私有(private)属性”。看看Correct javascript inheritance , Private variables in inherited prototypes , Define Private field Members and Inheritance in JAVASCRIPT module pattern和 How to implement inheritance in JS Revealing prototype pattern?

关于Javascript:我需要为对象中的每个变量放置 this.var 吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13418669/