QueQue: Colas de ejecución

QueQue es una pequeña librería que surgue con motivo de ampliar el ejemplo de una entrada anterior (en la cual vimos como implementar una cola básica de ejecución) . La idea es básicamente ejecutar un conjunto de métodos en un orden dado y compartiendo cierta información en cada paso (algo parecido a un pipeline).

QueQue tiene además soporte para eventos, manejo de errores y tareas asincrónicas.

La idea a grandes rasgos es facilitar la escritura de código asincrónico sin necesidad de caer en un anidamiento interminable de callbacks permitiendo además, que cada paso sea un proceso atómico y encapsulado que no conoce de la tarea siguiente. Obviamente, el resultado va a ser menos conciso que la versión de callbacks anidados, pero en la mayoría de los casos esto no representa un problema.

// Callbacks anidados
function addStatus(id, callback) {
	// Task 1
	ajax('/user/status', { id: id } , function(json) {
		var s = new Status(json);
		// Task 2
		ajax('/user/set/', { hash: s.getHash() }, function(json) {
			// Task 3
			callback(json);
		});
	});
}

// Utilizando QueQue se transforma en
function addStatus(id, callback) {
	QueQue()
		// Task 1
		.add(function(proxy) {
			ajax('/user/status', { id: id}, function(json) {
				var s = new Status(json);
				proxy.ready(s.getHash());
			});
		}, { async: true })
		// Task 2
		.add(function(proxy) {
			ajax('/user/set/', { hash: proxy.memo }, function(json) {
				proxy.ready(json);
			});
		}, { async: true })
		// Task 3
		.add(callback)
		.start();
}

Ejemplos

La instanciación puede ser explícita (new QueQue) o implícita (QueQue()):

var q = new QueQue();
var k = QueQue();

// Ejecución sin asignación
QueQue.add(alert).add(console.log).start();

En principio, el ejemplo más básico es la ejecución de tareas sincrónicas sin relación directa:

// Basic queue
QueQue()
	.add(function(proxy) {
		console.log('Hello');
	})
	.add(function(proxy) {
		console.log('world!');
	})
	.start();

Haciendo uso de la cola como si fuese un pipeline, donde cada tarea utiliza el resultado de la anterior. En las tareas sincrónicas basta con devolver el objeto en común, mientras que en las asincrónicas se asigna como parámetro del método proxy.ready:

function Pizza() {
	function d(cb) { setTimeout(cb, 1500) }
	this.knead = this.cook = d;
}

// Pipeline
QueQue()
	.onStart(function() {
	    console.log('Start');
	})
	.onComplete(function() {
	    console.log('Pizza time!');
	})
	.add(function(proxy) {
		var pizza = proxy.memo;

		// Amasamos
		pizza.knead(function() {
			proxy.ready(pizza);
		});
	}, { async: true })
	.add(function(proxy) {
		var pizza = proxy.memo;

		// Cocinamos
		pizza.cook(function() {
			proxy.ready(pizza);
		});
	}, { async: true })
	.add(function(proxy) {
		var pizza = proxy.memo;
		// ... cut
	})

	.start(new Pizza);

API General

add

QueQue add(Function fn[, Object opts])

Agrega una tarea a la lista de ejecución, dicha tarea será situada en el último lugar de la lista en dicho momento. Las opciones disponibles para la tarea son:

  • Boolean async
    Indica si la tarea es asincrónica. En caso de que así sea se la considerará finalizada una vez que se ejecute el método proxy.ready. Por defecto false.
  • Object scope
    Contexto en el cual se ejecutará la tarea. Por defecto la instancia actual de QueQue.
  • Function onException
    Handler específico de exceptions para la tarea. En caso de estar definido será ejecutado en lugar de los handlers de exceptions generales.

clear

QueQue clear()

Elimina las tareas pendientes de la cola.

end

QueQue end()

Detiene la ejecución y elimina las tareas pendientes de la cola. Dispara el evento complete.

start

QueQue start([Object subject])

Comienza la ejecución de las tareas. Recibe como argumento un objeto que puede ser capturado por la primer tarea mediante la referencia proxy.memo. Dispara el evento start.

stop

QueQue stop()

Detiene la ejecución, detención que se hace efectiva una vez terminada la tarea actual. Dispara el evento stop.

Eventos

on

QueQue on(String event, Function handler)

Handler genérico, recibe como primer argumento el evento a observar y luego el handler. Los eventos posibles son add, complete, exception, start y stop.

onAdd

QueQue onAdd(Function handler)

Se ejecuta al agregar una tarea. El handler recibe como único párametetro un objeto con las opciones definidas para la tarea.

onComplete

QueQue onComplete(Function handler)

Se ejecuta al finalizar la ejecución de las tareas. Este handler no recibe argumentos.

onException

QueQue onException(Function handler)

Se ejecuta al generarse un error en una tarea. El handler recibe como único párametetro la exception generada.

onStart

QueQue onStart(Function handler)

Se ejecuta al comenzar las tareas. Este handler no recibe argumentos.

onStop

QueQue onStop(Function handler)

Se ejecuta al detener las tareas. Este handler no recibe argumentos.

Código Fuente

GitHubEl código fuente (y en algun  futuro tests y ejemplos) está disponible en un repositorio público de GitHub: QueQue.

Leer más:


Shortlink: http://goo.gl/A0kOY




3 views shared on this article. Join in...

  1. Alex dice:

    Saludos, baje los archivos de https://github.com/Aijoona/QueQue (index.html y QueQue.js) y al ejecutar el siguiente ejemplo
    QueQue()
    .add(function(proxy) {
    return proxy.memo + ‘ world’;
    })
    .add(function(proxy) {
    console.log(proxy.memo + ‘!’);
    })
    .start(‘Hello’);

    manda el siguiente error
    this._memo.steps is undefined Line 135 (QueQue.js)

    Gracias.



Pings to this post

  1. […] Para una implementación más completa, ver la entrada ‘QueQue: Colas de ejecución‘. […]


Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Comment

You may use these tags : <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>