JavaScriptda Partial Application va Currying

JavaScript kengaytiriladigan til bo'lib, funksional dasturlashni o'z ichiga olgan bir necha dasturlash paradiqmalari qo'llab-quvvatlaydi. Funksional dasturlashdagi ikki muhim tushuncha - bu Partial Application va Currying. Ushbu texnikalar sizga kompleks operatsiyalarni kichik, qo'llanuvchilarga bo'linadigan qismlarga ajratish orqali ko'proq qamrovli va qayta ishlanadigan funksiyalar yaratishga imkon beradi.

Kirish

Qisman Qo'llash va Currying - bu JavaScript'da katta moslashuvchanlik va qayta foydalanish imkonini beruvchi ikkita kuchli funksional dasturlash usullaridir. Bu tushunchalar bir-biriga yaqin, lekin farqli bo'lib, ularni tushunish sizning toza, modulli va samarali kod yozish qobiliyatingizni sezilarli darajada oshirishi mumkin.

Qisman Qo'llash (Partial Application)

Qisman Qo'llash Nima?

Qisman Qo'llash - bu funksiyaga ma'lum miqdordagi argumentlarni belgilash va natijada kamroq argumentli boshqa funksiya hosil qilish jarayonidir. Boshqacha qilib aytganda, bu asl funksiyaning ba'zi argumentlarini oldindan to'ldirib, yangi funksiya yaratish usulidir.

Qisman Qo'llashni Amalga Oshirish

Keling, JavaScript'da qisman qo'llashni qanday amalga oshirishni ko'rib chiqaylik:

function qismanQollash(fn, ...args) {
  return function(...qolganArgs) {
    return fn(...args, ...qolganArgs);
  };
}

// Foydalanish misoli
function qoshish(a, b, c) {
  return a + b + c;
}

const beshQosh = qismanQollash(qoshish, 5);
console.log(beshQosh(10, 15)); // Natija: 30

const beshVaOnQosh = qismanQollash(qoshish, 5, 10);
console.log(beshVaOnQosh(15)); // Natija: 30

Bu misolda, qismanQollash - bu yuqori tartibli funksiya bo'lib, u funksiya va ba'zi boshlang'ich argumentlarni qabul qiladi va yangi funksiya qaytaradi. Bu yangi funksiya chaqirilganda, boshlang'ich argumentlarni yangi argumentlar bilan birlashtiradi va asl funksiyani chaqiradi.

Qisman Qo'llash Uchun Foydalanish Holatlari

1. Konfiguratsiya: Qisman qo'llash umumiy funksiyalarning sozlangan versiyalarini yaratish uchun foydalidir.

function malumotOlish(asosiyUrl, endpoint, id) {
  return fetch(`${asosiyUrl}/${endpoint}/${id}`);
}

const APIdanOlish = qismanQollash(malumotOlish, 'https://api.misol.com');
const foydalanuvchiOlish = APIdanOlish('foydalanuvchilar');

foydalanuvchiOlish(123).then(javob => console.log(javob));

2. Hodisalarni Boshqarish: Bu ko'pincha hodisa boshqaruvchisiga qo'shimcha ma'lumotlarni uzatish uchun ishlatiladi.

function bosilgandaBosqarish(foydalanuvchiId, hodisa) {
  console.log(`${foydalanuvchiId} foydalanuvchi bosdi`);
}

element.addEventListener('click', qismanQollash(bosilgandaBosqarish, 123));

Currying

Currying Nima?

Currying - bu bir nechta argumentlarni qabul qiladigan funksiyani har biri bitta argument qabul qiladigan funksiyalar ketma-ketligiga aylantirish usulidir. U matematik Haskell Curry sharafiga nomlangan.

Curryingni Amalga Oshirish

Mana JavaScript'da curryingning asosiy amalga oshirilishi:

function curry(fn) {
  return function curried(...args) {
    if (args.length >= fn.length) {
      return fn.apply(this, args);
    } else {
      return function(...qolganArgs) {
        return curried.apply(this, args.concat(qolganArgs));
      };
    }
  };
}

// Foydalanish misoli
function qoshish(a, b, c) {
  return a + b + c;
}

const curriedQoshish = curry(qoshish);
console.log(curriedQoshish(1)(2)(3)); // Natija: 6
console.log(curriedQoshish(1, 2)(3)); // Natija: 6
console.log(curriedQoshish(1)(2, 3)); // Natija: 6

Bu amalga oshirishda, curry asl funksiyani chaqirish uchun yetarli argumentlar to'planguncha argumentlarni yig'ib boradigan yangi funksiyani qaytaradi.

Currying Uchun Foydalanish Holatlari

1. Funksiya Kompozitsiyasi: Currying funksiyalarni birlashtirish (kompozitsiya qilish)ni osonlashtiradi.

const qoshish = curry((a, b) => a + b);
const kopaytirish = curry((a, b) => a * b);

const qoshKeynKopaytir = x => kopaytirish(2)(qoshish(x)(3));

console.log(qoshKeynKopaytir(5)); // Natija: 16

2. Ixtisoslashgan Funksiyalar Yaratish: Currying umumiy funksiyalardan yanada ixtisoslashgan funksiyalar yaratish imkonini beradi.

const filter = curry((predicate, array) => array.filter(predicate));

const juftlarniFilter = filter(x => x % 2 === 0);

