La evolución de JavaScript

En los últimos meses, y viendo la popularidad de JavaScript debido a fenómenos como HTML5 o NodeJs, me he propuesto ponerme al día con JavaScript, ese lenguaje que normalmente utilizo para hacer validaciones en mis páginas HTML, pero que, en realidad, permite mucho más que eso.

Lo cierto es que, debido al boom que está sufriendo este lenguaje, lo que más me está costando es saber cuál es el estado en que se encuentra y hacia donde se encamina. Por ello, sirva este post para recopilar las ideas que sobre ello he ido encontrando y para, a partir de él, seguir profundizando en el lenguaje y sus capacidades, tanto nuevas como antiguas.

JavaScript surgió como un lenguaje de script en el navegador que apareció por primera vez dentro de Netscape Navigator 2 allá por 1995, y que se basaba en el lenguaje CEnvi desarrollado anteriormente por Nombas.

Fue tal el éxito de JavaScript que Microsoft decidió incorporar su propia implementación de este lenguaje, llamada JScript, en la versión 3 de su navegador Internet Explorer.

Debido a los problemas que entrañaban las diferencias entre implementaciones, se envió la versión JavaScript 1.1 como propuesta a ECMA para su estandarización, que culminó con el estándar ECMA-262. Este estándar dicta la base del lenguaje ECMAScript a través de su sintaxis, tipos, sentencias, palabras clave y reservadas, operadores y objetos, y sobre la cual se pueden construir distintas implementaciones. La versión JavaScript 1.3 fue la primera implementación completa del estándar ECMAScript.

Actualmente, las implementaciones de JavaScript de los navegadores implementan la versión 3 del estándar ECMAScript, que data de 1999, y cuyas últimas mejoras han sido:

• Soporte de expresiones regulares.
• Nuevas sentencias de control.
• Manejo de excepciones (bloque try-catch).
• Definición de errores más precisa.
• Formateo de salidas numéricas de datos.
• Manejo de strings más avanzado.

Cuando en 2004 se empezó a trabajar en la evolución de JavaScript, surge la revolucionaria propuesta ECMAScript 4, que pretende convertir JavaScript en un nuevo lenguaje con nuevas reglas, principalmente introduciendo el tipado de variables y el concepto tradicional de clases e interfaces al estilo de lenguajes como Java.
Debido a la revolución que estos cambios en JavaScript suponían, surge ECMAScript 3.1 como contrapropuesta, que evita introducir nuevos conceptos y añade en su lugar características adicionales al lenguaje.

Finalmente se llegó a la decisión de enfocarse en la propuesta ECMAScript 3.1, que se ha cambiado de nombre, pasando a ser ECMAScript 5. ECMASCript 4 ha quedado relegada al proyecto Harmony. Harmony, que a su vez parece que pasará a ser ECMAScript 6, pretende incorporar a posteriori en ECMAScript 5 algunas de las mejoras propuestas inicialmente por ECMAScript 4.

Las características que se incluyen en ECMAScript5 son las siguientes:

• Getters y setters.
• Array extras y reductions.
• Cambios en Object:
  • Rediseño de los atributos internos de las propiedades.
  • Introducción de métodos estáticos de Object, que permiten:
    • Acceder a la información del prototipo.
    • Manipular las propiedades de un objeto.
    • Crear objetos de forma dinámica.
    • Obtener los nombres de las propiedades.
    • Impedir que un objeto sea modificado.
  • Cambios a las funciones:
    • Soporte nativo del function currying a través del método bind.
  • Cambios en el objeto Date.
• Soporte nativo de JSON.
• Modo de ejecución strict, que define reglas de codificación más estrictas que el modo de ejecución estándar.

Los cambios que podrían ser introducidos en ECMAScript 6 se mencionan en esta charla de Dave Herman, ingeniero de Mozilla Labs y representante del TC39:

• Módulos.
• Ámbito a nivel de bloque (sentencia let).
• Generators.
• Proxys.
• Destructuring assignments.
• Rest y default arguments.
• Name objects.
• Iterators.
• Array comprehensions.
• String templates.
• Hash tables y weak maps.

También parece que se podría incluir:

• Constantes.
• Clases y herencia.
• Tipos Map, Set y StructType.

Algunos navegadores ya han ido incluyendo estas y otras mejoras del lenguaje, como se indica en estos datos obtenidos de Wikipedia:

• Javascript 1.5 (Firefox 1.0, IE 8-, Opera 6, Safari 5-, Chrome 10-):
  • ECMAScript 3.
  • Constantes.
  • Getters y setters.
• Javascript 1.6 (Firefox 1.5):
  • Array extras.
  • Array y String Generics.
• Javascript 1.7 (Firefox 2.0):
  • Ámbito a nivel de bloque.
  • Generators.
  • Iterators.
  • Array Comprehensions.
  • Destructuring assignments.
• Javascript 1.8 (Firefox 3.0, Opera 11.50):
  • Expression closures.
  • Generator Expressions.
  • Array Reductions.
• Javascript 1.8.1 (Firefox 3.5):
  • Soporte nativo de JSON.
• Javascript 1.8.2 (Firefox 3.6):
  • Actualizaciones menores.
• JavaScript 1.8.5 (Firefox 4, IE 9):
  • 1.8.2.
  • ECMAScript 5.

Referencias:
- JavaScript en Wikipedia.
- ECMAScript en Wikipedia.
- Presentación sobre ECMAScript 5.
- ECMAScript 5: The Definitive Slides.
- Otra presentación sobre ECMAScript 5.
- Video: "Changes to JavaScript, Part 1".
- Video: "Dave Herman: The Future of JavaScript (ECMAScript 6)"