javascript - para - ¿Qué significa que el espacio de nombres global estaría contaminado?

obtener contenido de un div javascript

Question

¿Qué significa que el espacio de nombres global estaría contaminado?

Realmente no entiendo lo que significa el espacio de nombres global contaminarse.

Answer 1

Cuando declaras variables globales, funciones, etc., ellos, ehm, van al espacio de nombres global. Además de los problemas de rendimiento / memoria (que pueden surgir), es probable que se encuentre con desafortunados conflictos de nombres, cuando redefina una variable importante o no use el valor que cree que usa.

Se debe evitar la definición de cosas en el espacio de nombres global.

Answer 2

En JavaScript, las declaraciones fuera de una función se encuentran en el ámbito global. Considera este pequeño ejemplo:

var x = 10;
function example() {
    console.log(x);
}
example(); //Will print 10

En el ejemplo anterior, x se declara en el alcance global. Cualquier ámbito hijo, como el creado por la función de example , hereda de manera efectiva lo declarado en cualquier ámbito primario (en este caso, es solo el alcance global).

Cualquier ámbito hijo que redeclare una variable declarada en el ámbito global sombreará la variable global, lo que podría causar errores no deseados y difíciles de rastrear:

var x = 10;
function example() {
    var x = 20;
    console.log(x); //Prints 20
}
example();
console.log(x); //Prints 10

Las variables globales generalmente no se recomiendan debido a la posibilidad de causar problemas como este. Si no usamos la instrucción var dentro de la función de example , habríamos sobrescrito accidentalmente el valor de x en el ámbito global:

var x = 10;
function example() {
    x = 20; //Oops, no var statement
    console.log(x); //Prints 20
}
example();
console.log(x); //Prints 20... oh dear

Si desea leer más y entenderlo correctamente, le sugiero que consulte la especificación ECMAScript . Puede que no sea la más emocionante de las lecturas, pero ayudará sin fin.

Answer 3

Nota rápida sobre la recolección de basura

A medida que las variables pierden alcance, serán elegibles para la recolección de basura. Si tienen un alcance global, entonces no serán elegibles para la recopilación hasta que el espacio de nombres global pierda alcance.

Aquí hay un ejemplo:

var arra = [];
for (var i = 0; i < 2003000; i++) {
 arra.push(i * i + i);
}

Agregar esto a su espacio de nombres global (al menos para mí) debería tener un uso de memoria de 10,000 kb (win7 firefox) que no será recolectado. Otros navegadores pueden manejar esto de manera diferente.

Considerando que tener ese mismo código en un ámbito que está fuera de alcance de esta manera:

(function(){
 var arra = [];
 for (var i = 0; i < 2003000; i++) {
  arra.push(i * i + i);
 }
})();

Permitirá que arra pierda alcance después de que se ejecute el cierre y sea elegible para la recolección de basura.

El espacio de nombre global es tu amigo

A pesar de los muchos reclamos en contra del uso del espacio de nombres global, es tu amigo. Y como un buen amigo, no debes abusar de tu relación.

Sé gentil

No abuse (generalmente denominado "contaminante") del espacio de nombres global. Y lo que quiero decir con no abusar del espacio de nombres global es - no crear múltiples variables globales. Aquí hay un mal ejemplo de usar el espacio de nombres global.

var x1 = 5;
var x2 = 20;
var y1 = 3
var y2 = 16;

var rise = y2 - y1;
var run = x2 - x1;

var slope = rise / run;

var risesquared = rise * rise;
var runsquared = run * run;

var distancesquared = risesquared + runsquared;

var distance = Math.sqrt(dinstancesquared);

Esto creará 11 variables globales que podrían sobrescribirse o malinterpretarse en alguna parte.

Sé ingenioso

Un enfoque más ingenioso, que no contamine el espacio de nombres global, sería envolver todo esto en el patrón del módulo y solo usar una variable global mientras se exponen múltiples variables.

Aquí hay un ejemplo: (Tenga en cuenta que esto es simple y que no se maneja ningún error)

//Calculate is the only exposed global variable
var Calculate = function () {
 //all defintions in this closure are local, and will not be exposed to the global namespace
 var Coordinates = [];//array for coordinates
 var Coordinate = function (xcoord, ycoord) {//definition for type Coordinate
   this.x = xcoord;//assign values similar to a constructor
   this.y = ycoord;
  };

  return {//these methods will be exposed through the Calculate object
   AddCoordinate: function (x, y) {
   Coordinates.push(new Coordinate(x, y));//Add a new coordinate
  },

  Slope: function () {//Calculates slope and returns the value
   var c1 = Coordinates[0];
   var c2 = Coordinates[1];
   return c2.y - c1.y / c2.x - c1.x;//calculates rise over run and returns result
  },

  Distance: function () {
   //even with an excessive amount of variables declared, these are all still local
   var c1 = Coordinates[0];
   var c2 = Coordinates[1];

   var rise = c2.y - c1.y;
   var run = c2.x - c1.x;

   var risesquared = rise * rise;
   var runsquared = run * run;

   var distancesquared = risesquared + runsquared;

   var distance = Math.sqrt(distancesquared);

   return distance;
  }
 };
};

//this is a "self executing closure" and is used because these variables will be
//scoped to the function, and will not be available globally nor will they collide
//with any variable names in the global namespace
(function () {
 var calc = Calculate();
 calc.AddCoordinate(5, 20);
 calc.AddCoordinate(3, 16);
 console.log(calc.Slope());
 console.log(calc.Distance());
})();