Algunas de estas técnicas han sido guardadas celosamente por los grandes gurús de Javascript (y en general de cualquier lenguaje un poco moderno) pero hoy por fin verán la luz para que todo el mundo pueda convertirse en uno de ellos:

Arrays

Lo mejor para saber el número de elementos que tiene tu array no es usar la propiedad length ya implementada de serie. No. Lo mejor es tener una variable numeroElementos que vamos actualizado cada vez que hagamos una operación. De esta manera conseguimos varia ventajas:

• Para eliminar el último elemento añadido en un array no merece la pena usar el método pop(). Es "más mejor" hacer numeroElementos--;
• Seguro que alguna vez habéis tenido que hacer operaciones con los elementos de un array del tipo "el primero y el segundo, segundo y tercero, tercero y cuarto..." y siempre había un problema con el último (nos salíamos del array y teníamos una excepción, o teníamos que crear un caso especial o...). Pues gracias al consejo anterior nos olvidamos de esos problemas ya que ¡el elemento seguirá estando a pesar de hacer numeroElementos--!
• La mejor manera de vaciar por completo un array en JS no es hacer Array.clear(myArray); o myArray = []; o myArray = new Array();  Lo mejor es hacer myArray.length = 0;  El porqué no es mejor hacer numeroElementos = 0; es todavía un misterio para mí.

Condicionales

Como los compiladores a veces son un poquito tontitos, siempre está bien verificar dos veces (o más) que algo es cierto. if(variableBooleana == true)

Y vosotros, ¿qué secretos informáticos habéis descubierto en vuestros proyectos y podéis compartir?

Si alguna vez os ha tocado programar (o copypastear) algo en Javascriptquizás desconozcáis que Javascript es un lenguaje orientado a objetos y más concretamente basado en prototipos. ¿Qué quiere decir esto? Que si pensáis que sabéis programar en Java o C# y os mandan a un proyecto donde solo hay Javascript más os vale que os informéis un poco de cómo funcionan las cosas antes de poneros a tirar líneas como locos.

Orientación basada en prototipos

La principal diferencia con los lenguajes más comunes es la ausencia de clases (ya puedo sentir tu cara de escepticismo). ¿Cómo obtenemos herencia, polimorfismo y todas esas cosas tan grandiosas de la programación orientada a objetos? Pues principalmente mediante la "clonación" de objetos ya existentes (que sirven como prototipos) y añadiéndoles nuevos comportamientos. La otra manera es crear objetos nuevos de la nada (ex nihilo). Con Javascript además podemos añadir nuevas funcionalidades a objetos ya predefinidos.

Objetos ya predefinidos:

function outputBackwards(){
	for (i=this.length-1;i>=0;i--)
		document.write(this.charAt(i))
}

String.prototype.writeback=outputBackwards

Con esto hemos añadido un método (writeback())que nos permite imprimir una cadena de caracteres en sentido inverso al objeto String.

Objetos propios

function Person(){}
var anton = new Person();
anton.edad = 25;

Con esto creamos un objeto del tipo persona llamado anton y le añadimos la propiedad edad que tiene como valor 25. Para añadir nuevos comportamientos a nuestros objetos se haría de la siguiente forma:

function Person(){}

Person.prototype.dormir = function(){}

Va quedando más clara la cosa, ¿no? La herencia se resuelve aplicando el prototipo del objeto "madre" a nuestro nuevo objeto:

function AnObject(){}
function AnotherObject(){}
AnotherObject.prototype = new AnObject();

AnotherObject recupera el prototipo de AnObject (todas sus propiedades y métodos). Si queremos añadir nuevos comportamientos habría que hacer como en el ejemplo anterior. Creo que la flexibilidad y la cantidad de cosas horribles que se pueden hacer como meta alguien que no sabe, han quedado patentes :)

Y ahora que lo tenéis todo claro, de los dos códigos siguientes ¿cuál os parece que se ajusta mejor a la forma de pensar del lenguaje?

function myObject1(){
	this.method1 = method1;
	this.method2 = method2;
}

function method1(){
	//Something here
}

function method2(){
	//Something here too
}

function myObject1(){	
}

myObject1.prototype.method1 = function(){
	//Something here
}

myObject1.prototype.method2 = function(){
	//Something here too
}

En el primer caso solo le veo sentido si method1 y method2 se fueran a compartir entre varios objetos (no era el caso cuando lo vi), aunque siempre nos quedaría copiar el protoype del original como hemos visto antes. Si me equivoco que alguien me lo diga :)

Para el próximo post sobre Javascript pondré algo sobre la modificación de funciones y métodos de forma dinámica, que es algo curioso.