Ето примери за всичко ново в ECMAScript 2016, 2017 и 2018

Трудно е да следите какво е новото в JavaScript (ECMAScript). И още по-трудно е да намерите полезни примери за код.

Така че в тази статия ще обхвана всички 18 функции, които са изброени в готовите предложения на TC39, добавени в ES2016, ES2017 и ES2018 (окончателен чертеж) и ще ги покажа с полезни примери.

Това е доста дълъг пост, но трябва да се чете лесно. Помислете за това като за четене на Netflix от започване. В края на това обещавам, че ще имате много познания за всички тези функции.

Добре, нека да ги прегледаме една по една.

1. Array.prototype.includes

include е прост метод за екземпляр в Array и помага лесно да се намери дали елемент е в масива (включително NaN за разлика от indexOf).

ECMAScript 2016 или ES7 - Array.prototype.includes ()
Trivia: спецификациите на JavaScript искаха да го назоват, но това очевидно вече се използва от Mootools, така че те използват и включва.

2. Оператор за фиксиране на експоненцията

Математическите операции като събиране и изваждане имат инфиксиращи оператори като + и - съответно. Подобно на тях, ** infix операторът обикновено се използва за работа с експоненти. В ECMAScript 2016, ** беше представен вместо Math.pow.

ECMAScript 2016 или ES7 - ** Оператор за фиксиране на експонентите

1. Object.values ​​()

Object.values ​​() е нова функция, подобна на Object.keys (), но връща всички стойности на собствените свойства на обекта, с изключение на всички стойности (и) в прототипичната верига.

ECMAScript 2017 (ES8) - Object.values ​​()

2. Object.entries ()

Object.entries () е свързан с Object.keys, но вместо да връща само ключове, той връща и ключове, и стойности по метода на масива. Това прави много лесно да се правят неща като използване на обекти в контури или преобразуване на обекти в Карти.

Пример 1:

ECMAScript 2017 (ES8) - Използване на Object.entries () в контури

Пример 2:

ECMAScript 2017 (ES8) - Използване на Object.entries () за преобразуване на обект в карта

3. Струнни подплънки

В String бяха добавени два метода - String.prototype.padStart и String.prototype.padEnd - които позволяват добавяне / предварителен или празен низ или някакъв друг низ към началото или в края на оригиналния низ.

'someString'.padStart (numberOfCharcters [, stringForPadding]);
'5'.padStart (10) //' 5 '
'5'.padStart (10,' = * ') //' = * = * = * = * = 5 '
'5'.padEnd (10) //' 5 '
'5'.padEnd (10,' = * ') //' 5 = * = * = * = * = '
Това е полезно, когато искаме да подравним нещата в сценарии като доста печатен дисплей или терминален печат.

3.1 padStart пример:

В примера по-долу имаме списък с числа с различна дължина. Искаме да добавим „0“, така че всички елементи да имат една и съща дължина от 10 цифри за целите на дисплея. Можем да използваме padStart (10, '0'), за да постигнем лесно това.

ECMAScript 2017 - пример padStart

3.2 padEnd пример:

padEnd наистина е полезен, когато печатаме множество елементи с различна дължина и искаме да ги подравним правилно.

Примерът по-долу е добър реалистичен пример за това как padEnd, padStart и Object.entries всички се събират, за да получат красив изход.

ECMAScript 2017 - пример padEnd, padStart и Object.Entries
const автомобили = {
  'BMW': '10',
  'Tesla': '5',
  'AmLamborghini': '0'
}
Object.entries (автомобили) .map (([име, брой]) => {
  // padEnd добавя '-', докато името стане 20 знака
  // padStart предвещава '0', докато броят стане 3 знака.
  console.log (`$ {name.padEnd (20, '-')} Брой: $ {count.padStart (3, '0')}`)
});
// Отпечатва ..
// BMW - - - - - - - Брой: 010
// Тесла - - - - - - Брой: 005
// Lamborghini - - - Брой: 000

