scripts - variable public javascript

¿Qué sucede con las variables "var" dentro de un Constructor de JavaScript?

Question

ejemplo:

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

foo = new Foo();

pregunta original:

Sé que bla se asignará a cada instancia de Foo. ¿Qué pasará con Blabla?

nueva pregunta:

lo que entiendo ahora:

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

En su ejemplo, blabla es una variable local, por lo que desaparecerá cuando finalice la función constructora.

Si declara una función dentro del constructor, que usa la variable, entonces la variable formará parte del cierre de esa función y sobrevive tanto como la función (es decir, normalmente siempre que el objeto):

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

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

Answer 2

Esa variable es local para el constructor y no será accesible fuera de ese alcance (ya sea a través de this u otro), a menos que sea capturada por un cierre.

Answer 3

Las variables declaradas con var dentro de una función utilizada como constructor serán, como todas las demás variables declaradas con var dentro de cualquier función, visibles solo durante la ejecución de esa función (a menos que el valor se cierre usando cierres).

En otras palabras, blabla es efectivamente invisible fuera de la función:

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

Al definir las funciones que se cierran sobre estas variables, se convierten en lo más parecido que JavaScript tiene a las variables "privadas":

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 4

Se convertirá en una variable local (piense en ''privada'') dentro de Foo() . Lo que significa que no puedes acceder a él fuera de 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
}

Podrías exponerlo (devolviéndolo) con un método Foo.

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

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

Ahora fuera de Foo ():

var FooBar = new Foo();

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

demostración jsFiddle

Answer 5

Si no utiliza la palabra clave var, "blabla" se convierte en una variable global. En otros puntos del código, si también usas blabla sin var, también será global, y puedes cambiar accidentalmente otras instancias de blabla e introducir errores involuntarios en tu código. "var" coloca la variable en el ámbito actual, por lo que en el caso anterior, solo es accesible para Foo.

Answer 6

blabla casi puede considerarse un miembro privado de Foo .

Vea este artículo de Douglas Crockford.

Answer 7

Cualquier método interno que le dé a this , es decir: this.method = function () {}; mientras que dentro de su función de constructor de Foo, todos van a tener una referencia al blahblah que es único para cada instancia de un objeto 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

Pero está completamente protegido del acceso fuera de la billetera, a menos que se lo devuelva a alguien, desde una función privilegiada.

wallet.balance; // undefined;

(Un poco más de interés: si el balance es una string , un number o un boolean , incluso si lo devuelve, eso no le dará a la gente derechos de edición, o incluso acceso de visualización permanente), las variables escalares se pasan por valor, por lo solo está pasando el valor del saldo en ese momento ; si, por el contrario, el saldo fuera un object , una function o una array , tendrían acceso permanente para modificar el funcionamiento interno)

Nota: los métodos TIENEN que asignarse dentro del constructor para que esto funcione. Los prototipos no pueden acceder a las variables internas. Agregar métodos más tarde no les dará acceso a las variables internas.

Esto significa que cada instancia ocupará un poco más de memoria, ya que cada una tiene su propia copia de los métodos y tiene su propia copia de los vars. Pero si lo que estás haciendo requiere datos privados, esta sería una buena forma de obtenerlo.