Íme néhány példa az ECMAScript 2016, 2017 és 2018 újdonságaira

Nehéz nyomon követni, hogy mi az új a JavaScript-ben (ECMAScript). És még nehezebb találni hasznos kódpéldákat.

Tehát ebben a cikkben a TC39 végleges javaslataiban felsorolt ​​mind a 18 funkciót lefedi, amelyeket az ES2016, az ES2017 és az ES2018 (végleges tervezet) adtak hozzá, és hasznos példákkal mutatom be azokat.

Ez egy nagyon hosszú üzenet, de könnyen olvashatónak kell lennie. Gondolj erre mint „Netflix túlzott olvasásra”. Végül ígérem, hogy rengeteg ismerete lesz mindezen szolgáltatásokról.

Oké, menjünk át ezeket egyenként.

1. A tömb.prototípus tartalmazza

A include egy egyszerű példány módszer a tömbön, és segít könnyen megtalálni, ha egy elem a tömbben van (beleértve a NaN-t, az indexOf-től eltérően).

ECMAScript 2016 vagy ES7 - Array.prototype.includes ()
Trivia: A JavaScript-specifikus emberek meg akarták nevezni, hogy tartalmazza. De ezt nyilvánvalóan a Mootools már használta, így ezek tartalmazzák.

2. Exponentációs infix operátor

Az olyan matematikai műveletek, mint az összeadás és kivonás, olyan infix operátorokkal rendelkeznek, mint a + és -, illetve. Nekik hasonlóan a ** infix operátort általában használják exponenciális műveletekhez. Az ECMAScript 2016-ban a ** a Math.pow helyett került bevezetésre.

ECMAScript 2016 vagy ES7 - ** Exponent infix operátor

1. Object.values ​​()

Az Object.values ​​() egy olyan új funkció, amely hasonló az Object.keys () -hez, de visszaadja az Object saját tulajdonságainak minden értékét, kizárva minden értéket a prototípusos láncban.

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

2. Object.entries ()

Az Object.entries () az Object.keys-hez kapcsolódik, de a kulcsok visszaadása helyett tömb módon adja vissza a kulcsokat és az értékeket. Ez nagyon egyszerűvé teszi a dolgok elvégzését, például objektumok hurokban történő felhasználását vagy objektumok térképpé konvertálását.

1. példa:

ECMAScript 2017 (ES8) - Az Object.entries () használata hurokban

2. példa:

ECMAScript 2017 (ES8) - Az Object.entries () használata az objektum térképpé konvertálásához

3. Karakterlánc-párnázat

Két példánymódszert adtak a karakterlánchoz - String.prototype.padStart és String.prototype.padEnd -, amelyek lehetővé teszik, hogy üres karakterláncot vagy más karakterláncot hozzáfűzzenek / előtegyenek az eredeti karakterlánc elejére vagy végére.

'someString'.padStart (numberOfCharcters [, stringForPadding]);
'5'.padStart (10) //' 5 '
'5'.padStart (10,' = * ') //' = * = * = * = * = 5 '
'5'.padEnd (10) //' 5 '
'5'.padEnd (10,' = * ') //' 5 = * = * = * = * = '
Ez akkor hasznos, ha a dolgokat olyan helyzetekben akarjuk igazítani, mint például a szép nyomtatás vagy terminál nyomtatás.

3.1 PadStart példa:

Az alábbi példában különböző hosszúságú számok listája található. Azt szeretnénk feltölteni, hogy „0” legyen, hogy minden elem azonos hosszúságú legyen, tíz számjeggyel a megjelenítés céljából. Ezt a padStart (10, '0') segítségével könnyen elérhetjük.

ECMAScript 2017 - padStart példa

3.2 padEnd példa:

A padEnd nagyon hasznos, ha többféle hosszúságú elemet nyomtatunk, és szeretnénk megfelelően igazítani őket.

Az alábbi példa egy jó reális példa arra, hogy a padEnd, a PadStart és az Object.entries hogyan jönnek létre egy szép kimeneti eredmény létrehozására.