3.3 padStart и padEnd на Emojis и други двубайтови символи

Emojis и други двубайтови символи са представени с помощта на множество байтове unicode. Така че padStart и padEnd може да не работят както се очаква!

Например: Нека да кажем, че се опитваме да забием сърцето на низовете, за да достигнем 10 знака с емоджи. Резултатът ще изглежда по-долу:

// Забележете, че вместо 5 сърца, има само 2 сърца и 1 сърце, което изглежда странно!
'heart'.padStart (10, ""); // отпечатва .. '❤heart'

Това е така, защото long е 2 кодови точки ('\ u2764 \ uFE0F')! Самата дума сърце е 5 знака, така че имаме само 5 символа, останали до тампон. И така, това, което се случва, е, че JS нанася две сърца, използвайки '\ u2764 \ uFE0F' и това произвежда . За последния той просто използва първия байт на сърцето \ u2764, който произвежда ❤

Така завършваме с: сърце

PS: Можете да използвате тази връзка, за да проверите преобразуванията на unicode char.

4. Object.getOwnPropertyDescriptors

Този метод връща всички подробности (включително методите за задаване на getter getand setter) за всички свойства на даден обект. Основната мотивация за добавяне на това е да се позволи плитко копиране / клониране на обект в друг обект, който също копира функциите на getter и setter, за разлика от Object.assign.

Object.assign плитки копира всички детайли, с изключение на функциите за получаване и настройка на оригиналния обект-източник.

Примерът по-долу показва разликата между Object.assign и Object.getOwnPropertyDescriptors заедно с Object.defineProperties за копиране на оригинален обект Car в нов обект ElectricCar. Ще видите, че с помощта на Object.getOwnPropertyDescriptors функциите за получаване на отстъпки и настройките също се копират в целевия обект.

ПРЕДИ…

Преди - Използване на Object.assign

СЛЕД…

ECMAScript 2017 (ES8) - Object.getOwnPropertyDescriptors
вар кола = {
 име: „BMW“,
 цена: 1000000,
 задайте отстъпка (x) {
  това.d = x;
 }
 получите отстъпка () {
  върнете това.d;
 }
};
// Разпечатайте подробности за свойството „отстъпка“ на обекта на автомобил
console.log (Object.getOwnPropertyDescriptor (кола, 'отстъпка'));
// отпечатъци ..
// {
// get: [Функция: get],
// set: [функция: set],
// изброява: вярно,
// конфигурируем: true
//}
// Копирайте свойствата на автомобила в ElectricCar с помощта на Object.assign
const ElectricCar = Object.assign ({}, кола);
// Разпечатайте подробности за свойството „отстъпка“ на обекта ElectricCar
console.log (Object.getOwnPropertyDescriptor (ElectricCar, 'отстъпка'));
// отпечатъци ..
// {
// стойност: неопределена,
// написана: вярно,
// изброява: вярно,
// конфигурируем: true
  
//}
//  Забележете, че гетърите и сетерите липсват в обекта на ElectricCar за свойство „отстъпка“! 
// Копирайте свойствата на Car в ElectricCar2, като използвате Object.defineProperties
// и извличайте свойствата на Car, като използвате Object.getOwnPropertyDescriptors
const ElectricCar2 = Object.defineProperties ({}, Object.getOwnPropertyDescriptors (Car));
// Разпечатайте подробности за свойството „отстъпка“ на обекта ElectricCar2
console.log (Object.getOwnPropertyDescriptor (ElectricCar2, 'отстъпка'));
// отпечатъци ..
// {get: [Функция: get], 
// set: [Функция: набор], 
// изброява: вярно,
// конфигурируем: true
//}
// Забележете, че гетърите и сетерите присъстват в обекта ElectricCar2 за „отстъпка“!

5. Добавете запетайки в параметрите на функцията

