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 
    } 
}