¿Hay algún peligro asociado con el uso de espacios de nombres de JavaScript?

¿Hay algún peligro / advertencia que se debe tener en count al crear espacios de nombres JavaScript?

Nuestro proyecto es bastante amplio y estamos ejecutando muchos files JavaScript (más de 20, esperando más). Es imposible tener ningún mantenimiento del código sin usar espacios de nombres, así que los estamos implementando de la siguiente manera:

var namespace1 = { doSomething: function() { ... }, doSomethingElse: function() { ... } } 

Y luego para crear jerarquías, las vinculamos así:

 var globalNamespace = { functions1: namespace1, functions2: namespace2, ... } 

Esto funciona bien, pero es esencialmente un "truco" para hacer que JS se comporte como si tuviera espacios de nombres. Aunque este método se usa mucho, la mayoría de la literatura sobre esto parece enfocarse en cómo hacerlo, y no si existen posibles inconvenientes. A medida que escribimos más código JS, esto se está convirtiendo rápidamente en una parte integral de la forma en que funciona nuestro sistema. Entonces, es importante que funcione a la perfección.

¿Hubo alguna situación en la que este sistema de espacio de nombres "inducido" causó errores o necesitó atención especial? ¿Podemos esperar comportamientos idénticos en todos los browseres?

La forma en que define espacios de nombres en su ejemplo parece crear globales de cada espacio de nombres para que termine con

 window.namespace1 window.namespace2 window.globalNamespace window.globalNamespace.namespace1 window.globalNamespace.namespace2 

Entonces, si tienes algo que clobbers window.namespace1 , también window.globalNamespace.namespace1

editar:

Así es como solucionamos este problema:

 namespacing = { init: function(namespace) { var spaces = []; namespace.split('.').each(function(space) { var curSpace = window, i; spaces.push(space); for (i = 0; i < spaces.length; i++) { if (typeof curSpace[spaces[i]] === 'undefined') { curSpace[spaces[i]] = {}; } curSpace = curSpace[spaces[i]]; } }); } }; 

Entonces lo usa así:

 namespacing.init('globalNamespace.namespace1'); globalNamespace.namespace1.doSomething = function() { ... }; 

De esta manera, no tiene que introducir nuevas variables globales y puede agregar con confianza a un espacio de nombres existente sin destruir otros objects en él.

Como básicamente está agregando funciones a objects y esos objects a otros objects, esperaría que cada browser maneje esto de la misma manera.

Pero si quieres modularidad, ¿por qué no utilizar un marco (relativamente) simple como require.js ? Eso le permitirá a usted y a su equipo escribir código de manera modular y le permite al equipo 'importar' estos modules donde sea necesario:

 require(["helper/util"], function() { //This function is called when scripts/helper/util.js is loaded. }); 

Require.js se ocupará de las dependencies y también evitará la contaminación del espacio de nombres global.

Usamos un sistema similar en el trabajo y hace bien el trabajo. No veo ningún inconveniente que pueda haber; solo son objects y properties. Por esa misma razón, la compatibilidad con browseres cruzados debería ser buena. Puede terminar teniendo que escribir algunos nombres largos para resolver una function en particular, como Foo.Bar.Test.Namespace2.Function , pero incluso eso puede resolverse asignándolo a una variable de Foo.Bar.Test.Namespace2.Function .

Así es como recomendaría hacerlo, por lo que te mantienes fuera del scope global, excepto en el espacio de nombres "base". Hacemos algo similar donde trabajo Digamos que trabajas para Acme co, y quieres que ACME sea tu espacio de nombre base.

En la parte superior de cada file, includeías:

 if (!window.ACME) { window.ACME = {} } 

Entonces simplemente ve y define lo que quieras en términos de eso.

 ACME.Foo = { bar: function () { console.log("baz"); } } 

Si desea un nivel más profundo de espacio de nombres, simplemente haga lo mismo para cada nivel.

 if (!window.ACME) { window.ACME = {} } if (!ACME.Foo) { ACME.Foo = {} } 

De esta forma, cada file se puede probar de forma independiente y configurarán la infraestructura del espacio de nombres automáticamente, pero cuando los compile juntos o si testing varios files simultáneamente, no sobrescribirán los elementos que ya están definidos.