index.md

Functional programming

👉 Mavzuga oid havola

Functional programming - bu declarative programmming paradimn-lar sinfiga mansub bo'lib, dasturni pure funksiyalarga bo'lish orqali tuzishni ilgari suradi. Bu orqali kod tushunarli, boshqarishga oson, qayta ishlatsa bo'ladigan va testlashga oson bo'ladi. Functional programming-ning quyidagi konseptlari mavjud: immutability, pure functions, higher order functions, first-class functions, currying, recursion, composition, refercial transparency va boshqalar.

1. Immutability - bu dasturdagi data (object, array...)-larni o'zgartirmasdan ishlash. Bunda Array-lar bilan ishlaganda mutable obyektlardan iloji boricha qochiladi. Masalan:

   const numbers = [1, 2, 3, 4];
   const doubledNums = doubleNums(numbers);
   
   function doubleNums(nums) {
     return nums.map((num) => num + num);
   }

2. Pure va impure - qaytaradigan natijasi side effect-lardan xoli va har safar bir xil input-ga bir xil output qaytaradigan funksiyalar, impure esa teskarasi.

   let a = 1;
   let b = 2;
   function Plus(a, b) {
     return a + b;
   }
   Plus(a, b); // pure function
   
   function Minus() {
     return a - b;
   }
   Minus(); // impure function

   Side effect - funksiya tashqarisidan nimanidir ishlatish. Tashqari bilan to'g'ridan to'g'ri aloqa.

3. First-class functions (citizens) - bu variable-ga bersa bo'ladigan, argument sifatida bersa bo'ladigan, boshqa funksiyadan return qilsa bo'ladigan va property bersa saqlay oladigan funksiyalar (funksiya obyektlardek ishlay olishi).

   function Test() {
     return "Hello World!";
   }
   
   Test.name; // Test
   Test.newProp = "Goodbye World";
   Test.newProp; // Goodbye World

4. Higher order functions - bu argument sifatida funksiya oladigan yoki qaytaradigan funksiyalar. Misol, Array.prototype.map, Array.prototype.reduce va boshqalar.

   // argument sifatida funksiya oladigan
   [1, 2, 3].map((v) => v + 1);
   
   // funksiya qaytaradigan
   function A() {
     return function B() {
       return true;
     };
   }

5. Currying - funksiyalarni bir nechta qismlarga bo'lib, alohida-alohida argument berib chaqirish usuli. Masalan:

   add(1, 2, 3); // simple function
   add(1)(2)(3); // curried function
   
   function add(a) {
     return (b) => {
       return (c) => a + b + c;
     };
   }
   add(1)(2)(3); // 6

6. Recursion - Functional programming-da bir funksiya o'zini-o'zi chaqirishiga nisbatan aytiladi va bunday funksiyalar recursive function deyiladi. Masalan, ushbu 1 dan N songacha bo'lgan sonlar ko'paytmasini topish uchun recursion-dan foydalanib ko'ramiz.

   📢 P.S: Recursive funksiyalar dasturni ishlashiga yomon tasir qilishini inobatga olib, hamma joyda ham ishlatish tavsiya etilmaydi.

   function multiplyUpTo(num) {
     if (num === 1) return 1;
     return multiplyUpTo(num - 1) * num;
   }
   multiplyUpTo(4); // 24

7. Callback function - argument sifatida boshqa funksiyaga berilib, shu funksiya ichida chaqiriladigan funksiyalar callback funksiyalar deyiladi.

   function myFunc(cbFunc) {
     cbFunc();
   }
   
   myFunc(() => console.log("Callback function"));

8. Function Composition - bir data ustida natijaga yetguncha, funksiyalar ketma-ketligida Callback va Currying uslubidan foydalanib ishlashiga aytiladi.

   // Bread Slicing Function
   const sliceBread = (bread) => `${bread} is sliced`;
   
   // Spreading Function
   const spreadButter = (bread) => `Butter spread on ${bread}`;
   
   // Filling Function
   const addFilling = (bread) => `Filling added to ${bread}`;
   
   // Composing Functions to make a Sandwich
   const makeSandwich = (bread) => addFilling(spreadButter(sliceBread(bread)));
   
   console.log(makeSandwich("Whole Wheat"));
   // Outputs: "Filling added to Butter spread on Whole Wheat is sliced"

9. Pipe function - Function Composition bilan deyarli bir xil, faqat ustunligi berilgan funksiyalar ketma-ketlikda ishlaydi.

   const pipe =
     (...fns) =>
     (data) =>
       fns.reduce((data, fn) => fn(data), data);
   
   const addMeat = (osh) => osh + "+ Meat";
   const addEgg = (osh) => osh + "+ Egg";
   
   const osh = pipe(addMeat, addEgg);
   
   console.log(osh("Osh")); // Osh + Meat + Egg

10. Referential Transparency - biror qiymat qaytaradigan funksiyani argument sifatida boshqa funksiyaga bergan holatdagi natija, shu funksiya qaytaradigan qiymatni argument sifatida bergandagi bilan bir xil bo'lishi kerak, shunda birinchi funksiya Referential Transparency deyiladi.

    const sum = (a, b) => a + b;
    const showSum = (num) => `Result is: ${num}`;
    
    showSum(sum(2, 3));
    showSum(5);

11. IIFE - Immediatlty Invoked Function Expression e'lon qilingan zahoti ishlaydigan funksiya. Ko'proq global scope-da kod yozishdan qochish uchun ishlatiladi.

    (function () {
      console.log("I am in a scope");
    })();

    const sum = ((_) => {
      let limit = 0;
      return (num1, num2) => {
        limit++;
        !(limit % 4) ? "I'm tired" : num1 + num2;
      };
    })();