Това е незначителна актуализация, която ни позволява да имаме запетаи след последния параметър на функцията. Защо? За да помогнете с инструменти като git blame, за да се гарантира, че само новите разработчици ще бъдат обвинени.

Примерът по-долу показва проблема и решението.

ECMAScript 2017 (ES 8) - Запетая със запетая във функционален параметър
Забележка: Можете също да извиквате функции с последни запетаи!

6. Асинхрон / чакайте

Това, досега, е най-важната и най-полезната функция, ако питате мен. Функциите на Async ни позволяват да не се справяме с ада обратно повикване и правим целия код да изглежда прост.

Ключовата дума async казва на компилатора на JavaScript да третира функцията по различен начин. Компилаторът прави пауза, когато достигне чакащата ключова дума в рамките на тази функция. Предполага се, че изразът след изчакване връща обещание и изчаква, докато обещанието бъде разрешено или отхвърлено, преди да продължи напред.

В примера по-долу функцията getAmount извиква две асинхронни функции getUser и getBankBalance. Можем да направим това обещано, но използването на асинхрон изчакване е по-елегантно и просто.

ECMAScript 2017 (ES 8) - Основен пример за Async Await

6.1 Асинхронните функции сами връщат обещание.

Ако чакате резултата от функция за асинхронизация, трябва да използвате синтаксиса на Promise, за да заснемете резултата му.

В следващия пример искаме да регистрираме резултата с помощта на console.log, но не в рамките на doubleAndAdd. Така че искаме да изчакаме и използваме след това синтаксис, за да предадем резултата на console.log.

ECMAScript 2017 (ES 8) - Async чакайте сами да върнат обещанието

6.2 Повикване на асинхронизация / изчакване паралелно

В предишния пример се обаждаме чакаме два пъти, но всеки път чакаме една секунда (общо 2 секунди). Вместо това можем да го паралелизираме, тъй като a и b не зависят един от друг, използвайки Promise.all.

ECMAScript 2017 (ES 8) - Използване на Promise.all за паралелизиране на асинхронизацията / изчакване

6.3 Грешка при работа с функции за асинхронизация / изчакване

Има различни начини за справяне с грешки при използване на async чакат.

Вариант 1 - Използвайте опит за улавяне във функцията

ECMAScript 2017 - Използвайте опитайте улавяне в рамките на функцията за асинхронизация / изчакване
// Вариант 1 - Използвайте опит за улавяне във функцията
функция за асинхронизация doubleAndAdd (a, b) {
 опитвам {
  a = изчакайте doubleAfter1Sec (a);
  b = изчакайте doubleAfter1Sec (b);
 } улов (д) {
  връщане NaN; // върнете нещо
 }
върнете a + b;
}
// Usage:
doubleAndAdd ('one', 2) .then (console.log); // NaN
doubleAndAdd (1, 2) .then (console.log); // 6
функция doubleAfter1Sec (парам) {
 върнете ново обещание ((разрешаване, отхвърляне) => {
  setTimeout (функция () {
   нека val = param * 2;
   isNaN (val)? отхвърлям (NaN): разрешаване (val);
  }, 1000);
 });
}

Вариант 2 - Уловете всеки изчакващ израз

Тъй като всеки изчакващ израз връща обещание, можете да улавяте грешки във всеки ред, както е показано по-долу.

ECMAScript 2017 - Използвайте опитайте да уловите всеки изчакващ израз
// Вариант 2 - * Улов * грешки във всеки ред на изчакване
// тъй като всеки изчакващ израз е обещание само по себе си
функция за асинхронизация doubleAndAdd (a, b) {
 a = изчакайте doubleAfter1Sec (a) .catch (e => console.log ('"a" е NaN')); // 
 b = изчакайте doubleAfter1Sec (b) .catch (e => console.log ('"b" е NaN')); // 
 ако (! a ||! b) {
  връщане NaN;
 }
 върнете a + b;
}
// Usage:
doubleAndAdd ('one', 2) .then (console.log); // NaN и регистрира: "a" е NaN
doubleAndAdd (1, 2) .then (console.log); // 6
функция doubleAfter1Sec (парам) {
 върнете ново обещание ((разрешаване, отхвърляне) => {
  setTimeout (функция () {
   нека val = param * 2;
   isNaN (val)? отхвърлям (NaN): разрешаване (val);
  }, 1000);
 });
}

