comparte el articulo 

Uso de objetos anidados y namespaces en clases con MooTools

Actualizado el 07/11/2013 < > 0 Comentarios

Resumen: Para manejar namespaces en MooTools es necesario extender su funcionalidad nativa, en este artículo te explicamos cómo lograrlo.

Un namespace es un contenedor de identificadores, el cual permite la desambiguación de éstos cuando varios tienen el mismo nombre pero residen en diferentes espacios. Es conocido que MooTools no fomenta el uso de namespaces para las clases utilizadas dentro de su estructura, sin embargo muchos frameworks populares de JavaScript como jQuery, Dojo, YUI, entre otros, tratan de adecuar esta funcionalidad a través de herramientas externas, por lo que es deseado que MooTools siga este paradigma y se adapte para utilizar dichas propiedades.

Para implementar el uso y empleo de namespaces en MooTools, podemos basarnos en el kit de herramientas de Dojo, éste proporciona dos funciones útiles para trabajar con ellos, dojo.getObject y dojo.setObject. Estos métodos permiten establecer y obtener objetos anidados a través de cadenas de texto.

Objetos anidados

Aplicando dicha metodología, podemos establecer las funciones necesarias para crear y obtener objetos anidados de forma rápida y sencilla con MooTools. Podemos modificar el código que nos proporciona Dojo y adapatarlo de la siguiente manera:

(function() {

	//Método para obtener y establecer los objetos que pueden o no existir
	var objectifier = function(partes, crea, contexto) {
		var resultado = contexto || window;
		for(var i = 0, s; resultado && (s = partes[i]); i++) {
			resultado = (s in resultado ? resultado[s] : (crea ? resultado[s] = {} : undefined));
		}
		return resultado;
	};

	//Crea un objeto si no existe
	Object.extend("establece", function(nombre, valor, contexto) {
		var partes = nombre.split("."), s = partes.pop(), resultado = objectifier(partes, true, contexto);
		return resultado && s ? (resultado[s] = valor) : undefined;
	});

	//Trae un objeto si es que no está presente
	Object.extend("trae", function(nombre, crea, contexto) {
		return objectifier(nombre.split("."), crea, contexto);
	});

	//Comprueba si el objeto existe
	Object.extend("existe", function(nombre, contexto) {
		return Object.retrieve(nombre, false, contexto) !== undefined;
	});

})();

Ambos métodos utilizan un método de root para analizar la cadena y realizar la búsqueda del objeto, si es que existe. El método “establece” crea el objeto, aceptando su nombre, el valor, y el contexto (objeto base), creando el objeto como se desea:

// Crea mi.namespace.MiClase
Object.establece("mi.namespace.MiClase", {
	nombre: "LaWebera"
});
// mi.namespace.MiClase.nombre = "LaWebera"

// Crea otro.objeto.existente.mi.namespace.MiClase
Object.establece("mi.namespace.MiClase", {
	nombre: "LaWebera"
}, otro.objeto.existente); // Tiene que ser un objeto que ya existe

Asimismo, el método “trae” busca y recupera el objeto, así como opcionalmente puede crearlo:

// Obtener un objeto
Object.trae("mi.namespace.MiClaseDos");

// Trata de encontrar un objeto, lo crea si no existe
Object.trae("mi.namespace.MiClaseTres", true);

La función “existe” por su parte, se encarga de verificar e indicarnos si un objeto existe o no:

Object.existe(“mi.namespace.MiClaseDos”); // regresa TRUE o FALSE

Estos métodos te serán de gran utilidad cuando busques trabajar con objetos dinámicos y con namespaces, así que tenlos a la mano para trabajar con ellos como base.

Namespaces en clases

Al final del día los namespaces son técnicamente objetos anidados, y como ya tenemos las funciones para crear y obtener dichos objetos con MooTools, es tiempo de hacer uso de ellos y modificar una clase de modo que podamos crear una clase con namespaces.

Esta técnica es bastante sencilla:

(function() {
	
	// Mantenemos la referencia a la clase original
	var original_class = Class;
	
	// Redefinimos la clase
	Class = function(nombre, parametros, contexto) {
		// Verificamos si es el método original o el que fue hecho namespace
		var namespace_aplicado = (argumentos.length > 1);
		
		// Añadimos el nombre de la clase a la lista de parámetros
		if(namespace_aplicado) parametros.$nombre = nombre;
		
		// Creamos y obtenemos la clase original
		var original = new original_class(namespace_aplicado ? parametros : nombre);
		
		// Si el namespace fue aplicado, establecemos la clase
		if(namespace_aplicado) Object.establece(nombre, original, contexto);
		
		// Regresamos la clase que recien creamos
		return original;
	};
	
})();

Mantenemos la referencia a la clase original, ya que se va a utilizar en la nueva función de Class, la cual toma como argumentos tres variables, el nombre de la clase, los parámetros que básicamente son las propiedades habituales de la clase y el contexto que se quiere pasar al método Object.establece. El primer paso consiste en analizar los argumentos que se envían a Class, si sólo se envía un argumento es una clase tradicional, si se proporciona más de un argumento estamos tratando de crear una clase namespace y es ahi donde se llama el resto de la funcionalidad. En el código anterior también añadimos la propiedad $nombre a la clase, proporcionando así el nombre de la clase para su uso posterior.

De esta manera es como se utiliza la nueva función Class:

// Crea una clase namespace
var miClase = new Class("lawebera.ui.Cortinilla", {
	initialize: function() { 
		// Acciones
	},
	metodo: function(){}
});
// miClase === lawebera.ui.Cortinilla

El primer parámetro es el nombre que se le dará al namespace, mientras que el segundo es simplemente una serie de parámetros. Si sólo proporcionamos un argumento la clase que se retorna utilizará la función nativa. Ambas opciones regresarán al final una nueva clase creada. Para crear una instancia de la clase se hace lo siguiente:

var instClase = new lawebera.ui.Cortinilla({
    // Propiedades
});

// Obtener el nombre de la clase declarada
var nombre_de_la_clase = instClase.$nombre; // Guarda en la variable el valor "lawebera.ui.Cortinilla"

Los namespaces son una funcionalidad adecuada para cuando tengamos un entorno contaminado por variables de tipo global.

Publicado el 02/10/2013, última actualización 07/11/2013.

Contenido exclusivo de LaWebera.es. Prohibida su copia.

Autor: Daniel Ernesto Navarro Herrera

URL: LaWebera.es :: Diseño de paginas web

(Subir al texto)

Añadir Comentario

* Campos obligatorios

Meneame Bitacoras