ES8: Novedades del lenguaje JavaScript en 2017

¡ES8 está en vivo! Lanzado a principios de este verano, ES8 (también llamado ES2017) ofrece nuevas formas de codificar con JavaScript. Vamos a explorarlos.

Si tiene la última versión de Chrome, abra la consola y codifiquemos juntos.

Object.values ​​()

Accede a todos los valores de nuestro objeto sin ninguna complicación. He aquí un ejemplo:

const countries = { BR: 'Brazil', DE: 'Germany', RO: 'Romania', US: 'United States of America'};

Object.values(countries); // ['Brazil', 'Germany', 'Romania', 'United States of America']

Entradas de objeto

Convierta su atributo de objeto en una matriz de atributos:

const countries = { BR: 'Brazil', DE: 'Germany', RO: 'Romania', US: 'United States of America'};

Object.entries(countries); 

// [['BR', 'Brazil'], ['DE', 'Germany'], ['RO', 'Romania'], ['US','United States of America']]

Relleno de cadenas (padStart y padEnd)

Esto devuelve la cadena pasada agregando el pad y el principio o al final. La definición de la función es:

'string'.padStart(targetLength, padString)

'string'.padEnd(targetLength, padString)

Podemos hacer:

'0.10'.padStart(10); // it return a string of length 10, padding empty spaces in the beginning

'hi'.padStart(1); // 'hi''hi'.padStart(5); // ' hi''hi'.padStart(5, 'abcd'); // 'abchi''hi'.padStart(10, 'abcd'); // 'abcdabcdhi'

'loading'.padEnd(10, '.'); // 'loading...'

// useful example making things easier to read'0.10'.padStart(12); // ' 0.10''23.10'.padStart(12); // ' 23.10''12,330.10'.padStart(12); // ' 12,330.10'

Object.getOwnPropertyDescriptors ()

Devuelve todos los descriptores de propiedad propios (no heredados) de un objeto. Los atributos del objeto de retorno pueden ser: value, writable, get, set, configurabley enumerable.

const obj = { name: 'Pablo', get foo() { return 42; }};

Object.getOwnPropertyDescriptors(obj);//// {// "name": {// "value": "Pablo",// "writable":true,// "enumerable":true,// "configurable":true// },// "foo":{// "enumerable":true,// "configurable":true,// "get": function foo()// "set": undefined// }// }

Un ejemplo práctico es: JavaScript tiene un método para copiar propiedades Object.assign(). Copia la propiedad cuya clave es key. Me gusta esto:

const value = source[key]; // gettarget[key] = value; // set

Y en algunos casos falla porque no copia correctamente las propiedades con atributos no predeterminados como captadores, definidores y propiedades no grabables.

Por ejemplo:

const objTarget = {};const objSource = { set greet(name) { console.log('hey, ' + name); }};Object.assign(objTarget, objSource);

objTarget.greet = 'love'; // trying to set fails, sets greet = 'love'

Resolviendo:

const objTarget = {};const objSource = { set greet(name) { console.log('hey, ' + name); }};Object.defineProperties(objTarget, Object.getOwnPropertyDescriptors(objSource));

objTarget.greet = 'love'; // prints 'hey, love'

Comas finales en listas y llamadas de parámetros de funciones

Este es un cambio de sintaxis. Nos permite escribir una declaración de función válida con una coma al final.

getDescription(name, age,) { ... }

Funciones asincrónicas (async y await)

Esto hace que sea mucho más fácil trabajar con funciones asincrónicas:

function loadExternalContent() { return new Promise((resolve, reject) => { setTimeout(() => { resolve('hello'); }, 3000); });}

async function getContent() { const text = await loadExternalContent(); console.log(text);}

console.log('it will call function');getContent();console.log('it called function');

// it prints:

'it will call function' // synchronous'it called function' // synchronous'hello' // asynchronous (after 3 seconds)

Atómica y memoria compartida

Según la especificación:

"La memoria compartida se expone en forma de un nuevo tipo SharedArrayBuffer; el nuevo objeto Atomics global proporciona operaciones atómicas en ubicaciones de memoria compartida, incluidas operaciones que se pueden utilizar para crear primitivas de sincronización de bloqueo".

Esto significa:

Memoria compartida: podemos permitir que varios subprocesos lean y escriban los mismos datos con el nuevo SharedArrayBufferconstructor.

Atómica: podemos usar el Atomicsobjeto para asegurarnos de que nada de lo que se está escribiendo o leyendo se interrumpirá en medio del proceso. Entonces las operaciones terminan antes de que comience la siguiente.

Si te ha gustado este artículo, asegúrate de que te guste, dame muchas palmadas, ¿significa mucho para el escritor? Y sígueme si quieres leer más artículos sobre Cultura, Tecnología y Startups.

Flávio H. de Freitas is an Entrepreneur, Engineer, Tech lover, Dreamer and Traveler. Has worked as CTO in Brazil, Silicon Valley and Europe.