JavaScript Pipeline Operatori va Tiplarni Avtomatik Aniqlash: Funksiyalar Zanjirida Tiplar Xavfsizligini Chuqur O'rganish

Zamonaviy dasturiy ta'minotni ishlab chiqish olamida toza, o'qilishi oson va qo'llab-quvvatlanadigan kod yozish shunchaki eng yaxshi amaliyot emas; bu turli vaqt zonalarida va madaniyatlarda hamkorlik qilayotgan global jamoalar uchun zaruratdir. JavaScript, vebning lingua franca'si sifatida, ushbu talablarga javob berish uchun doimiy ravishda rivojlanib bormoqda. Tilga kutilayotgan eng muhim qo'shimchalardan biri bu Pipeline Operator (|>) bo'lib, u funksiyalarni kompozitsiya qilish usulimizni tubdan o'zgartirishni va'da qiladi.

Pipeline operatori haqidagi ko'plab muhokamalar uning estetik va o'qilish afzalliklariga qaratilgan bo'lsa-da, uning eng chuqur ta'siri keng ko'lamli ilovalar uchun muhim bo'lgan sohada yotadi: tip xavfsizligi. TypeScript kabi statik tip tekshiruvchisi bilan birlashtirilganda, pipeline operatori ma'lumotlarning bir qator transformatsiyalar orqali to'g'ri oqishini ta'minlash uchun kuchli vositaga aylanadi va kompilyator xatolarni ishlab chiqarishga yetib bormasdanoq aniqlaydi. Ushbu maqola pipeline operatori va tiplarni avtomatik aniqlash o'rtasidagi simbiotik munosabatni chuqur tahlil qiladi, bu dasturchilarga murakkab, ammo ajoyib darajada xavfsiz funksiya zanjirlarini yaratishga qanday imkon berishini o'rganadi.

Pipeline Operatorini Tushunish: Tartibsizlikdan Aniqlikka

Uning tip xavfsizligiga ta'sirini baholashdan oldin, biz avvalo pipeline operatori hal qiladigan muammoni tushunishimiz kerak. U dasturlashdagi keng tarqalgan naqshni hal qiladi: bir qiymatni olib, unga bir qator funksiyalarni qo'llash, bunda bir funksiyaning natijasi keyingisining kirish ma'lumotiga aylanadi.

Muammo: Funksiya Chaqiruvlaridagi 'Halokat Piramidasi'

Oddiy ma'lumotlarni o'zgartirish vazifasini ko'rib chiqaylik. Bizda foydalanuvchi obyekti bor va biz uning ismini olib, uni katta harflarga o'tkazib, so'ngra bo'sh joylarni olib tashlamoqchimiz. Oddiy JavaScript'da siz buni quyidagicha yozishingiz mumkin:

            const user = { firstName: '  johnny ', lastName: 'appleseed' };

function getFirstName(person) {
  return person.firstName;
}

function toUpperCase(text) {
  return text.toUpperCase();
}

function trim(text) {
  return text.trim();
}

// Ichma-ich yondashuv
const result = trim(toUpperCase(getFirstName(user)));

console.log(result); // "JOHNNY"

            

              
                Copy
              
            
          

Bu kod ishlaydi, lekin uning o'qilishida jiddiy muammo bor. Operatsiyalar ketma-ketligini tushunish uchun siz uni ichkaridan tashqariga qarab o'qishingiz kerak: avval `getFirstName`, keyin `toUpperCase`, so'ngra `trim`. Transformatsiyalar soni ortib borishi bilan bu ichma-ich joylashgan tuzilmani tahlil qilish, nosozliklarni tuzatish va qo'llab-quvvatlash tobora qiyinlashib boradi - bu naqsh ko'pincha 'halokat piramidasi' yoki 'ichma-ich do'zax' deb ataladi.

Yechim: Pipeline Operatoridan Foydalangan Holda Chiziqli Yondashuv

