Aprendiendo Javascript: Javascript Koans

En el último año (incluso últimos años) está ganando mucha importancia un lenguaje de programación que nunca ha tenido muy buena fama, me refiero a Javascript. En mi caso personal me interesa aprender Javascript porque se presenta como una solución muy interesante en el desarrollo de aplicaciones móviles multiplataforma, además de tener todo un ecosistema de frameworks, como JQuery, que permiten crear una interfaz más amigable para nuestros clientes.

La cuestión más importante es, ¿por dónde empiezo?. Está la aproximación clásica de leer libros, blogs y hacer todos los ejercicios que puedas, pero he optado por seguir previamente el camino de las koans. ¿No sabes lo que son las koans?, pues a grandes rasgos se trata de un proyecto en el que tienes que completar una serie de problemas propuestos, con pasos muy sencillos. A medida que vas avanzando, cada ejercicio te "ilumina" sobre algún aspecto importante del lenguaje. Existen koans para casi todos los lenguajes, desde Ruby hasta Scala, pasando por Clojure, Java, Groovy y muchos más.

Buscando en Google yo he encontrado los siguientes repositorios de koans para Javascript:

• David Laing repository
• Liam McLennan repository

Me he quedado con la primera opción porque utiliza Jasmine para hacer los tests, y me gusta mucho este framework, algo más "avanzado" que QUnit y con un estilo BDD (Behaviour-Driven Development).

Estas koans son bastante cortas y en algo más de una hora puedes completarlas todas sin problemas. Si conoces otros lenguajes de programación será sencillo y te permitirá conocer las comparaciones o la herencia un poco particulares de Javascript entre otras cosas, pero ni mucho menos serás un experto cuando acabes. Me pareció curioso el uso de la librería Underscore.js, que permite añadir un tratamiento más funcional en el uso de listas y arrays.

Tras haber realizado las koans decidí utilizar la librería Underscore.js para refactorizar la kata de StringCalculator que había hecho hacía un tiempo, y aquí está el resultado.

Código final de la kata sin Underscore.js

	StringCalculator = {
	add : function(input) {
	checkIfContainsNegativeNumbers(input);
	var parser = new Parser(input);
	var numbers = parser.parse();
	return numbers.getSummatory();
	}
	}
	function checkIfContainsNegativeNumbers(input) {
	negativeNumbers = input.getNegativeNumbers();
	if (negativeNumbers)
	throw "Negative numbers are not supported (" + negativeNumbers.toStringList() + ")";
	}
	function Parser(input) {
	var _input = input;
	this.parse = function() {
	var separator = parseSeparator(_input);
	var numbers = parseNumbers(_input);
	return numbers.replace(separator, ",").split(/,|\n/g);
	}
	function parseNumbers(input) {
	if (input.hasCustomDelimiter())
	return input.getNumbersAfterDelimiterDefinition();
	return input;
	}
	function parseSeparator(input) {
	if (input.hasCustomDelimiter())
	return input.getCustomDelimiter();
	return ",";
	}
	}
	/* Extending Javascript types to symplify code legibility */
	Array.prototype.getSummatory = function() {
	var result = 0;
	for (var current = 0; current < this.length; current++)
	result += parseInt(this[current] || 0);
	return result;
	}
	Array.prototype.toStringList = function() {
	var message = "";
	for (var current = 0; current < this.length; current++) {
	message += this[current];
	if (current < this.lastElementPosition())
	message += ", ";
	}
	return message;
	}
	Array.prototype.lastElementPosition = function() {
	return this.length - 1;
	}
	String.prototype.getNegativeNumbers = function() {
	return this.match(/-\d/g);
	}
	String.prototype.hasCustomDelimiter = function() {
	return this.match("^\/\/");
	}
	String.prototype.getCustomDelimiter = function() {
	return this.charAt(2);
	}
	String.prototype.getNumbersAfterDelimiterDefinition = function() {
	var matcher = this.match("(//;\n)?(.*)");
	return matcher[2];
	}

view raw stringcalculator_v1.js hosted with ❤ by GitHub

Código tras utilizar Underscore.js y eliminar alguna función que sobraba :-P

	StringCalculator = {
	add : function(input) {
	checkIfContainsNegativeNumbers(input);
	var numbers = new Parser(input).parse();
	return _(numbers).reduce(this.summatory);
	},
	summatory: function(summatory, element) {
	return summatory + element;
	}
	}
	function checkIfContainsNegativeNumbers(input) {
	negativeNumbers = input.getNegativeNumbers();
	if (negativeNumbers)
	throw "Negative numbers are not supported (" + negativeNumbers.toString() + ")";
	}
	function Parser(input) {
	var _input = input;
	this.parse = function() {
	var separator = parseSeparator(_input);
	var numbers = parseNumbers(_input);
	numbers = numbers.replace(separator, ",").split(/,|\n/g);
	return _(numbers).map(parseToIntNumber);
	}
	function parseNumbers(input) {
	if (input.hasCustomDelimiter())
	return input.getNumbersAfterDelimiterDefinition();
	return input;
	}
	function parseSeparator(input) {
	if (input.hasCustomDelimiter())
	return input.getCustomDelimiter();
	return ",";
	}
	var parseToIntNumber = function(element) {
	return parseInt(element || 0);
	}
	}
	/* Extending Javascript types to symplify code legibility */
	String.prototype.getNegativeNumbers = function() {
	return this.match(/-\d/g);
	}
	String.prototype.hasCustomDelimiter = function() {
	return this.match("^\/\/");
	}
	String.prototype.getCustomDelimiter = function() {
	return this.charAt(2);
	}
	String.prototype.getNumbersAfterDelimiterDefinition = function() {
	var matcher = this.match("(//;\n)?(.*)");
	return matcher[2];
	}

view raw stringcalculator_v2.js hosted with ❤ by GitHub

Quien quiera ver el código más en detalle puede utilizar este enlace.