console.log(juftlarniFilter([1, 2, 3, 4, 5, 6])); // Natija: [2, 4, 6]

Qisman Qo'llash va Currying O'rtasidagi Farqlar

Qisman qo'llash va currying funksiyalar bilan ishlash usullari bo'lsa-da, ular o'rtasida ba'zi muhim farqlar mavjud:

1. Argumentlar Soni: Qisman qo'llash kamroq argumentli funksiya hosil qiladi, currying esa har doim bir argumentli (unar) funksiyalar zanjirini hosil qiladi.
2. Moslashuvchanlik: Qisman qo'llash istalgan sondagi argumentlarni belgilash imkonini beradi, currying esa odatda chapdan o'ngga qarab, bir vaqtda bitta argumentni qabul qiladi.
3. Natija: Qisman qo'llash qolgan argumentlarni kutadigan funksiyani qaytaradi, currying esa keyingi argumentni kutadigan funksiyalar ketma-ketligini qaytaradi.

Ilg'or Usullar

1. O'rin Egallash Currying: Bu argumentlarni yanada moslashuvchan tartibda joylashtirish imkonini beradi.

const _ = Symbol('o'rin egallash');

function ilgorCurry(fn) {
  return function curried(...args) {
    const toliq = args.length >= fn.length && !args.slice(0, fn.length).includes(_);
    if (toliq) return fn.apply(this, args);
    return function(...yangiArgs) {
      const natija = args.map(arg => arg === _ ? yangiArgs.shift() : arg);
      return curried.apply(this, natija.concat(yangiArgs));
    };
  };
}

const kopaytirish = ilgorCurry((a, b, c) => a * b * c);
console.log(kopaytirish(_, 2)(_, 4)(3)); // Natija: 24

2. O'rin Egallash bilan Qisman Qo'llash: O'rin egallash curryingga o'xshash, lekin qisman qo'llash uchun.

function orinEgallashQismanQollash(fn, ...args) {
  return function(...qolganArgs) {
    const yangiArgs = args.map(arg => arg === _ ? qolganArgs.shift() : arg);
    return fn.apply(this, yangiArgs.concat(qolganArgs));
  };
}

const salomlashish = (salom, unvon, ism) => `${salom}, ${unvon} ${ism}!`;
const janobSalomlash = orinEgallashQismanQollash(salomlashish, 'Salom', 'Janob', _);
console.log(janobSalomlash('Aliyev')); // Natija: Salom, Janob Aliyev!

Ishlash Samaradorligi Mulohazalari

Qisman qo'llash va currying yanada moslashuvchan va qayta foydalanish mumkin bo'lgan kodga olib kelishi mumkin bo'lsa-da, ular qo'shimcha funksiya yopilmalari (closure) yaratilishi tufayli ishlash samaradorligiga ta'sir qilishi mumkin. Kodingizning ishlash samaradorligi muhim bo'lgan qismlarida, curried/qisman qo'llanilgan funksiyalarni ularning oddiy versiyalari bilan solishtirish va profillashtirish muhimdir.

const qoshish = (a, b, c) => a + b + c;
const curriedQoshish = curry(qoshish);

console.time('Oddiy funksiya');
for (let i = 0; i < 1000000; i++) {
  qoshish(1, 2, 3);
}
console.timeEnd('Oddiy funksiya');

console.time('Curried funksiya');
for (let i = 0; i < 1000000; i++) {
  curriedQoshish(1)(2)(3);
}
console.timeEnd('Curried funksiya');

Eng Yaxshi Amaliyotlar

1. Tavsiflovchi Nomlar Ishlatish: Qisman qo'llanilgan yoki curried funksiyalarni yaratishda ularning ixtisoslashgan maqsadini aniq tasvirlovchi nomlardan foydalaning.
2. O'qilishni Hisobga Olish: Bu usullar qisqa kodga olib kelishi mumkin bo'lsa-da, natijada olingan kod hali ham o'qilishi va saqlanishi oson bo'lishini ta'minlang.
3. Funksiyalaringizni Hujjatlashtiring: Qisman qo'llanilgan yoki curried funksiyalaringizning kutilgan argumentlari va xatti-harakatlarini aniq hujjatlashtiring.
4. TypeScript yoki JSDoc Ishlatish: Yaxshiroq tur tekshirish va avtomatik to'ldirish uchun TypeScript yoki JSDoc izohlaridan foydalanishni ko'rib chiqing.
5. 'this' Kontekstiga E'tibor Bering: Esda tutingki, o'q funksiyalari o'zlarining 'this' kontekstiga ega emas, bu esa ushbu usullarni metodlar bilan ishlatishda muhim bo'lishi mumkin.

Xulosa

Qisman Qo'llash va Currying - bu JavaScript'da yanada moslashuvchan, qayta foydalanish mumkin bo'lgan va ifodali kodga olib kelishi mumkin bo'lgan kuchli usullardir. Bu tushunchalarni tushunish va ularni oqilona qo'llash orqali siz yanada toza, modulli JavaScript yozishingiz mumkin. Biroq, ularni ishlatishni kod o'qilishi va ishlash samaradorligi bilan muvozanatlashtirish muhimdir. Har qanday ilg'or usul kabi, ularni kodingizga aniq foyda keltiradigan joylarda ishlatish muhimdir.