JavaScript构造函数中的“var”变量会发生什么？

Question

例如：

function Foo() { 
    this.bla = 1; 
    var blabla = 10; 
    blablabla = 100; 
    this.getBlabla = function() { 
     return blabla; // exposes blabla outside 
    } 
} 

foo = new Foo(); 

原题：

我知道，喇嘛将被分配到富的每一个实例。 blabla会发生什么？

新的问题：

我现在明白了：

this.bla = 1;  // will become an attribute of every instance of FOO. 
var blabla = 10; // will become a local variable of Foo(**not** an attribute of every instance of FOO), which could be accessed by any instance of FOO only if there's a method like "this.getBlabla". 
blablabla = 100; // will define a **new** (or change if exist) global(window) variable. 

        Did i understand correctly? 

Answer 1

任何内部的方法，你给this - 即：this.method = function() {};而里面你的Foo构造函数，是所有将不得不在参考对于Foo对象的每个实例都是唯一的。

function Wallet() { 
    var balance = 0; 
    this.checkBalance = function() { return balance; }; 
    this.depositAmount = function (amount) { balance += amount; }; 
} 


var wallet = new Wallet(); 
wallet.checkBalance(); // 0 
wallet.depositAmount(3); 
wallet.checkBalance(); // 3 

但是它完全免受外部钱包访问的影响，除非您从特权功能返回给某人。

wallet.balance; // undefined; 

（兴趣增加位 - 如果balance是string，一个number或boolean，即使你回吧，不会给人们编辑权限，甚至永久性观看访问 - 标变量是按值传递的，所以您只是在时间处传递余额的值 - 但如果余额是object，function或array，则他们可以永久访问以修改废话您的内部工作）

注意：方法HAVE被分配给构造函数内部使其工作。 原型不能访问内部变量。 稍后添加方法不会让他们访问内部变量。

这意味着每个实例都会占用更多内存，因为每个实例都有自己的方法副本，并拥有自己的变量副本。 但是，如果你在做什么需要私人数据，这将是一个很好的方式来获得它。

Answer 2

它将成为当地内Foo()（认为 '私有'）变量。这意味着您无法在Foo()之外访问它。

function Foo() { 
    this.bla = 1; // this becomes an extension of Foo() 
    var blabla = 10; // this becomes a "Local" (sort of like a 'private') variable 
} 

您可以用Foo方法暴露它（通过返回它）。

function Foo() { 
    var blabla = 10; // local 

    this.getBlabla = function() { 
     return blabla; // exposes blabla outside 
    } 
} 

现在美孚（）以外：

var FooBar = new Foo(); 

var what_is_blabla = FooBar.getBlabla(); //what_is_blabla will be 10 

jsFiddle demonstration

Answer 3

该变量为局部的构造，也不会是范围以外访问（无论是通过this或以其他方式），除非它被封闭捕获。

Answer 4

在用作构造函数的函数内声明的变量将与任何函数内用var声明的所有其他变量一样，仅在执行该函数期间才可见（除非该值是使用闭包关闭的）。

换句话说，blabla是功能外有效无形：

var foo = new Foo(); 
console.log(foo.bla);  // 1 
console.log(foo.blabla); // throws NameError 

通过定义关闭了这些变量函数，它们成为最接近的JavaScript具有“私有”变量：

function Foo() { 
    this.bla = 1; 
    var private = 1; 

    this.increment = function() { 
     ++private; 
    } 

    this.getPrivateValue = function() { 
     return private; 
    } 
} 

foo = new Foo(); 
console.log(foo.bla);    // 1 
foo.bla = 6;       // legal 
console.log(foo.bla);    // 6 
console.log(foo.getPrivateValue()); // 1 
// console.log(foo.private);   // would throw an error 
foo.increment();      // legal 
console.log(foo.getPrivateValue()); // 2 
// foo.getPrivateValue() = 5;  // syntax error. Still can't reassign to private no matter what you try! 

Answer 5

blabla几乎可以被认为是Foo的私人成员。

查看this来自Douglas Crockford的文章。

Answer 6

如果您不使用var关键字，则“blabla”将成为全局变量。在代码中的其他地方，如果你也使用blabla without var，它也将是全局的，并且你可能会无意中更改blabla的其他实例并在你的代码中引入无意识的错误。 “var”将变量放在当前范围中，所以在上面的情况下，它只能由Foo访问。

Answer 7

在你的例子中blabla是一个局部变量，所以当构造函数结束时它将消失。

如果声明构造内部的功能，它使用了可变的，那么变量将是闭合该功能的一部分，和（即通常只要对象），只要生存作为功能：

function Foo() { 
    this.bla = 1; 
    var blabla = 10; 

    this.getBlabla = function() { 
    alert(blabla); // still here 
    } 
}