Hozirda TC39 (JavaScript-ni standartlashtiruvchi qo'mita) da 2-bosqich taklifi bo'lgan pipeline operatori oqlangan, chiziqli muqobilni taklif etadi. U o'zining chap tomonidagi qiymatni olib, uni o'ng tomonidagi funksiyaga argument sifatida uzatadi.

Oldinga siljigan versiya bo'lgan F# uslubidagi taklifdan foydalanib, avvalgi misolni quyidagicha qayta yozish mumkin:

            // Pipeline yondashuvi
const result = user 
  |> getFirstName 
  |> toUpperCase 
  |> trim;

console.log(result); // "JOHNNY"

            

              
                Copy
              
            
          

Farq juda katta. Kod endi chapdan o'ngga tabiiy ravishda o'qiladi va ma'lumotlarning haqiqiy oqimini aks ettiradi. `user` `getFirstName` ga yuboriladi, uning natijasi `toUpperCase` ga yuboriladi va bu natija `trim` ga yuboriladi. Bu chiziqli, qadamma-qadam tuzilma nafaqat o'qish uchun osonroq, balki keyinchalik ko'rib chiqadiganimizdek, nosozliklarni tuzatish uchun ham ancha osonroqdir.

Raqobatdosh Takliflar Haqida Eslatma

Tarixiy va texnik kontekst uchun shuni ta'kidlash joizki, pipeline operatori uchun ikkita asosiy taklif mavjud edi:

• F# uslubi (sodda): Bu taklif keng tarqalgan va hozirda 2-bosqichda. x |> f ifodasi f(x) ning to'g'ridan-to'g'ri ekvivalenti. Bu sodda, bashorat qilinadigan va bir argumentli funksiyalar kompozitsiyasi uchun a'lo darajada.
Smart Mix (Mavzu Havolasi Bilan): Bu taklif yanada moslashuvchan bo'lib, yuborilayotgan qiymatni ifodalash uchun maxsus belgini (masalan, # yoki ^) kiritgan. Bu value |> Math.max(10, #) kabi murakkabroq operatsiyalarga imkon berardi. Kuchli bo'lishiga qaramay, uning qo'shimcha murakkabligi standartlashtirish uchun soddaroq F# uslubi afzal ko'rilishiga olib keldi.

Ushbu maqolaning qolgan qismida biz F# uslubidagi pipeline'ga e'tibor qaratamiz, chunki u JavaScript standartiga kiritilishi eng ehtimol bo'lgan nomzoddir.

O'yinni O'zgartiruvchi Omil: Tiplarni Avtomatik Aniqlash va Statik Tip Xavfsizligi

O'qilishi osonligi ajoyib afzallik, lekin pipeline operatorining haqiqiy kuchi TypeScript kabi statik tip tizimini kiritganingizda ochiladi. U vizual jihatdan yoqimli sintaksisni xatolarsiz ma'lumotlarni qayta ishlash zanjirlarini yaratish uchun mustahkam asosga aylantiradi.

Tiplarni Avtomatik Aniqlash Nima? Tezkor Eslatma

Tiplarni avtomatik aniqlash - bu ko'plab statik tiplangan tillarning xususiyati bo'lib, unda kompilyator yoki tip tekshiruvchi dasturchi uni aniq yozmasdan turib, ifodaning ma'lumot turini avtomatik ravishda aniqlay oladi. Masalan, TypeScript'da siz const name = "Alice"; deb yozsangiz, kompilyator `name` o'zgaruvchisining turi `string` ekanligini aniqlaydi.

An'anaviy Funksiya Zanjirlarida Tip Xavfsizligi

Tip xavfsizligi u yerda qanday ishlashini ko'rish uchun asl ichma-ich misolimizga TypeScript tiplarini qo'shaylik. Avval biz o'z tiplarimizni va tiplangan funksiyalarimizni aniqlaymiz:

            interface User {
  id: number;
  firstName: string;
  lastName: string;
}

const user: User = { id: 1, firstName: '  clara ', lastName: 'oswald' };

const getFirstName = (person: User): string => person.firstName;

const toUpperCase = (text: string): string => text.toUpperCase();

const trim = (text: string): string => text.trim();

// TypeScript 'result'ning tipini 'string' ekanligini to'g'ri aniqlaydi
const result: string = trim(toUpperCase(getFirstName(user)));

            

              
                Copy
              
            
          

Bu yerda TypeScript to'liq tip xavfsizligini ta'minlaydi. U quyidagilarni tekshiradi:

1. getFirstName `User` interfeysiga mos keladigan argument qabul qiladi.
2. getFirstName ning qaytariladigan qiymati (`string`) `toUpperCase` ning kutilgan kirish turiga (`string`) mos keladi.
3. toUpperCase ning qaytariladigan qiymati (`string`) `trim` ning kutilgan kirish turiga (`string`) mos keladi.

Agar biz xatoga yo'l qo'ysak, masalan, butun `user` obyektini `toUpperCase` ga uzatishga harakat qilsak, TypeScript darhol xatolikni belgilaydi: toUpperCase(user) // Xato: 'User' turidagi argument 'string' turidagi parametrga tayinlanmaydi.

Pipeline Operatori Tiplarni Avtomatik Aniqlashni Qanday Kuchaytiradi

Endi, ushbu tiplangan muhitda pipeline operatoridan foydalansak nima bo'lishini ko'rib chiqaylik. Garchi TypeScript hali operator sintaksisini tabiiy ravishda qo'llab-quvvatlamasa-da, kodni transpilyatsiya qilish uchun Babel'dan foydalanadigan zamonaviy ishlab chiqish sozlamalari TypeScript tekshiruvchisiga uni to'g'ri tahlil qilish imkonini beradi.

            // Babel pipeline operatorini transpilyatsiya qiladigan sozlamani tasavvur qiling

const finalResult: string = user
  |> getFirstName   // Kirish: User, Chiqish 'string' deb aniqlandi
  |> toUpperCase    // Kirish: string, Chiqish 'string' deb aniqlandi
  |> trim;           // Kirish: string, Chiqish 'string' deb aniqlandi

            

              
                Copy
              
            
          

Sehrgarlik aynan shu yerda sodir bo'ladi. TypeScript kompilyatori ma'lumotlar oqimini biz kodni o'qiyotgandek kuzatib boradi:

1. U `user` dan boshlaydi, uning turi `User` ekanligini biladi.
2. U `user` ning `getFirstName` ga yuborilayotganini ko'radi. `getFirstName` `User` turini qabul qila olishini tekshiradi. Qabul qila oladi. Keyin u bu birinchi qadam natijasini `getFirstName` ning qaytarish turi, ya'ni `string` deb aniqlaydi.
3. Bu aniqlangan `string` endi pipeline'ning keyingi bosqichi uchun kirish ma'lumotiga aylanadi. U `toUpperCase` ga yuboriladi. Kompilyator `toUpperCase` `string` ni qabul qilishini tekshiradi. Qabul qiladi. Bu bosqich natijasi `string` deb aniqlanadi.
4. Bu yangi `string` `trim` ga yuboriladi. Kompilyator tiplarning mosligini tekshiradi va butun pipeline'ning yakuniy natijasini `string` deb aniqlaydi.

Butun zanjir boshidan oxirigacha statik ravishda tekshiriladi. Biz ichma-ich versiya bilan bir xil darajadagi tip xavfsizligiga ega bo'lamiz, ammo ancha yuqori o'qilishi osonligi va dasturchi tajribasi bilan.

Xatolarni Erta Aniqlash: Tiplar Nomutanosibligining Amaliy Misoli

Ushbu tip xavfsiz zanjirning haqiqiy qiymati xato kiritilganda yaqqol namoyon bo'ladi. Keling, `number` qaytaradigan funksiya yarataylik va uni stringni qayta ishlash pipeline'imizga noto'g'ri joylashtiraylik.

            const getUserId = (person: User): number => person.id;

// Noto'g'ri pipeline
const invalidResult = user
  |> getFirstName   // OK: User -> string
  |> getUserId      // XATO! getUserId 'User' kutmoqda, lekin 'string' qabul qilmoqda
  |> toUpperCase;

            

              
                Copy
              
            
          

Bu yerda TypeScript darhol `getUserId` qatorida xatolik chiqaradi. Xabar kristaldek tiniq bo'ladi: 'string' turidagi argument 'User' turidagi parametrga tayinlanmaydi. Kompilyator `getFirstName` ning natijasi (`string`) `getUserId` uchun talab qilinadigan kirish ma'lumotiga (`User`) mos kelmasligini aniqladi.

Keling, boshqa bir xatoni sinab ko'raylik:

            const invalidResult2 = user
  |> getUserId      // OK: User -> number
  |> toUpperCase;    // XATO! toUpperCase 'string' kutmoqda, lekin 'number' qabul qilmoqda

            

              
                Copy
              
            
          

Bu holda, birinchi qadam to'g'ri. `user` obyekti `getUserId` ga to'g'ri uzatiladi va natija `number` bo'ladi. Biroq, keyin pipeline bu `number` ni `toUpperCase` ga uzatishga harakat qiladi. TypeScript buni darhol boshqa bir aniq xato bilan belgilaydi: 'number' turidagi argument 'string' turidagi parametrga tayinlanmaydi.

Bu zudlik bilan, mahalliy fikr-mulohaza bebaho. Pipeline sintaksisining chiziqli tabiati tiplarning nomutanosibligi aynan qayerda sodir bo'lganini, to'g'ridan-to'g'ri zanjirdagi nosozlik nuqtasida aniqlashni osonlashtiradi.

Murakkab Stsenariylar va Tip Xavfsiz Naqshlar

Pipeline operatori va uning tiplarni avtomatik aniqlash imkoniyatlarining afzalliklari oddiy, sinxron funksiya zanjirlaridan tashqariga chiqadi. Keling, yanada murakkab, real hayotiy stsenariylarni o'rganamiz.

Asinxron Funksiyalar va Promise'lar Bilan Ishlash

Ma'lumotlarni qayta ishlash ko'pincha API'dan ma'lumotlarni olish kabi asinxron operatsiyalarni o'z ichiga oladi. Keling, ba'zi asinxron funksiyalarni aniqlaylik:

            interface Post { id: number; userId: number; title: string; body: string; }

const fetchPost = async (id: number): Promise<Post> => {
  const response = await fetch(`https://jsonplaceholder.typicode.com/posts/${id}`);
  return response.json();
};

const getTitle = (post: Post): string => post.title;

// Biz 'async' kontekstda 'await' dan foydalanishimiz kerak
async function getPostTitle(id: number): Promise<string> {
  const post = await fetchPost(id);
  const title = getTitle(post);
  return title; 
}

            

              
                Copy
              
            
          

F# pipeline taklifida `await` uchun maxsus sintaksis mavjud emas. Biroq, siz hali ham uni `async` funksiyasi ichida ishlatishingiz mumkin. Asosiy narsa shundaki, Promise'larni yangi Promise'lar qaytaradigan funksiyalarga yuborish mumkin va TypeScript'ning tiplarni avtomatik aniqlash mexanizmi buni go'zal tarzda boshqaradi.

            const extractJson = <T>(res: Response): Promise<T> => res.json();

async function getPostTitlePipeline(id: number): Promise<string> {
  const url = `https://jsonplaceholder.typicode.com/posts/${id}`;

  const title = await (url
    |> fetch // fetch Promise<Response> qaytaradi
    |> p => p.then(extractJson<Post>) // .then Promise<Post> qaytaradi
    |> p => p.then(getTitle) // .then Promise<string> qaytaradi
  );

  return title;
}

            

              
                Copy
              
            
          

Ushbu misolda TypeScript Promise zanjirining har bir bosqichida tipni to'g'ri aniqlaydi. U `fetch` ning `Promise` qaytarishini, `p.then(extractJson)` ning uni `Promise` ga aylantirishini va `p.then(getTitle)` ning uni `Promise` ga aylantirishini biladi. Yakuniy `await` buni `string` ga ochadi. Butun pipeline asinxron chegaralar bo'ylab ham tip xavfsizligini saqlab qoladi.

Maksimal Kompozitsiya Uchun Currylash va Qisman Qo'llash

Funksional dasturlash currylash va qisman qo'llash kabi tushunchalarga qattiq tayanadi, ular pipeline operatori uchun juda mos keladi. Currylash - bu ko'p argumentli funksiyani har biri bitta argument qabul qiladigan funksiyalar ketma-ketligiga aylantirish jarayoni.

Kompozitsiya uchun mo'ljallangan umumiy `map` va `filter` funksiyalarini ko'rib chiqing:

            // Curry qilingan map funksiyasi: funksiya qabul qilib, massiv qabul qiladigan yangi funksiya qaytaradi
const map = <T, U>(fn: (item: T) => U) => (arr: T[]): U[] => arr.map(fn);

// Curry qilingan filter funksiyasi
const filter = <T>(predicate: (item: T) => boolean) => (arr: T[]): T[] => arr.filter(predicate);

const numbers: number[] = [1, 2, 3, 4, 5, 6];

// Qisman qo'llanilgan funksiyalarni yaratish
const double = map((n: number) => n * 2);
const isGreaterThanFive = filter((n: number) => n > 5);

const processedNumbers = numbers
  |> double               // TypeScript natijani number[] deb aniqlaydi
  |> isGreaterThanFive;   // TypeScript yakuniy natijani number[] deb aniqlaydi

console.log(processedNumbers); // [6, 8, 10, 12]

            

              
                Copy
              
            
          

Bu yerda TypeScript'ning avtomatik aniqlash mexanizmi o'zini namoyon etadi. U `double` funksiyasining turi `(arr: number[]) => number[]` ekanligini tushunadi. Unga `numbers` (`number[]`) yuborilganda, kompilyator tiplarning mos kelishini tasdiqlaydi va natijani ham `number[]` deb aniqlaydi. Bu natijaviy massiv keyin mos imzo bilan `isGreaterThanFive` ga yuboriladi va yakuniy natija to'g'ri `number[]` deb aniqlanadi. Bu naqsh sizga pipeline operatori yordamida istalgan tartibda tuzilishi mumkin bo'lgan qayta ishlatiladigan, tip xavfsiz ma'lumotlarni o'zgartirish 'Lego g'ishtlari' kutubxonasini yaratishga imkon beradi.

Kengroq Ta'sir: Dasturchi Tajribasi va Kodni Qo'llab-quvvatlash

Pipeline operatori va tiplarni avtomatik aniqlash o'rtasidagi sinergiya shunchaki xatolarning oldini olishdan tashqariga chiqadi; u butun ishlab chiqish jarayonini tubdan yaxshilaydi.

Nosozliklarni Tuzatish Osonlashtirildi

`c(b(a(x)))` kabi ichma-ich joylashgan funksiya chaqiruvini tuzatish asabiylashtirishi mumkin. `a` va `b` orasidagi oraliq qiymatni tekshirish uchun siz ifodani qismlarga bo'lishingiz kerak. Pipeline operatori bilan nosozliklarni tuzatish juda osonlashadi. Siz kodni qayta tuzmasdan zanjirning istalgan nuqtasiga loglash funksiyasini qo'shishingiz mumkin.

            // Nosozliklarni tuzatish uchun umumiy 'tap' yoki 'spy' funksiyasi
const tap = <T>(label: string) => (value: T): T => {
  console.log(`[${label}]:`, value);
  return value;
};

const result = user
  |> getFirstName
  |> tap('After getFirstName') // Qiymatni shu yerda tekshiring
  |> toUpperCase
  |> tap('After toUpperCase') // Va bu yerda
  |> trim;

            

              
                Copy
              
            
          

TypeScript-ning generiklari tufayli bizning `tap` funksiyamiz to'liq tip xavfsizdir. U `T` turidagi qiymatni qabul qiladi va xuddi shu `T` turidagi qiymatni qaytaradi. Bu shuni anglatadiki, uni tip zanjirini buzmasdan pipeline'ning istalgan joyiga kiritish mumkin. Kompilyator `tap` ning chiqishi uning kirishi bilan bir xil turga ega ekanligini tushunadi, shuning uchun tip ma'lumotlari oqimi uzluksiz davom etadi.

JavaScript'da Funksional Dasturlashga Kirish Yo'li

Ko'pgina dasturchilar uchun pipeline operatori funksional dasturlash tamoyillariga qulay kirish nuqtasi bo'lib xizmat qiladi. U tabiiy ravishda kichik, sof, yagona mas'uliyatli funksiyalarni yaratishga undaydi. Sof funksiya - bu qaytariladigan qiymati faqat kirish qiymatlari bilan aniqlanadigan, kuzatiladigan nojo'ya ta'sirlarsiz bo'lgan funksiya. Bunday funksiyalarni tushunish, alohida sinab ko'rish va loyiha bo'ylab qayta ishlatish osonroq - bularning barchasi mustahkam, kengaytiriladigan dasturiy ta'minot arxitekturasining belgilaridir.

Global Perspektiva: Boshqa Tillardan O'rganish

Pipeline operatori yangi ixtiro emas. Bu boshqa muvaffaqiyatli dasturlash tillari va muhitlaridan olingan, sinovdan o'tgan tushuncha. F#, Elixir va Julia kabi tillar uzoq vaqtdan beri o'z sintaksislarining asosiy qismi sifatida pipeline operatorini taqdim etishgan, u yerda u deklarativ va o'qilishi oson kodni targ'ib qilgani uchun maqtovga sazovor bo'lgan. Uning g'oyaviy ajdodi Unix pipe (`|`) bo'lib, butun dunyo bo'ylab tizim ma'murlari va dasturchilar tomonidan o'nlab yillar davomida buyruqlar satri vositalarini bir-biriga zanjirlash uchun ishlatilgan. Ushbu operatorning JavaScript'da qabul qilinishi uning isbotlangan foydaliligining dalili va turli ekotizimlar bo'ylab kuchli dasturlash paradigmalarini uyg'unlashtirish yo'lidagi qadamdir.

Pipeline Operatoridan Bugun Qanday Foydalanish Mumkin

Pipeline operatori hali ham TC39 taklifi bo'lgani va hech qanday rasmiy JavaScript dvigatelining bir qismi bo'lmagani uchun, uni bugungi loyihalaringizda ishlatish uchun sizga transpilyator kerak bo'ladi. Buning uchun eng keng tarqalgan vosita Babel hisoblanadi.

1. Babel Bilan Transpilyatsiya

Siz pipeline operatori uchun Babel plaginini o'rnatishingiz kerak bo'ladi. `'fsharp'` taklifini belgilashga ishonch hosil qiling, chunki aynan shu versiya oldinga siljimoqda.

Bog'liqlikni o'rnating:

            npm install --save-dev @babel/plugin-proposal-pipeline-operator
            

              
                Copy
              
            
          

Keyin, Babel sozlamalaringizni sozlang (masalan, `.babelrc.json` da):

            {
  "plugins": [
    ["@babel/plugin-proposal-pipeline-operator", { "proposal": "fsharp" }]
  ]
}

            

              
                Copy
              
            
          

2. TypeScript Bilan Integratsiya

TypeScript o'zi pipeline operatorining sintaksisini transpilyatsiya qilmaydi. Standart sozlama - tip tekshiruvi uchun TypeScript va transpilyatsiya uchun Babel'dan foydalanish.

1. Tip Tekshiruvi: Sizning kod muharriringiz (VS Code kabi) va TypeScript kompilyatori (tsc) kodingizni tahlil qiladi va xususiyat tabiiy bo'lgandek tipni avtomatik aniqlash va xatolarni tekshirishni ta'minlaydi. Bu tip xavfsizligidan bahramand bo'lish uchun hal qiluvchi qadamdir.
2. Transpilyatsiya: Sizning qurish jarayoningiz Babel'dan (`@babel/preset-typescript` va pipeline plaginidan foydalangan holda) avval TypeScript tiplarini olib tashlash, so'ngra pipeline sintaksisini har qanday brauzer yoki Node.js muhitida ishlay oladigan standart, mos JavaScript'ga aylantirish uchun foydalanadi.

Bu ikki bosqichli jarayon sizga ikkala dunyoning eng yaxshi tomonlarini beradi: mustahkam, statik tip xavfsizligi bilan eng zamonaviy til xususiyatlari.

Xulosa: JavaScript Kompozitsiyasi Uchun Tip Xavfsiz Kelajak

JavaScript Pipeline Operatori shunchaki sintaktik shakar emas. U kod yozishning yanada deklarativ, o'qilishi oson va qo'llab-quvvatlanadigan uslubiga o'tishni anglatadi. Biroq, uning haqiqiy salohiyati faqat TypeScript kabi kuchli tip tizimi bilan birgalikda to'liq ochiladi.

Funksiya kompozitsiyasi uchun chiziqli, intuitiv sintaksisni ta'minlash orqali pipeline operatori TypeScript'ning kuchli tipni avtomatik aniqlash mexanizmiga bir transformatsiyadan keyingisiga silliq oqib o'tish imkonini beradi. U ma'lumotlar sayohatining har bir qadamini tasdiqlaydi, tiplarning nomutanosibligi va mantiqiy xatolarni kompilyatsiya vaqtida aniqlaydi. Bu sinergiya butun dunyodagi dasturchilarga murakkab ma'lumotlarni qayta ishlash mantig'ini yangi ishonch bilan yaratish imkonini beradi, chunki ish vaqtida yuzaga keladigan xatolarning butun bir sinfi bartaraf etilganini bilishadi.

Taklif JavaScript tilining standart qismiga aylanish yo'lida davom etar ekan, uni bugun Babel kabi vositalar orqali qabul qilish kod sifati, dasturchi unumdorligi va eng muhimi, mustahkam tip xavfsizligiga qilingan istiqbolli sarmoyadir.