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

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

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

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

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

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', 'esTesla': '5', 'amLamborghini': '0'}
Object.entries (автомобили) .map (([име, брой]) => {// padEnd добавя '-', докато името стане 20 знака // padStart предвещава '0', докато броят стане 3 знака. Console.log ( `$ {name.padEnd (20, '-')} Брой: $ {count.padStart (3, '0')}`)});
// Разпечатки .. // BMW - - - - - - - Брой: 010 // Tesla - - - - - - Брой: 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
var Car = {име: 'BMW', цена: 1000000, задайте отстъпка (x) {this.d = x; }, вземете отстъпка () {върнете това.d; },};
// Разпечатайте подробности за свойството "отстъпка" на обекта за автомобил console.log (Object.getOwnPropertyDescriptor (Автомобил, "отстъпка")); // разпечатки .. // {// get: [Функция: get], // set: [Функция: set], // изброяване: true, // конфигурируем: true //}
// Копирайте свойствата на автомобила в ElectricCar с помощта на Object.assign const ElectricCar = Object.assign ({}, Car);
// Отпечатване на подробности за свойството "отстъпка" на свойството ElectricCar console.log (Object.getOwnPropertyDescriptor (ElectricCar, "отстъпка")); // разпечатки .. // {// стойност: неопределена, // записваща: вярна, // изброяваща: вярна, // конфигурируема: вярна //} // Съобщение, че гетърите и сетерите липсват в обекта на ElectricCar за 'отстъпка „собственост!“
// Копирайте свойствата на Car в ElectricCar2 с помощта на Object.defineProperties // и извличайте свойствата на Car, използвайки Object.getOwnPropertyDescriptors const ElectricCar2 = Object.defineProperties ({}, Object.getOwnPropertyDescriptors (Car));
// Отпечатване на подробности за свойството „отстъпка“ на свойството ElectricCar2 console.log (Object.getOwnPropertyDescriptor (ElectricCar2, „отстъпка“)); // отпечатки .. // {get: [Функция: get],  // set: [Функция: set],  // изброяване: true, // конфигурируем: 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 чакайте сами връщат Promise

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; } // Използване: doubleAndAdd ('one', 2) .then (console.log); // NaN doubleAndAdd (1, 2) .then (console.log); // 6
функция doubleAfter1Sec (парам) {връщане на ново Promise ((разрешаване, отхвърляне) => {setTimeout (функция () {let val = param * 2; isNaN (val)? отхвърляне (NaN): решимост (val);}, 1000) ;}); }

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

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

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

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

ECMAScript 2017 - Хванете цялата функция за асинхронизация / изчакване в края
// Вариант 3 - Не правете нищо, освен да се справите извън функцията // тъй като async / await връща обещание, можем да хванем грешката на цялата функция async функция doubleAndAdd (a, b) {a = изчакайте doubleAfter1Sec (a); b = изчакайте doubleAfter1Sec (b); върнете a + b; }
// Използване: doubleAndAdd ('one', 2) .then (console.log) .catch (console.log); //  <------- използвайте "улов"
функция doubleAfter1Sec (парам) {връщане на ново Promise ((разрешаване, отхвърляне) => {setTimeout (функция () {let 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 + има функция, наречена литерален шаблон с етикет, който позволява на разработчиците да персонализират как низовете са интерполирани. Например, по стандартния начин низовете се интерполират като по-долу ...

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

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

Пример за функция на маркери, който показва интерполация на персонализиран низ
// Функция "Tag" връща персонализиран буквен буквал. // В този пример поздравете call timeGreet (), за да добавите Good // Сутрин / Следобед / Вечер в зависимост от времето на деня.
функция поздрав (hardCodedPartsArray, ... замянаPartsArray) {console.log (hardCodedPartsArray); //[ 'Здравейте ', '!' ] console.log (substituPartsArray); // [„Раджа“]
нека str = ''; hardCodedPartsArray.forEach ((string, i) => {if (i 
// Използване: const firstName = 'Raja'; const поздрави = поздрав`Здравейте $ {firstName}! `; //  <- Маркиран буквал
console.log (поздрави); // 'Здравей Раджа! Добро утро!' 
функция timeGreet () {const hr = new Date (). 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 '); // фалшив

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

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

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

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

4. RegExp Named Group Caps

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

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

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

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

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

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

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

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
// Следващите съвпадат с множество хинди символи / ^ \ p {Script = Devanagari} + $ / u.test ('हिन्दी'); // true // 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 чрез за чакане

Това е доста!

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

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

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

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

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