de Flavio H. Freitas

ES8: Noutăți în limba JavaScript în 2017

ES8 Noutati in limba JavaScript in 2017
Ce mai e nou?

ES8 este live! Lansat la începutul acestei veri, ES8 (numit și ES2017) oferă noi modalități de codificare cu JavaScript. Să le explorăm.

Dacă aveți cea mai recentă versiune de Chrome, deschideți consola și să codificăm împreună.

1612149065 552 ES8 Noutati in limba JavaScript in 2017
Cum se accesează consola JavaScript în Chrome: Vizualizare> Dezvoltator> Consolă JavaScript

Object.values ​​()

Accesați toate valorile obiectului nostru fără nicio complicație. Iată un exemplu:

const countries = {    BR: 'Brazil',    DE: 'Germany',    RO: 'Romania',    US: 'United States of America'};
Object.values(countries); // ['Brazil', 'Germany', 'Romania', 'United States of America']

Obiect.intrări

Întoarce-ți obiect atribut într-un matrice de atribute:

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']]

Umplutura de șiruri (padStart și padEnd)

Aceasta returnează șirul trecut adăugând pad-ul și începutul sau la sfârșitul acestuia. Definiția funcției este:

'string'.padStart(targetLength, padString)
'string'.padEnd(targetLength, padString)

Putem face:

'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 ()

Returnează toți descriptorii de proprietăți proprii (ne-moșteniți) ai unui obiect. Atributele obiectului returnat pot fi: value, writable, get, set, configurable și 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 exemplu practic este: JavaScript are o metodă de copiere a proprietăților Object.assign(). Copiază proprietatea a cărei cheie este key. Asa:

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

Și, în unele cazuri, nu reușește, deoarece nu copiază în mod corespunzător proprietățile cu atribute non-implicite, cum ar fi getters, setere și proprietăți care nu pot fi scrise.

De exemplu:

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"

Rezolvarea:

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

Urmărirea virgulelor în listele parametrilor funcției și apeluri

Aceasta este o schimbare de sintaxă. Ne permite să scriem o declarație de funcție validă cu virgulă în cele din urmă.

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

Funcții de asincronizare (asincronizare și așteptare)

Acest lucru face mult mai ușor să lucrați cu funcții asincrone:

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)

Memorie partajată și atomică

In conformitate cu specificație:

“Memoria partajată este expusă sub forma unui nou tip SharedArrayBuffer; noul obiect Atomics global oferă operații atomice pe locațiile de memorie partajată, inclusiv operațiuni care pot fi utilizate pentru a crea primitive de sincronizare de blocare.”

Asta înseamnă:

Memorie partajată: putem permite ca mai multe fire să citească și să scrie aceleași date cu noul SharedArrayBuffer constructor.

Atomică: Putem folosi Atomics obiectați pentru a vă asigura că nimic din ceea ce este scris sau citit nu va fi întrerupt la mijlocul procesului. Deci operațiile sunt terminate înainte de a începe următoarea.

Dacă ți-a plăcut acest articol, asigură-te că îmi place să-mi dai multe palme – înseamnă scriitor lumea? Și furmează-mă dacă doriți să citiți mai multe articole despre Cultură, Tehnologie și Startup-uri.

Flávio H. de Freitas este antreprenor, inginer, iubitor de tehnologie, visător și călător. A lucrat ca CTO în Brazilia, Silicon Valley și Europa.