TypeScript eng yaxshi amaliyotlari — Iteratsiya, va’dalar va baholash

TypeScript - bu JavaScript kengaytmasini o'rganish oson. Ishlaydigan va biror narsa qiladigan dasturlarni yozish oson. Biroq, barcha foydalanish holatlarini hisobga olish va mustahkam TypeScript kodini yozish qiyin.

Ushbu maqolada biz TypeScript bilan kod yozishda amal qilish kerak bo'lgan eng yaxshi amaliyotlarni, jumladan, for-in tsikllarini yaxshiroq alternativalar bilan almashtirishni ko'rib chiqamiz.

Va'da kodi ham foydali bo'lishi kerak.

baholashga o'xshash usullardan ham foydalanmaslik kerak.

For-in tsikli bo'lgan massivda iteratsiya yo'q

For-in sikli unchalik foydali emas, chunki for-of sikllari va obyekt kalitlarini olish usullari mavjud.

Bundan tashqari, u ob'ektimizning prototiplarini takrorlaydi, biz buni xohlamasligimiz mumkin.

Takrorlash tartibi ham kafolatlanmaydi.

Shuning uchun biz uni kodimizda ishlatmasligimiz kerak.

Yozish o'rniga:

for (const x in [1, 2, 3]) {
  console.log(x);
}

Biz yozamiz:

for (const x of [1, 2, 3]) {
  console.log(x);
}

For-in tsikli indekslar ustida, for-of sikli esa yozuvlar ustida ishlaydi.

Eval kabi usullardan foydalanmang

JavaScript-da va kengaytmali TypeScript-da ikkalasida ham satrlarni qabul qiladigan va ularni kod sifatida ishga tushiradigan usullar mavjud.

Satrdan kodni boshqaradigan eval usuli mavjud.

Function konstruktori qatordan funksiyani ham qaytaradi.

Shuningdek, setTimeout va setInterval funktsiyalari ikkalasi ham satrdan kodni ishga tushirishi mumkin.

Bu kod satrda bo'lgani uchun har qanday optimallashtirishni amalga oshirishga to'sqinlik qiladi.

Bundan tashqari, u katta xavfsizlik kamchiligini keltirib chiqaradi, chunki har kim kod bilan satrni kiritishi va uni ishga tushirishi mumkin.

Shuning uchun biz stringdan kodni ishga tushirishga imkon beradigan biron bir funktsiyani ishga tushirmasligimiz kerak.

Agar biz setTimeout yoki setInterval dan foydalansak, satr o'rniga qayta qo'ng'iroq qilishimiz kerak.

Masalan, yozish o'rniga:

setTimeout('alert(`foo`);', 100);

or:

const add = new Function('a', 'b', 'return a + b');

Biz yozamiz:

setTimeout(() => {
  alert(`foo`);
}, 100);

or:

setInterval(() => {
  alert(`foo`);
}, 10000);

va boshqa funksiyalardan foydalanmang.

O'zgaruvchilar yoki parametrlar uchun aniq turdagi deklaratsiyalar yo'q. Raqam, satr yoki mantiqiy qiymatga boshlang

Raqam, satr yoki mantiqiy aniq tayinlangan har qanday narsa uchun bizga turlar kerak emas.

Buning sababi, koddan ularning nima ekanligi aniq.

Shuning uchun yozish o'rniga:

const a: number = 10;

Biz yozamiz:

const a = 10;

Bu string yoki mantiqiy kabi boshqa har qanday ibtidoiy qiymatlar uchun amal qiladi.

Qaytish turi aniq bo'lsa, biz tur izohini ham o'tkazib yuborishimiz mumkin.

Shunday qilib, yozish o'rniga:

const a: number = Number('1');

Biz yozamiz:

const a = Number('1');

Bu regexlar uchun ham amal qiladi. Agar bizda regex literal bo'lsa, biz izohga muhtoj emasmiz.

Yozish o'rniga:

const a: RegExp = /foo/;

Biz yozamiz:

const a = /foo/;

Valid Ways da new va constructor dan foydalaning

Biz new va constructor dan to'g'ri yo'llar bilan foydalanishimiz kerak.

Shuning uchun biz ularni yangi sinf misollarini yaratish uchun yoki mos ravishda konstruktor funktsiyalari sifatida ishlatmasligimiz kerak.

Masalan, yozish o'rniga:

class C {
  new(): C;
}

Biz yozamiz:

class C {
  constructor(){
    //...
  }
}
const c = new C();

Konstruktorlar faqat sinflarda bo'lishi kerak.

new ni interfeyslarda imzo sifatida ham belgilashimiz mumkin:

interface I {
  new (): C;
}

Va'dalarni bajarish uchun mo'ljallanmagan joylarda foydalanmang

Biz va'dalarni bajarish uchun mo'ljallanmagan joylarda ishlatmasligimiz kerak.

Masalan, biz ularni if ibora yoki tsiklga qo'ymasligimiz kerak.

Shunday qilib, yozish o'rniga:

const promise = Promise.resolve('foo');

if (promise) {
  // Do something
}

or:

const promise = Promise.resolve('foo');

while (promise) {
  // Do something
}

or:

[1, 2, 3].forEach(async value => {
  await foo(value);
});

or:

new Promise(async (resolve, reject) => {
  await doSomething();
  resolve();
});

Biz yozishimiz kerak:

const promise = Promise.resolve('foo');

if (await promise) {
  // Do something
}

or:

const promise = Promise.resolve('foo');
while (await promise) {
  // Do something
}

or:

for (const value of [1, 2, 3]) {
  await foo(value);
}

Biz hal qilingan qiymatni to'g'ri olishimiz uchun await ni to'g'ri joylarga qo'yishimiz kerak.

Bundan tashqari, quyidagilar haqiqiy emas:

new Promise(async (resolve, reject) => {
  await doSomething();
  resolve();
});

chunki va'da ichida va'da bo'lish ortiqcha.

Biz await doSomething() ni va'da qilingan qayta qo'ng'iroqdan tashqariga ko'chirishimiz mumkin.

Xulosa

Va'dalar foydali tarzda ishlatilishi kerak yoki ularni umuman ishlatmaslik kerak.

baholashga o'xshash funktsiyalardan foydalanmaslik kerak, chunki ular xavfli.

for-in looplari yaxshiroq alternativlar bilan almashtirilishi kerak.