Evitando lo global en JavaScript

Las variables globales y funciones en el ambito global no son una muy buena idea. La razón es que cada script se ejecuta en el mismo ambito y si hay varios programadores no es difícil coincidir en variables o funciones con el mismo nombre y que quedaran sobrescritas.

Existen varias soluciones. Voy a ir una a una comentandolas.  Digamos que tienes tres funciones y una variable tal que asi:

var actual = null;
function iniciar(){...}
function cambiar(){...}
function verificar(){...}

Se pueden proteger utilizando un objeto javascript:

var nombreUnico = {
  actual: null,
  iniciar: function(){...},
  cambiar: function(){...},
  verificar: function(){...}
}

 Para llamar a las funciones o cambiar el valor de la variable tendremos que hacerlo con el prefijo nombreUnico., así para ejecutar la función iniciar seria nombreUnico.iniciar().

El siguiente paso es envolver todo en una función anónima. A esto se le conoce como el module pattern.

var nombreUnico = function(){
  var actual = null;
  function iniciar(){...}
  function cambiar(){...}
  function verificar(){...}
}();

Pero de esta manera hay un problema. Nada es accesible desde fuera. Si quieres hacerlo público necesitas envolver lo que quieras hacer publico en una sentencia de return.

var nombre = function(){
  var actual = null;
  function verificar(){...}
  return { 
    iniciar: function(){...}
    cambiar: function(){...}
  }
}();

De esta manera desde fuera solo tenemos accesibles las funciones de iniciar() y cambiar().

Así que el siguiente paso es:

nombre = function(){
  var actual = null;
  function iniciar(){...}
  function cambiar(){...}
  function verificar(){...}
  return {
    iniciar: iniciar,
    cambiar: cambiar
  }
}();

En vez de devolver directamente las funciones, lo que se devuelve son punteros a esas funciones. El nombre de la función no hace falta que coincida con el del puntero.

Si no necesitas que ninguna variable o función sea accesible desde fuera, puedes envolver toda la construcción en otro set de parentesis para ejecutarla sin necesidad de ningún nombre.

(function(){
  var actual = null;
  function iniciar(){...}
  function cambiar(){...}
  function verificar(){...}
})();

Esto mantiene todo en una especie de paquete que es inaccesible desde el fuera.

Evitando lo global en JavaScript

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google photo

Estás comentando usando tu cuenta de Google. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

Conectando a %s