ES2019: Novedades de JavaScript en 2019

es2019

ES2019: Novedades de JavaScript en 2019

Este es el tercero de una serie de artículos donde estamos repasando las novedades de los últimos años en JavaScript. En los anteriores artículos ya vimos las novedades de JavaScript en 2020 y 2021. En este artículo volveremos a subirnos a la máquina del tiempo de H.G. Wells para viajar un par de años al pasado y repasar las novedades de JavaScript en 2019, es decir, las novedades de ES2019.

Al igual que en los artículos anteriores, me voy a centrar exclusivamente en aquellas novedades de ES2019 que sean más asequibles. Las novedades que impliquen un uso avanzado del lenguaje las comentaré simplemente de pasada. Aunque ya os adelanto (spoilers!) que este año 2019 las novedades no fueron gran cosa.

Optional catch binding

Antes en el catch era obligatorio indicar un parámetro para el error. Desde ES2019 ya no es obligatorio.

Antes:

try {
  throw new Error("Error extremadamente grave!");
} 
catch(error) {
  console.log(error);
}

Ahora:

try {
  throw new Error("Error extremadamente grave!");
} 
catch {
  console.log("Algo muy feo ha pasado!"); // no usamos el error
}

JSON superset y Well-formed JSON.stringify

Estas dos novedades, como están relacionadas con JSON, y además tienen escaso interés, he decidido unificarlas.

En ambos casos, se trata mas bien de corrección de problemas, mas que de novedades.

La primera novedad se refiere a que antes había 2 caracteres (los extremadamente poco usados U+2028 y U+2029) no permitidos dentro de un JSON, que ahora si están permitidos.

En el caso de la segunda novedad, la especificación indica que JSON debe de ser codificado usando UTF-8, pero el problema es que JSON.stringify() podía devolver caracteres que no tienen representación en UTF-8. A partir de ES2019 simplemente para estos caracteres se usan secuencias de escape.

Symbol.prototype.description

Antes, cuando se creaba un Símbolo, la descripción que le dábamos no era accesible directamente, tan solo indirectamente a través del método toString(). Ahora disponemos de una nueva propiedad llamada description que nos proporciona de forma más directa la descripción.

const EJEMPLO = Symbol("Descripción"); // creamos un símbolo
alert(EJEMPLO.toString()); // forma indirecta de obtener la descripción
alert(EJEMPLO.description); // nueva forma directa de obtener la descripción

Function.prototype.toString revision

En ES2019 se ha mejorado el método toString() de las funciones. Este método nos devuelve el código de una función. Entre estas mejoras, ahora si que nos devuelve los comentarios del código.

function saluda() { alert("Hola"); /* comentario en el código */ }
alert(saluda.toString());

Object.fromEntries

A mi ver, una de las pocas novedades interesantes de ES2019. Se trata de un nuevo método estático de la clase Object para convertir una lista de elementos «clave-valor» en un objeto.

var profesor = Object.fromEntries([['nombre', 'Abel'], ['apellidos', 'Camarena']]);
console.log(profesor.nombre + " " + profesor.apellidos);

String.prototype.{trimStart,trimEnd}

Aunque no había especificación que lo pidiese, la mayoría de los navegadores tenían los métodos trimLeft() y trimRight() para eliminar espacios en blanco al principio y al final de una cadena de texto. En ES2019 estos métodos fueron renombrados a trimStart() y trimEnd() para mantener coherencia con los métodos padStart() y padEnd(). Los métodos trimLeft() y trimRight() se mantienen como «alias» para no romper la compatibilidad.

var s = "     Hola ".trimStart() + " mundo!     ".trimEnd();
alert("["+s+"]");

Array.prototype.{flat,flatMap}

Y terminamos con otra interesante novedad de ES2019.

Se trata de un par de nuevos métodos para los arrays: el método flat() y el método flatMap().

Empecemos por el más sencillo de los dos, el método flat(). Se trata de un método que nos devuelve una copia pero con menos dimensiones, es decir, nos devuelve el mismo array «aplanado». Lo mejor es ver un ejemplo:

var a = [ // array multi dimensional
  [1, [2, 3, [4, 5, [6, 7]]]],
  [8, 9, [10, 11], [12]]
];
console.log(a.flat());  // aplanamos 1 dimensión
console.log(a.flat(2)); // aplanamos 2 dimensiones
console.log(a.flat(Infinity)); // aplanamos totalmente
// esta ultima instrucción muestra en la consola el
// array unidimensional devuelto:
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

Como parámetro indicamos los niveles de profundidad que queremos eliminar, o bien Inifity para obtener un array totalmente aplanado, es decir, unidimensional.

Por su parte, el método flatMap() es una combinación de los métodos flat() y map(). Concretamente, es lo mismo que usar el método map() y después el método flat(). Veamos otro ejemplo:

// en este ejemplo, por cada item del array vamos a devolver 
// otro array con su doble y con su valor elevado al cuadrado
var a = [1,2,3,4,5];
console.log(a.map(val=>[val*2, val*val])); // solo con map
// esta ultima instrucción muestra en la consola:
// [[2, 1], [4, 4], [6, 9], [8, 16], [10, 25]]
console.log(a.flatMap(val=>[val*2, val*val])); // con flatMap
// esta ultima instrucción muestra en la consola:
// [2, 1, 4, 4, 6, 9, 8, 16, 10, 25]

Conclusión

Como podéis ver, ES2019 fue una actualización aburrida (o tranquila, según se mire) de JavaScript. Y es que, afortunadamente, no todas las actualizaciones iban a ser tan animadas como lo fue ES2015.

Escribe un comentario