Вариант 3 - Уловете цялата функция за асинхронизация в очакване

ECMAScript 2017 - Хванете цялата функция за асинхронизация / изчакване в края
// Вариант 3 - Не правете нищо, освен да се справите извън функцията
// тъй като async / await връща обещание, можем да хванем грешката на цялата функция
функция за асинхронизация doubleAndAdd (a, b) {
 a = изчакайте doubleAfter1Sec (a);
 b = изчакайте doubleAfter1Sec (b);
 върнете a + b;
}
// Usage:
doubleAndAdd ('one', 2)
.След (console.log)
.catch (console.log); //  <------- използвайте "улов"
функция doubleAfter1Sec (парам) {
 върнете ново обещание ((разрешаване, отхвърляне) => {
  setTimeout (функция () {
   нека val = param * 2;
   isNaN (val)? отхвърлям (NaN): разрешаване (val);
  }, 1000);
 });
}
ECMAScript в момента е в окончателен проект и ще излезе през юни или юли 2018 г. Всички функции, обхванати по-долу, са в етап-4 и ще бъдат част от ECMAScript 2018.

1. Споделена памет и атома

Това е огромна, доста усъвършенствана функция и е основното подобрение на JS двигателите.

Основната идея е да се въведе някаква мулти-резбова функция в JavaScript, така че разработчиците на JS да могат да пишат високоефективни, едновременни програми в бъдеще, като позволяват сами да управляват паметта, вместо да позволяват на JS engine да управлява паметта.

Това се прави от нов тип глобален обект, наречен SharedArrayBuffer, който по същество съхранява данни в споделено пространство на паметта. Така че тези данни могат да бъдат споделени между основната нишка на JS и нишките на уеб работници.

Досега, ако искаме да споделим данни между основната нишка на JS и работниците в мрежата, трябваше да копираме данните и да ги изпратим на другия поток, използвайки postMessage. Вече не!

Просто използвате SharedArrayBuffer и данните са достъпни незабавно както от основната нишка, така и от множество нишки на уеб работници.

Но споделянето на памет между нишките може да доведе до расови условия. За да се избегнат условията на състезанието, се въвежда глобалният обект „Atomics“. Atomics предоставя различни методи за заключване на споделената памет, когато нишка използва своите данни. Той също така предоставя методи за безопасно актуализиране на тези данни в тази споделена памет.

Препоръката е да използвате тази функция чрез някаква библиотека, но в момента няма библиотеки, изградени върху тази функция.

Ако се интересувате, препоръчвам ви да прочетете:

  1. От работници до споделена памет - lucasfcosta
  2. Въведение в карикатурата на SharedArrayBuffers - Лин Кларк
  3. Споделена памет и атоми - д-р Аксел Раушмайер

2. Отместеното буквално ограничение на шаблона е отстранено

Първо, трябва да изясним какво представлява „Tagged Template Literal“, за да можем да разберем по-добре тази функция.

В ES2015 + има функция, наречена литерален шаблон с етикет, който позволява на разработчиците да персонализират как низовете са интерполирани. Например, по стандартния начин низовете се интерполират като по-долу ...

В маркирания литерал можете да напишете функция за получаване на твърдо кодирани части от низовия литерал, например ['Здравей', '!'], И променливите за подмяна, например ['Raja'], като параметри в персонализирана функция (например поздрав) и върнете каквото искате от тази персонализирана функция.

Примерът по-долу показва, че нашата персонализирана функция „Tag“ поздравява добавянето на времето от деня като „Добро утро!“ „Добър ден“ и така нататък в зависимост от времето на деня към буквалния низ и връща персонализиран низ.

