Frage Was passiert mit "var" -Variablen in einem JavaScript-Konstruktor?


Beispiel:

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

foo = new Foo();

ursprüngliche Frage:

Ich weiß, dass bla jeder Instanz von Foo zugewiesen wird. Was wird mit Blabla passieren?

neue Frage:

was ich jetzt verstehe:

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?

10
2017-08-14 15:19


Ursprung


Antworten:


Irgendwelche internen Methoden, die Sie geben this - dh: this.method = function () {};  während drinnen deiner Foo-Konstruktorfunktion sind alle werde einen Bezug auf die haben blahblah das ist einzigartig für jede Instanz von a Foo Objekt.

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

Aber es ist vollständig vor dem Zugriff außerhalb des Portemonnaies geschützt, es sei denn, Sie geben es an jemanden aus einer privilegierten Funktion zurück.

wallet.balance; // undefined;

(hinzugefügt ein bisschen von Interesse - wenn balance ist ein string, ein number, oder ein booleanAuch wenn Sie es zurückgeben, erhalten Sie keine Bearbeitungsrechte oder sogar dauerhaften Zugriff auf die Anzeige. Skalare Variablen werden nach Wert übergeben, so dass Sie nur den Wert des Guthabens übergeben damals - wenn jedoch das Gleichgewicht ein war object, ein function oder array, sie hätten permanenten Zugang, um den Mist aus deinen internen Arbeiten zu verändern)

Hinweis: Methoden HABEN innerhalb des Konstruktors zugewiesen werden, damit dies funktioniert. Prototypen können nicht auf interne Variablen zugreifen. Wenn Methoden später hinzugefügt werden, erhalten sie keinen Zugriff auf interne Variablen.

Das bedeutet, dass jede Instanz etwas mehr Speicher beansprucht, da jede eine eigene Kopie der Methoden besitzt und eine eigene Kopie der Variablen besitzt. Aber wenn das, was Sie tun, private Daten erfordert, wäre dies ein guter Weg, um es zu bekommen.


8
2017-08-14 15:30



In Ihrem Beispiel blabla ist eine lokale Variable, also wird sie verschwinden, wenn die Konstruktorfunktion endet.

Wenn Sie innerhalb des Konstruktors, der die Variable verwendet, eine Funktion deklarieren, ist die Variable Teil des Abschlusses für diese Funktion und überlebt so lange wie die Funktion (d. H. Normalerweise so lange wie das Objekt):

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

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

5
2017-08-14 15:29



Es wird ein lokal (denke an 'private') Variable innerhalb Foo(). Das bedeutet, dass Sie nicht darauf zugreifen können 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
}

Sie könnten es (indem Sie es zurückgeben) mit einer Foo-Methode aussetzen.

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

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

Jetzt außerhalb von Foo ():

var FooBar = new Foo();

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

jsFiddle Demonstration


2
2017-08-14 15:20



Diese Variable ist lokal für den Konstruktor und wird außerhalb dieses Bereichs nicht zugänglich sein (sei es durch this oder auf andere Weise), es sei denn, es wird durch eine Schließung erfasst.


1
2017-08-14 15:21



Variablen deklariert mit var Innerhalb einer Funktion, die als Konstruktor verwendet wird, wird, wie alle anderen Variablen, mit deklariert var innerhalb einer Funktion nur während der Ausführung dieser Funktion sichtbar sein (es sei denn, der Wert wird über Closures geschlossen).

Mit anderen Worten, blabla ist außerhalb der Funktion praktisch unsichtbar:

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

Durch das Definieren von Funktionen, die sich über diese Variablen schließen, werden sie zum nächsten Punkt, den JavaScript für "private" Variablen hat:

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!

1
2017-08-14 15:21



Wenn Sie das Schlüsselwort var nicht verwenden, wird "blabla" zu einer globalen Variablen. An anderen Stellen im Code, wenn Sie auch blabla ohne var verwenden, wird es auch global sein, und Sie können versehentlich andere Instanzen von blabla ändern und unbeabsichtigte Fehler in Ihrem Code einfügen. "var" setzt die Variable in den aktuellen Bereich, im obigen Fall ist sie nur für Foo zugänglich.


0
2017-08-14 15:21



blablakann fast als ein privates Mitglied von angesehen werden Foo.

Sehen Dies Artikel von Douglas Crockford.


-2
2017-08-14 15:21