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

Question

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

Realmente no entiendo qué significa el espacio de nombres global contaminarse.

Answer 1

nota rápida sobre la recogida de basura

Como variables pierden su alcance, que será elegible 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í se muestra un ejemplo:

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

Añadiendo esto a su espacio de nombres global (al menos para mí) deben ad 10.000 kb de uso de la memoria (Win7 Firefox) que no serán recogidos. Otros navegadores pueden manejar esto de manera diferente.

Mientras que tener el mismo código en un alcance que se sale del ámbito de esta manera:

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

Permitirá arra para perder alcance tras el cierre ejecuta y ser elegible para la recolección de basura.

espacio de nombres global es su amigo

A pesar de las muchas reclamaciones contra el uso del espacio de nombres global, es su amigo. Y como un buen amigo, no debes abusar de tu relación.

ser suave

No abuse (normalmente conocida como "contaminante"), el 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 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.

ser ingenioso

Un enfoque más recursos, que no contamina el espacio de nombres global, sería para envolver todo esto en el diseño del módulo y sólo utilizar una variable global, mientras que la exposición de múltiples variables.

Aquí se muestra un ejemplo: (Tenga en cuenta que esto es simple y no hay control de errores)

//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()); 
})(); 

Answer 2

Cuando declara 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 elementos en el espacio de nombres global.

Answer 3

En JavaScript, las declaraciones fuera de una función se encuentran en el ámbito global. Considere 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 ámbito global. Cualquier ámbito hijo, como el creado por la función example, hereda de manera efectiva las cosas declaradas en cualquier ámbito primario (en este caso, es solo el alcance global).

Cualquier ámbito secundario que redeclares una variable declarada en el ámbito global sombreará la variable global, causando potencialmente no deseados, difíciles de gestionar los fallos:

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

Las variables globales son por lo general no se recomienda debido a la posibilidad de causar problemas como este Si no usamos la declaración var dentro de la función example, habríamos sobrescritos 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 y entender más adecuadamente, sugiero pasar por el ECMAScript specification. Puede que no sea la más emocionante de las lecturas, pero ayudará sin fin.