Entradas con la etiqueta ‘instancia’

JS – Métodos Estáticos en JavaScript

Publicado por Iván Gajate el 26 de octubre de 2014 en JavaScript | Los comentarios están cerrados.

A veces podemos necesitar que una clase que instanciemos muchas veces guarde alguna variable o método a nivel de clase, no a nivel de instancia (variables estáticas).
Podemos usar las clausuras para ello:

http://jsfiddle.net/yporqueno/h1n2gk2d/

var Persona = function (){
    // Variable de clase (estatica)
    var count = 0;
 
    // Constructor de la clase Persona
    var fn = function(){
        var _api = {};
        _api.saluda = function(){
            alert('Hola #'+count);
        };
        count++;
        return _api;
    };
 
    // Metodo estatico de Persona
    fn.getCount = function(){
        alert('Numero de personas '+count);
    }
 
    return fn;
}();

De esta manera la variable «count» solo se crea una vez, y queda accesible para cada instancia que creemos de la clase Persona.
Ahora podemos crear tantas instancias como queramos de Persona y acceder al conteo que lleva la clase de forma centralizada.

var manolo = new Persona();
manolo.saluda();
 
var pepe = new Persona();
pepe.saluda();
 
// Metodo estatico de la clase Persona
Persona.getCount();

Gracias Javi por la idea!! 🙂

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 ;).