Archivo de la categoría ‘Patrones de diseño’

Singleton en JavaScript

Publicado por Iván Gajate el 4 de noviembre de 2012 en JavaScript, Patrones de diseño, Tutoriales | Los comentarios están cerrados.

Un Singleton es un tipo de objeto del que solo queremos tener una única instancia que sea accesible fácilmente desde cualquier parte.

Un ejemplo muy típico de este patrón de diseño es el modelo de datos. Todo el mundo tiene que tener acceso a él pero debemos asegurarnos de que solo existe una instancia.

var modelo = function(){
 
}();

Lo que hacemos es guardar en una variable nuestro objeto desde el principio, así nos aseguramos de tener un única instancia.
Son muy importantes los paréntesis del final de la definición de función. Lo que hacen es auto ejecutar la función (crear el objeto la primera vez que se lee este código). De esta manera nuestra variable crea y almacena el objeto.

Esto con un ejemplo real usando un namespace sería algo así:

YXQN.modelo = function(){
 
	var _api = {};
	var _contador;
 
	function init(){
		_contador = 0;
	}
 
	// Incrementa el marcador
	_api.incrementarContador = function(){
		_contador++;
	}
 
	// Devuelve el valor actual
	_api.getContador = function(){
		return _contador;
	}
 
	init();
 
	return _api;
}();

Como la instancia ya está creada, no necesitamos hacer un new, podemos acceder directamente a la variable modelo:

YXQN.modelo.getContador(); // 0
YXQN.modelo.incrementarContador();
YXQN.modelo.getContador(); // 1

Otro uso muy interesantes para el Singleton es un objeto que controle las cartelas de aviso de nuestra página, es bueno que todos los avisos estén centralizados y no se pisen entre si.

Nótese que escribo modelo en minúsculas, indicando que es una variable, porque realmente se crea desde un principio en memoria, desde que se carga el js. Es lo que se conoce como Eager initialization, o de inicialización impaciente, y aunque tiene la ventaja de estar creado desde un principio, tiene la desventaja de que si no se usa consume unos recursos que no utilizamos. Si el objeto es muy costoso de crear, puede que ralentice el inicio del programa. Veremos mas adelante como crear un Singleton Lazy Initialization, o de inicialización perezosa (siempre me ha hecho mucha gracia este nombre ;).

AS3 – Singleton

Publicado por Iván Gajate el 6 de junio de 2011 en AS3, Flash, Patrones de diseño | 13 comentarios »

Uno de los patrones de diseño que mas útiles en mi opinión es el Singleton. Si queremos almacenar datos relevantes para nuestro proyecto y que sean accesibles fácilmente desde cualquier sitio es la mejor opción. O para la típica cartela de avisos que solo puede estar abierta una vez y que tiene que llamarse desde muchos sitios.

Para construirlo a mi esta es la forma que mas me gusta:

package {

	public class Modelo {

		private static var _instance:Modelo;

		public function Modelo(singletonenforcer:SingletonEnforcer) {
			if (singletonenforcer == null) {
				throw new Error("Modelo es un Singleton. Para acceder a una instancia hacedlo mediante Modelo.getInstance()");
				return;
			}
		}

		public static function getInstance():Modelo {
			if (!_instance) {
				_instance = new Modelo(new SingletonEnforcer());
			}
			return _instance;
		}

	}
}

class SingletonEnforcer{}

De esta manera podemos acceder así:

Modelo.getInstance().guardarDatos();
Modelo.getInstance().recogerDatos();

Patrón Value Object

Publicado por Iván Gajate el 17 de mayo de 2009 en AS3, Flash, Patrones de diseño, Tutoriales | 18 comentarios »

Este mini patrón de diseño, consiste simplemente en agrupar varios valores dentro de un objeto para enviarlo y recibirlo con mayor comodidad/seguridad.

Yo casi más que un patrón lo considero una buena costumbre de programación, y es que cuando tengo que pasarle a una función mas de 4 ó 5 parámetros, los meto todos en un objeto y hago que esta función sólo espere ese objeto como único parámetro.

// Sin Value Object
public function guardarDatos(nombre:String, apellidos:String, edad:uint, hombre:Boolean):void{
	//
}

// Con Value Object
public function guardarDatos(datos:Object):void{
	//
}

Esto, aparte de hacer el código más legible, hace nuestro programa escalable, pues si en un futuro queremos añadir un nuevo parámetro a la función, no tengo que cambiar su firma (public function guardarDatos(datos:Object):void), sino que le añado una nueva propiedad al objeto y listo, mi función sigue esperando un sólo parámetro.

Leer el resto de esta entrada