ECMAScript 2017 - padEnd, padStart és Object.Entries példa
const autók = {
  „MBMW”: „10”,
  „EsTesla”: „5”,
  „Lamborghini”: „0”
}
Object.entries (autók) .map (([név, szám]) => {
  // padEnd add - '-' mindaddig, amíg a név 20 karaktergé nem válik
  // padStart '0' -t tölt fel, amíg a szám 3 karaktergé nem válik.
  console.log (`$ {name.padEnd (20, '-')} gróf: $ {count.padStart (3, '0')}))
});
// Kiírja ..
// MBMW - - - - - - - Szám: 010
// esTesla - - - - - - Szám: 005
// Lamborghini - - - Szám: 000

3.3 pad️ padStart és padEnd hangulatjelekön és más kétbájtos karaktereken

A hangulatjelek és más kétbájtos karakterek ábrázolása több bájt unicode használatával történik. Tehát a padStart és a PadEnd nem működik a várt módon!

Például: Tegyük fel, hogy megpróbáljuk meghúzni a húr szívét, hogy elérje a 10 karaktert az hangulatjel segítségével. Az eredmény az alábbiak szerint néz ki:

// Figyelem: 5 szív helyett csak 2 szív és 1 szív van, amelyek furcsának néznek ki!
'heart'.padStart (10, ); // nyomtat .. '❤heart'

Ennek oka az, hogy 2 kódpont hosszú ('\ u2764 \ uFE0F')! Maga a szív szó 5 karakterből áll, tehát összesen 5 karakter van hátra. Mi történik tehát, hogy a JS két színt „\ u2764 \ uFE0F” felhasználásával párnáz, és eredményt produkál. Az utóbbihoz csak a szív első byte-ját használja, amely 27-t hoz létre

Tehát végül: ❤szív

PS: Ezt a linket használhatja az unicode char-konverziók ellenőrzésére.

4. Object.getOwnPropertyDescriptors

Ez a módszer visszaadja az összes objektum összes tulajdonságának részleteit (beleértve a getter getand setter set metódusokat). Ennek fő motivációja az, hogy lehetővé tegyük egy objektum sekély másolását / klónozását egy másik objektumba, amely szintén másolja a getter és a setter funkciókat, szemben az Object.assign-nal.

Az Object.assign sekély másolja az összes részletet, kivéve az eredeti forrásobjektum getter és setter funkcióit.

Az alábbi példa bemutatja az Object.assign és az Object.getOwnPropertyDescriptors, valamint az Object.defineProperties közötti különbséget az eredeti objektum-autó új objektumba másolásához. Látni fogja, hogy az Object.getOwnPropertyDescriptors használatával a kedvezmény-összegyűjtő és a beállító funkciók is átmásolódnak a célobjektumba.

ELŐTT…

Előtt - Az Object.assign használata

UTÁN…

ECMAScript 2017 (ES8) - Object.getOwnPropertyDescriptors
var Car = {
 név: „BMW”,
 ár: 1000000,
 meghatározott kedvezmény (x) {
  this.d = x;
 },
 kedvezményt kap () {
  vissza ezt.d;
 },
};
// Az autóobjektum kedvezményes tulajdonságainak kinyomtatása
console.log (Object.getOwnPropertyDescriptor (autó, 'kedvezmény'));
// azt írja ki ..
// {
// get: [Function: get],
// set: [Function: set],
// felsorolható: igaz,
// konfigurálható: igaz
//}
// Másolja át az autó tulajdonságait az ElectricCar-ba az Object.assign használatával
const ElectricCar = Object.assign ({}, autó);
// Az ElectricCar objektum „kedvezményes” tulajdonságának részleteinek kinyomtatása
console.log (Object.getOwnPropertyDescriptor (ElectricCar, 'kedvezmény'));
// azt írja ki ..
// {
// érték: meghatározatlan,
// írható: igaz,
// felsorolható: igaz,
// konfigurálható: igaz
  
//}
// Vegye figyelembe, hogy a getternek és a setternek hiányoznak az ElectricCar objektumban a 'kedvezményes' ingatlanhoz! 
// Másolja a Car tulajdonságait az ElectricCar2-re az Object.defineProperties használatával
// és az Object.getOwnPropertyDescriptors használatával bontsa ki az autó tulajdonságait
const ElectricCar2 = Object.defineProperties ({}, Object.getOwnPropertyDescriptors (Car));
// Az ElectricCar2 objektum „kedvezményes” tulajdonságának részleteinek kinyomtatása
console.log (Object.getOwnPropertyDescriptor (ElectricCar2, 'kedvezmény'));
// azt írja ki ..
// {get: [Function: get], 
// set: [Function: set], 
// felsorolható: igaz,
// konfigurálható: igaz
//}
// Felhívjuk figyelmét, hogy getter és setter jelen vannak az ElectricCar2 objektumban 'kedvezményes' tulajdonságért!

5. Adjon hozzá egy záró vesszőt a funkcióparaméterekhez

Ez egy kisebb frissítés, amely lehetővé teszi számunkra, hogy az utolsó funkcióparaméter után vesszővel rendelkezzünk. Miért? Az olyan eszközök támogatása, mint például a git blame, annak biztosítása érdekében, hogy csak az új fejlesztőket hibázzák.

Az alábbi példa bemutatja a problémát és a megoldást.

ECMAScript 2017 (ES 8) - Végső vessző a paraméterben
Megjegyzés: Funkciókat is hívhat hátsó vesszőkkel!

6. Async / várj

Ez messze a legfontosabb és leghasznosabb funkció, ha kérdezel tőlem. Az Async funkciók lehetővé teszik, hogy ne foglalkozzunk a visszahívási pokollal, és az egész kód egyszerűnek tűnjön.

Az async kulcsszó azt mondja a JavaScript fordítónak, hogy a funkciót eltérően kezelje. A fordító szünetet tart, amikor eléri az adott funkción belül a várakozási kulcsszót. Feltételezi, hogy a várakozás utáni kifejezés visszatér ígéretet, és vár tovább, amíg az ígéret meg nem oldódik vagy elutasításra kerül, mielőtt továbbmozdulna.

Az alábbi példában a getAmount függvény két aszinkron függvényt hív fel: getUser és getBankBalance. Megtehetjük ezt ígéretesen, de az async használata elegánsabb és egyszerűbb.

ECMAScript 2017 (ES 8) - Async Várjon alapvető példát

6.1 Az Async funkciók maguk adják meg az ígéretét.

Ha az async függvény eredményeire vár, akkor az Promise szintaxisát kell használnia az eredmény rögzítéséhez.

A következő példában szeretnénk naplózni az eredményt a console.log használatával, de nem a doubleAndAdd alatt. Tehát várni szeretnénk, majd a szintaxist használva továbbíthatjuk az eredményt a console.log fájlra.

ECMAScript 2017 (ES 8) - Az Async Await maguk visszaküldi az ígéretét

6.2 Az async hívása párhuzamosan vár

Az előző példában kétszer várunk, de minden alkalommal egy másodpercre várunk (összesen 2 másodperc). Ehelyett párhuzamosíthatjuk, mivel az Promise.all használatával a és b nem függenek egymástól.

ECMAScript 2017 (ES 8) - Az Promise.all használata az aszinkronizáláshoz / várakozáshoz

6.3 Hiba az async / vár funkciók kezelésekor

A hibák kezelésére különféle módok vannak, amikor az async vár.

1. lehetőség - Használja a próbálkozás funkciót a funkción belül

ECMAScript 2017 - Használja a try catch funkciót az async / várni funkción belül
// 1. opció - Használja a try catch funkciót
async function doubleAndAdd (a, b) {
 próbálja meg {
  a = várjon doubleAfter1Sec (a);
  b = várjon doubleAfter1Sec (b);
 } fogás (e) {
  visszatér NaN; // adj vissza valamit
 }
visszatér a + b;
}
// Usage:
doubleAndAdd ('egy', 2). majd (console.log); // NaN
doubleAndAdd (1, 2) .then (console.log); // 6
doubleAfter1Sec (param) funkció {
 új ígéret visszaadása ((megoldás, elutasítás) => {
  setTimeout (function () {
   legyen val = param * 2;
   isNaN (val)? elutasítás (NaN): feloldás (val);
  }, 1000);
 });
}

2. opció - Fogjon meg minden várakozási kifejezést

Mivel minden várakozó kifejezés ígérettel jár, minden hibán hibákat észlelhet az alábbiak szerint.

ECMAScript 2017 - Használd a próbáld ki a fogást minden várható kifejezést
// 2. lehetőség - * Catch * hibák minden várakozási sorban
// mivel minden kifejezésre váró kifejezés önmagában ígéret
async function doubleAndAdd (a, b) {
 a = várjon doubleAfter1Sec (a) .catch-t (e => console.log ('' a 'NaN')); // 
 b = várjon doubleAfter1Sec (b) .catch-t (e => console.log ('' b 'NaN')); // 
 if (! a ||! b) {
  visszatér NaN;
 }
 visszatér a + b;
}
// Usage:
doubleAndAdd ('egy', 2). majd (console.log); // NaN és naplók: az "a" NaN
doubleAndAdd (1, 2) .then (console.log); // 6
doubleAfter1Sec (param) funkció {
 új ígéret visszaadása ((megoldás, elutasítás) => {
  setTimeout (function () {
   legyen val = param * 2;
   isNaN (val)? elutasítás (NaN): feloldás (val);
  }, 1000);
 });
}

3. lehetőség - Fogja be a teljes aszinkronizálás funkciót

ECMAScript 2017 - Fogja be a teljes async funkciót / várja meg a funkciót a végén
// 3. opció - Csak a funkción kívül szabad kezdeni
// mivel az async / wait vár egy ígérettel, visszatérhetjük a teljes függvény hibáját
async function doubleAndAdd (a, b) {
 a = várjon doubleAfter1Sec (a);
 b = várjon doubleAfter1Sec (b);
 visszatér a + b;
}
// Usage:
doubleAndAdd ('egy', 2)
.és (console.log)
.catch (console.log); //  <------- használja a "catch"
doubleAfter1Sec (param) funkció {
 új ígéret visszaadása ((megoldás, elutasítás) => {
  setTimeout (function () {
   legyen val = param * 2;
   isNaN (val)? elutasítás (NaN): feloldás (val);
  }, 1000);
 });
}
Az ECMAScript jelenleg a végleges tervezetben van, és 2018. júniusban vagy júliusban áll rendelkezésre. Az összes, az alább felsorolt ​​szolgáltatás a 4. szakaszban van, és az ECMAScript 2018 részét képezi.

1. Közös memória és atomok

Ez egy hatalmas, nagyon fejlett funkció, és a JS motorok alapvető fejlesztése.

A fő ötlet az, hogy valamilyen többszálú funkciót hozzon a JavaScript-be, hogy a JS fejlesztői a jövőben nagy teljesítményű, párhuzamos programokat írhassanak, lehetővé téve a memória kezelését, ahelyett, hogy a JS motor kezelné a memóriát.

Ezt egy új típusú, a SharedArrayBuffer nevű globális objektum végzi, amely lényegében az adatokat megosztott memóriaterületen tárolja. Tehát ezeket az adatokat meg lehet osztani a fő JS szál és a web-worker szálak között.

Mostanáig, ha adatot szeretnénk megosztani a fő JS szál és a webes dolgozók között, akkor az adatokat lemásolni és a postMessage segítségével el kellett küldeni a másik szálra. Többé nem!

Egyszerűen a SharedArrayBuffer programot használja, és az adatok azonnal hozzáférhetők mind a fő szál, mind a több webes munkavállalói szál számára.

A memória megosztása a szálak között versenyfeltételeket okozhat. A verseny körülményeinek elkerülése érdekében bevezették az „Atomics” globális objektumot. Az Atomics különféle módszereket kínál a megosztott memória zárolására, amikor egy szál az adatait használja. Ezenkívül módszereket biztosít az ilyen adatok biztonságos frissítésére a megosztott memóriában.

Javasoljuk, hogy ezt a funkciót valamilyen könyvtáron keresztül használja, de jelenleg nincsenek a szolgáltatás tetejére épített könyvtárak.

Ha érdekli, javaslom olvasni:

  1. A munkavállalóktól a megosztott memóriáig - lucasfcosta
  2. Rajzfilm bevezetés a SharedArrayBuffers-be - Lin Clark
  3. Közös memória és atom - Dr. Axel Rauschmayer

2. A címkézett sablon szó szerinti korlátozása eltávolítva

Először tisztáznunk kell, hogy mi a „Címkézett sablon literál”, hogy jobban megértsük ezt a funkciót.

Az ES2015 + rendszerben van egy címkézett sablon literálnak nevezett szolgáltatás, amely lehetővé teszi a fejlesztők számára, hogy testreszabják a vonóságok interpolációját. Például a szokásos módon a húrokat az alábbiak szerint interpolálják:

A címkézett literálban meg lehet írni egy függvényt, amely a karakterlánc szöveges formátumú részeit, például ['Hello', '!'], És a pótló változókat, például ['Raja'] paramétereket kap egy paraméterré egy egyéni függvényt (például köszöntést), és térjen vissza az elvégzett funkcióhoz.

Az alábbi példa azt mutatja, hogy az egyéni „Címke” funkció üdvözletünk a napszakot hozzákapcsolja, mint például: „Jó reggelt!” „Jó napot”, és így a napi időtől függően a karakterláncba, és egyéni karakterláncot ad vissza.

Példa a címkefunkcióra, amely az egyéni karakterlánc-interpolációt mutatja
// A "Tag" függvény egyéni karakterláncot ad vissza.
// Ebben a példában a greet felhívja a timeGreet () hívást a jó hozzáadásához // Reggel / Délután / Este, a napi időtől függően.
funkció üdvözlet (hardCodedPartsArray, ... cserePartsArray) {
 console.log (hardCodedPartsArray); //[ 'Szia ', '!' ]
 console.log (replacementPartsArray); // ['Raja']
legyen str = '';
 hardCodedPartsArray.forEach ((string, i) => {
  if (i 
// Usage:
const firstName = 'Raja';
const greetings = Üdvözlet `Üdvözlet $ {firstName}! '; //  <- Címkézett literál
console.log (üdvözlet); // 'Hello Raja! Jó reggelt kívánok!' 
funkció timeGreet () {
 const hr = új dátum (). getHours ();
 visszatérési óra <12
  ? 'Jó reggelt kívánok!'
  : óra <18? 'Jó napot!' : 'Jó estét!';
}

Most, hogy megvitattuk, mi a „címkézett” funkció, sok ember ezt a funkciót különféle tartományokban akarja használni, például a Terminálon parancsokhoz és HTTP kérésekhez URI-k összeállításához stb.

A probléma a Címkézett karakterlánc szóval

A probléma az, hogy az ES2015 és az ES2016 specifikációk nem engedik elmenekülési karakterek használatát, mint például „\ u” (unicode), „\ x” (hexadecimális), kivéve, ha pontosan úgy néznek ki, mint „\ u00A9” vagy \ u {2F804} vagy \ xA9.

Tehát ha rendelkezik egy Címkézett funkcióval, amely belsőleg más domain szabályokat használ (például a Terminál szabályait), akkor lehet, hogy használnia kell a \ ubla123abla fájlt, amely nem néz ki \ u0049 vagy \ u {@ F804}, akkor szintaxis hibát kap .

Az ES2018-ban a szabályokat enyhítik az ilyen látszólag érvénytelen menekülési karakterek engedélyezéséig, feltéve, hogy a Címkézett funkció az objektumok értékeit egy „főtt” tulajdonsággal (ahol az érvénytelen karakterek „meghatározatlanok”) adják, majd egy „nyers” tulajdonsággal ( bármi, amit akarsz).

funkció myTagFunc (str) {
 visszatérés {"főtt": "meghatározatlan", "nyers": str.raw [0]}
}

var str = myTagFunc `hi \ ubla123abla`; // hívja a myTagFunc-t

str // {főtt: "meghatározatlan", nyers: "hi \\ unicode"}

3. A „dotall” jelző a reguláris kifejezéshez

Jelenleg a RegExben, bár a pont (".") Állítólag egy karakternek felel meg, nem felel meg az új sor karaktereknek, például \ n \ r \ f stb.

Például:

//Előtt
/first.second/.test('first\nsecond '); //hamis

Ez a továbbfejlesztés lehetővé teszi, hogy a pontkezelő bármilyen karakterhez illeszkedjen. Annak biztosítása érdekében, hogy ez semmit sem szakítson meg, a \ s zászlót kell használni, amikor a RegEx-et létrehozjuk ennek működéséhez.

// ECMAScript 2018
/first.second/s.test('first\nsecond '); // igaz közlemény: / s 

Itt található a javaslat API átfogó API-ja:

ECMAScript 2018 - A Regex dotAll funkció lehetővé teszi a \ n „.” Jel / s jelzőn keresztüli illesztését is

4. A RegExp nevű csoport rögzíti

Ez a továbbfejlesztés hasznos RegExp funkciót kínál más nyelvektől, például Python, Java és így tovább, úgynevezett „Named Groups”. Ez a szolgáltatás lehetővé teszi, hogy a RegExp-t író fejlesztők nevek (azonosítók) formátumban (? ...) biztosítsák a különböző alkatrészeket. a csoport a RegExp-ben. Ezt követően használhatják ezt a nevet, hogy megragadják a kívánt csoportot könnyedén.

4.1 Alapvető elnevezett csoportpélda

Az alábbi példában a (? <év>) (? ) és (? ) neveket használjuk a RegEx dátum különböző részeinek csoportosítására. A kapott objektum egy csoporttulajdont fog tartalmazni, amelynek tulajdonságai év, hónap és nap vannak a megfelelő értékekkel.

ECMAScript 2018 - Regex nevű csoportpélda

4.2 Az elnevezett csoportok használata a regexben

A \ k formátumot használhatjuk arra, hogy maga a regex-ben visszatérjen a csoportra. A következő példa bemutatja, hogyan működik.

ECMAScript 2018 - A Regex elnevezte a csoportok visszajelzését \ k <csoportnév> segítségével

4.3 Megnevezett csoportok használata a String.prototype.replace könyvtárban

Az elnevezett csoportfunkció most bekerült a String helyettesítő példány módszerébe. Tehát könnyen cserélhetjük a szavakat a karakterláncban.

Például váltson az „firstName, lastName” értékre „lastName, firstName” értékre.

ECMAScript 2018 - A RegEx által megnevezett csoportfunkció használata helyettesítő funkcióban

5. Az objektumok pihenő tulajdonságai

Pihenő operátor ... (három pont) lehetővé teszi a még nem kibontott objektumtulajdonságok kibontását.

5.1 A többi felhasználásával csak a kívánt tulajdonságokat lehet kibontani

ECMAScript 2018 - Az objektum megsemmisítése pihenés útján

5.2 Még jobb, ha eltávolíthatja a nem kívánt elemeket!

ECMAScript 2018 - Az objektum megsemmisítése pihenés útján

6. Az objektumok tulajdonságainak terjesztése

A szórási tulajdonságok ugyanúgy néznek ki, mint a három ponttal rendelkező pihenő tulajdonságok ... de a különbség az, hogy a szórást új objektumok létrehozására (átszervezésére) használja.

Tipp: a szóráskezelőt az egyenlőségjel jobb oldalán kell használni. A többit az egyenlőségjel bal oldalán használjuk.
ECMAScript 2018 - Objektumok átalakítása elterjedés révén

7. A RegExp kijelentések állítása

Ez a RegEx fejlesztése, amely lehetővé teszi számunkra, hogy biztosítsuk, hogy egy karakterlánc létezzen * közvetlenül * más karakterlánc előtt *.

Most már használhat egy csoportot (? <=…) (Kérdőjel kevesebb, mint egyenlő) a pozitív állítás mögött való megjelenéshez.

Ezenkívül a (?

Pozitív állítás: Tegyük fel, hogy meg akarjuk győződni arról, hogy a # jel létezik a győztes szó előtt (vagyis: #winning), és azt akarjuk, hogy a regex csak a „nyerő” karakterláncot adja vissza. Így írhatod meg.

ECMAScript 2018 - (? <=…) Pozitív állításra

Negatív állítás: Tegyük fel, hogy számokat szeretnénk kinyerni azokból a sorokból, amelyeknél € jelek vannak, nem pedig $ jelek azok előtt.

ECMAScript 2018 - (? <!…) Negatív állításokra

8. A RegExp Unicode tulajdonság menekül

Nem volt könnyű RegEx-et írni, hogy megfeleljen a különböző unicode karaktereknek. A \ w, \ W, \ d stb. Dolgok csak az angol karakterekkel és számokkal egyeznek. De mi lenne a számokkal más nyelveken, például hindi, görög és így tovább?

Itt jön be a Unicode Property Escape. Kiderül, hogy az Unicode hozzáadja metaadat-tulajdonságait minden szimbólumhoz (karakterhez), és különféle szimbólumok csoportosítására vagy jellemzésére használja.

Például az Unicode adatbázis összes hindi karaktert (हिन्हिन) a Script nevű tulajdonság alá csoportosít Devanagari értékkel és egy másik Script_Extensions nevû tulajdonság alá, azonos értékû Devanagari értékkel. Tehát kereshetünk a Script = Devanagari elemre, és beolvashatjuk az összes Hindi karaktert.

A devanagari különféle indiai nyelvekre használható, például marathi, hindi, szanszkrit és így tovább.

Az ECMAScript 2018-tól kezdődően \ p segítségével karaktereket tudunk elmenekülni, a {Script = Devanagari} mellett, hogy megfeleljenek az összes indiai karakternek. Vagyis használhatjuk: \ p {Script = Devanagari} -ot a RegEx-ben az összes Devanagari-karakter illesztéséhez.

ECMAScript 2018 - megjelenítve
// Az alábbiak megegyeznek több hindi karakterrel
/ ^ \ P {Script = dévanágari} + $ / u.test ( 'हिन्दी'); //igaz
// PS: van 3 hindi karakter

Hasonlóképpen, a Unicode adatbázis az összes görög karaktert a Script_Extensions (és a Script) tulajdonság alatt görög értékkel csoportosítja. Tehát minden görög karaktert kereshetünk a Script_Extensions = görög vagy a Script = görög segítségével.

Vagyis használhatjuk: \ p {Script = Greek} a RegEx-ben az összes görög karakter illesztésére.

ECMAScript 2018 - megjelenítve
// Az alábbiakban egy görög karakter található
/\p{Script_Extensions=Greek}/u.test('π '); // igaz

Ezenkívül az Unicode adatbázis különféle típusú hangulatjeleket tárol az Emoji, Emoji_Component, Emoji_Presentation, Emoji_Modifier és Emoji_Modifier_Base logikai tulajdonságok alatt, tulajdonságértékekkel "true". Tehát az összes hangulatjelet kereshetjük úgy, hogy egyszerűen kiválasztjuk a hangulatjeleket, hogy igazak legyenek.

Vagyis a következőket használhatjuk: \ p {Emoji}, \ Emoji_Modifier és így tovább, hogy megfeleljenek a különféle hangulatjeleknek.

A következő példa egyértelművé teszi.

ECMAScript 2018 - megmutatja, hogyan lehet felhasználni különféle hangulatjelekhez
// Az alábbiakban szereplő hangulatjel-karakter megegyezik
/\p{Emoji}/u.test(' '); //igaz
// A következő nem sikerül, mert a sárga hangulatjeleknek nincs szükségük / rendelkezniük kell Emoji_Modifier-rel!
/\p{Emoji}\p{Emoji_Modifier}/u.test('️ '); //hamis
// Az alábbiakban egy hangulatjel-karakter egyezik meg \ p {Emoji}, ezt követi \ p {Emoji_Modifier}
/\p{Emoji}\p{Emoji_Modifier}/u.test(' '); //igaz
// explaination:
// Alapértelmezés szerint a győzelem hangulatjele sárga színű.
// Ha ugyanazon hangulatjelek barna, fekete vagy más változatát használjuk, akkor ezeket figyelembe vesszük
// az eredeti hangulatjel változataiként, és két unicode karakter használatával ábrázolva.
// Az egyik az eredeti hangulatjelhez, majd egy másik unicode karakter a színhez.
//
// Tehát az alábbi példában, bár csak egyetlen barna győzelem hangulatjelet látunk,
// valójában két unicode karaktert használ, az egyik a hangulatjelekhez és a másik
// a barna színre.
//
// Az Unicode adatbázisban ezeknek a színeknek Emoji_Modifier tulajdonsága van.
// Tehát a \ p {Emoji} és a \ p {Emoji_Modifier} elemeket is megfelelő módon kell használni
// teljes mértékben megfeleljen a barna hangulatjeleknek.
/\p{Emoji}\p{Emoji_Modifier}/u.test(' '); //igaz

Végül használhatjuk a „P” (\ P) nagybetűs karaktert a kicsi p (\ p) helyett a mérkőzések érvénytelenítéséhez.

Irodalom:

  1. ECMAScript 2018 javaslat
  2. https://mathiasbynens.be/notes/es-unicode-property-escapes

8. Promise.prototype.finally ()

végül () egy új példány módszer, amelyet hozzáadtak az ígérethez. A fő ötlet az, hogy engedélyezze a visszahívást, miután megoldott vagy elutasított, hogy megtisztítsák a dolgokat. A végső visszahívást érték nélkül hívjuk, és bármilyen módon végrehajtjuk.

Nézzük meg különféle eseteket.

ECMAScript 2018 - végül () megoldási ügybenECMAScript 2018 - végül () elutasító esetbenECMASCript 2018 - végül () hibába dobva az ígéret ügyébőlECMAScript 2018 - Hiba történt a ** fogás ** esetéből

9. Aszinkron megismételés

Ez egy * rendkívül * hasznos szolgáltatás. Alapvetően lehetővé teszi számunkra, hogy könnyedén hozzunk létre aszinkód-kód hurkokat!

Ez a szolgáltatás új „várjon” hurkot ad hozzá, amely lehetővé teszi, hogy hívjuk az aszinkron függvényeket, amelyek visszatérő ígéreteket (vagy tömböt egy csomó ígérettel) hurokban. A hűvös dolog az, hogy a hurok megvárja, amíg minden ígéret feloldódik, mielőtt a következő hurokba kezdené.

ECMAScript 2018 - Async Iterator a várakozás előtt

Nagyon jó ez!

Ha ez hasznos volt, kérjük, kattintson néhányszor a lent c gombra a lent c gombra, hogy megmutassa támogatását! ⬇⬇⬇

Egyéb hozzászólásaim

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

Kapcsolódó ECMAScript 2015+ hozzászólások

  1. Nézze meg ezeket a hasznos ECMAScript 2015 (ES6) tippeket és trükköket
  2. 5 JavaScript „Rossz” alkatrészek, amelyek rögzítve vannak az ES6-ban
  3. Az ES6 „osztály” az új „rossz” rész?