Пример за функция на маркери, който показва интерполация на персонализиран низ
// Функция "Tag" връща персонализиран буквен буквал.
// В този пример поздравете timeGreet (), за да добавите Good // Сутрин / Следобед / Вечер в зависимост от времето на деня.
функция поздрав (hardCodedPartsArray, ... замянаPartsArray) {
 console.log (hardCodedPartsArray); //[ 'Здравейте ', '!' ]
 console.log (replacementPartsArray); // [„Раджа“]
нека str = '';
 hardCodedPartsArray.forEach ((string, i) => {
  ако (i 
// Usage:
const firstName = 'Раджа';
const поздрави = поздрав`Здравейте $ {firstName}! `; //  <- Маркиран буквал
console.log (поздрави); // 'Здравей Раджа! Добро утро!' 
функция timeGreet () {
 const hr = нова дата (). getHours ();
 върнете hr <12
  ? 'Добро утро!'
  : hr <18? 'Добър ден!' : 'Добър вечер!';
}

Сега, когато обсъдихме какви са функциите „Tagged“, много хора искат да използват тази функция в различни домейни, например в Terminal за команди и HTTP заявки за съставяне на URI и така нататък.

Problem Проблемът с Tagged Stral literal

Проблемът е, че спецификациите ES2015 и ES2016 не позволяват използването на символи за бягство като „\ u“ (unicode), „\ x“ (шестнадесетичен), освен ако не изглеждат точно като „\ u00A9“ или \ u {2F804} или \ xA9.

Така че, ако имате функция Tagged, която вътрешно използва някои други правила на домейна (като правилата на терминала), може да се наложи да използвате \ ubla123abla, който не прилича на \ u0049 или \ u {@ F804}, тогава ще получите грешка в синтаксиса ,

В ES2018 правилата са отпуснати, за да позволят такива на пръв поглед невалидни символи за бягство, стига функцията Tagged да връща стойностите в обект със „готвено“ свойство (където невалидните знаци са „неопределени“), а след това и „сурово“ свойство ( с каквото искате).

функция myTagFunc (str) {
 return {"cook": "undefined", "raw": str.raw [0]}
}

var str = myTagFunc `hi \ ubla123abla`; // извикайте myTagFunc

str // {cook: "undefined", raw: "hi \\ unicode"}

3. флаг „dotall“ за регулярно изразяване

Понастоящем в RegEx, въпреки че точката (".") Трябва да съвпада с един знак, тя не съвпада с нови символи на линия като \ n \ r \ f и т.н.

Например:

//Преди
/first.second/.test('first\nsecond '); // фалшив

Това подобрение позволява на оператора на точки да съвпада с всеки един символ. За да гарантираме, че това не нарушава нищо, трябва да използваме знака \, когато създаваме RegEx, за да работи това.

// ECMAScript 2018
/first.second/s.test('first\nsecond '); // вярно известие: / s 

Ето цялостния API от документа за предложения:

ECMAScript 2018 - Функцията Regex dotAll позволява съвпадение дори \ n чрез „.“ Чрез / с флаг

4. RegExp Named Group Caps

Това подобрение носи полезна функция на RegExp от други езици като Python, Java и т. Нар. „Наименовани групи.“ Тази функция позволява на разработчиците да пишат RegExp да предоставят имена (идентификатори) във формат (? <Име> ...) за различни части на групата в RegExp. След това те могат да използват това име, за да вземат с лекота всяка група, от която се нуждаят.

4.1 Основен пример на именуваната група

В примера по-долу ние използваме (? <Година>) (? <Месец>) и (? <Ден>) имена, за да групираме различни части от датата RegEx. Полученият обект вече ще съдържа свойство на групи със свойства година, месец и ден със съответните стойности.

ECMAScript 2018 - Пример за групите, посочени от Regex

4.2 Използване на групите с имена вътре в самия регекс

Можем да използваме формат \ k <име на група>, за да върнем групата в самия регекс. Следващият пример показва как работи.

ECMAScript 2018 - Regex назовава групите обратно препратки чрез \ k <име на група>

4.3 Използване на именувани групи в String.prototype.replace

Функцията с име на група вече е включена в метода на String за заместване на екземпляр. Така че лесно можем да разменяме думи в низ.

Например, променете „firstName, lastName“ на „lastName, firstName“.

ECMAScript 2018 - Използване на именатите групи на RegEx във функцията за замяна

5. Свойства за почивка на обекти

Оператор за почивка ... (три точки) ни позволява да извлечем свойства на обекта, които вече не са извлечени.

5.1 Можете да използвате почивка, за да помогнете да извлечете само свойства, които искате

ECMAScript 2018 - Разрушаване на обекти чрез покой

5.2 Още по-добре можете да премахнете нежеланите елементи!

ECMAScript 2018 - Разрушаване на обекти чрез покой

6. Разпространете свойства за обекти

Спред свойствата също изглеждат като свойства за почивка с три точки ... но разликата е, че използвате спред за създаване (преструктуриране) на нови обекти.

Съвет: операторът на разпространение се използва в дясната страна на знака за равенство. Останалите се използват в лявата част на знака за равенство.
ECMAScript 2018 - Преструктуриране на обекти чрез спред

7. RegExp Lookbehind твърденията

Това е подобрение на RegEx, което ни позволява да гарантираме, че някакъв низ съществува непосредствено * преди * някой друг низ.

Вече можете да използвате група (? <= ...) (въпросителна, по-малка от, равна), за да търсите за положително твърдение.

Освен това, можете да използвате (?

Положително твърдение: Нека кажем, че искаме да гарантираме, че знакът # съществува преди думата победа (тоест: #winning) и искаме реджексът да върне само низа „печеливш“. Ето как ще го напишете

ECMAScript 2018 - (? <=…) За положително твърдение

Отрицателно твърдение: Нека кажем, че искаме да извлечем числа от редове, които имат знаци €, а не знаци $ преди тези числа.

ECMAScript 2018 - (? <!…) За отрицателни твърдения

8. RegExp Unicode Property Escapes

Не беше лесно да напишете RegEx, за да съответства на различни символи unicode. Неща като \ w, \ W, \ d и т.н. съответстват само на английски символи и цифри. Но какво да кажем за числата на други езици като хинди, гръцки и т.н.?

Точно там влизат Escapes на свойствата на Unicode. Оказва се, че Unicode добавя свойства на метаданни за всеки символ (символ) и го използва за групиране или характеризиране на различни символи.

Например базата данни на Unicode групира всички символи на хинди (हिन्दी) под свойство, наречено Script със стойност Devanagari и друго свойство, наречено Script_Extensions със същата стойност Devanagari. Така че можем да търсим Script = Devanagari и да вземем всички символи на хинди.

Devanagari може да се използва за различни индийски езици като маратхи, хинди, санскрит и т.н.

Започвайки от ECMAScript 2018, можем да използваме \ p, за да избягаме от символи, заедно с {Script = Devanagari}, за да съпоставим всички тези индийски знаци. Тоест, можем да използваме: \ p {Script = Devanagari} в RegEx, за да съответстваме на всички символи на Devanagari.

ECMAScript 2018 - показва се \ p
// Следващите съвпадат с множество хинди символи
/ ^ \ Р {Script = деванагари} + $ / u.test ( "हिन्दी '); //вярно
// PS: има 3 хинди знака h

По подобен начин базата данни на Unicode групира всички гръцки знаци под свойството Script_Extensions (и Script) със стойността гръцки. Така че можем да търсим всички гръцки знаци, използвайки Script_Extensions = гръцки или скрипт = гръцки.

Тоест, можем да използваме: \ p {Script = Greek} в RegEx, за да съпоставим всички гръцки знаци.

ECMAScript 2018 - показва се \ p
// Следващите съвпадат с един гръцки символ
/\p{Script_Extensions=Greek}/u.test('π '); // вярно

Освен това базата данни Unicode съхранява различни видове Emojis под булевите свойства Emoji, Emoji_Component, Emoji_Presentation, Emoji_Modifier и Emoji_Modifier_Base със стойности на свойствата като "true". Така че можем да търсим всички Emojis, като просто изберем Emoji за истина.

Тоест, можем да използваме: \ p {Emoji}, \ Emoji_Modifier и така нататък, за да съпоставим различни видове Emojis.

Следващият пример ще изясни всичко.

ECMAScript 2018 - показва как \ p може да се използва за различни емоджи
// Следното съвпада с символ на Emoji
/\p{Emoji}/u.test(' '); //вярно
// Следното се проваля, тъй като жълтите емоджи не се нуждаят / имат Emoji_Modifier!
/\p{Emoji}\p{Emoji_Modifier}/u.test('️ '); // фалшив
// Следващото съвпада с символ на емоджи \ p {Emoji}, последвано от \ p {Emoji_Modifier}
/\p{Emoji}\p{Emoji_Modifier}/u.test(' '); //вярно
// обяснение:
// По подразбиране емоджита за победа е жълт цвят.
// Ако използваме кафяво, черно или други вариации на едни и същи емоджи, те се считат
// като вариации на оригиналния Emoji и са представени с помощта на два unicode знака.
// Едно за оригиналните емоджи, последвано от друг знак за unicode за цвета.
//
// И така, в примера по-долу, въпреки че виждаме само един кафяв емоджи за победа,
// всъщност използва два unicode знака, един за емоджи и друг
// за кафявия цвят.
//
// В базата данни на Unicode тези цветове имат свойство Emoji_Modifier.
// Значи трябва да използваме както \ p {Emoji}, така и \ p {Emoji_Modifier} правилно и
// напълно съвпадат с кафявите емоджи.
/\p{Emoji}\p{Emoji_Modifier}/u.test(' '); //вярно

И накрая, можем да използваме главен символ "P" (\ P) за бягство вместо малък p (\ p), за да отменим съвпаденията.

Препратки:

  1. Предложение за ECMAScript 2018
  2. https://mathiasbynens.be/notes/es-unicode-property-escapes

8. Promise.prototype.finally ()

накрая () е нов метод на инстанция, който беше добавен към Promise. Основната идея е да се разреши пускането на обратно повикване след разрешаване или отхвърляне, за да се помогне да се изчистят нещата. Окончателният обратно извикване се извиква без никаква стойност и винаги се изпълнява независимо от всичко.

Нека разгледаме различни случаи.

ECMAScript 2018 - най-накрая () в решаващ случайECMAScript 2018 - накрая () в случай на отхвърлянеECMASCript 2018 - най-накрая () в Грешка, хвърлена от случая PromiseECMAScript 2018 - Грешка, хвърлена в рамките на случай ** улов **

9. Асинхронна итерация

Това е * изключително * полезна функция. По принцип той ни позволява да създаваме бримки на асинхронния код с лекота!

Тази функция добавя нов цикъл „за чакане на”, който ни позволява да извикваме асинхронни функции, които връщат обещания (или масиви с куп обещания) в цикъл. Готиното е, че цикълът чака всяко обещание да се разреши, преди да премине към следващия цикъл.

ECMAScript 2018 - Async Iterator чрез за чакане

Това е почти всичко!

Ако това е полезно, моля, щракнете върху бутона p p няколко пъти надолу, за да покажете вашата подкрепа! ⬇⬇⬇

Моите други публикации

https://medium.com/@rajaraodv/latest

Свързани публикации на ECMAScript 2015+

  1. Вижте тези полезни съвети и трикове на ECMAScript 2015 (ES6)
  2. 5 JavaScript "лоши" части, които са фиксирани в ES6
  3. „Клас“ в ES6 Новата „лоша“ част?