Q: IFFE nima?

A: IIFE (Immediately Invoked Function Expression) bu JavaScript-da darhol bajariladigan funksiya ifodasini bildiradi. IIFE darhol yaratilib, chaqiriladigan funksiya bo'lib, asosan lokal o'zgaruvchilarni boshqa kodlardan yashirish uchun ishlatiladi.

#EX:
Tasavvur qiling, sizda biror o'zgaruvchi bor va siz uni faqat bitta joyda ishlatib, darhol o'sha joyda natijasini olishni xohlaysiz:

(function() { let number = 5; // O'zgaruvchini e'lon qilamiz let square = number * number; // Kvadratini hisoblaymiz console.log(square); // Natija: 25 })();

Nima sodir bo'ladi:

(function() { ... }) - Bu funksiya ifodasi. Funksiya (function() { ... }) qavslar ichiga olingan, bu uni oddiy funksiya emas, balki funksiya ifodasi ekanligini bildiradi.

() - Qavslar funksiya ifodasini darhol chaqiradi, ya'ni funksiyani yaratgan zahoti bajaradi.

Bu misolda, number va square faqat shu funksiya ichida mavjud. Funktsiya darhol chaqiriladi va natijani (25) konsolga chiqaradi. Tashqarida bu o'zgaruvchilar mavjud emas, ya'ni sizning kodingizda boshqa joyda number yoki square ga murojaat qilib bo'lmaydi. Bu global o'zgaruvchilar yaratmaslik va kodning boshqa qismlariga ta'sir qilmaslik uchun juda qulay.

@YusufxonToshkandiy

Q: Pipe Funstion nima ?

A: Pipe funtion — bu dasturlashda bir nechta funksiyalarni zanjir sifatida bir-biriga ulash uchun ishlatilinadigan texnalogiya. Bu odatda funksional dasturlashda keng qo'llaniladi va Composition funksiyalar bilan deyarli bir xil , faqat ustun ta'rafi Pipe funksiyalarga berilgan funksiyalar ketma ketlikda ishlaydi.

Ex:

```
const pipe = (double, square) => (x) => square(double(x));

const double = (x) => x * 2;
const square = (x) => x * x;

const doubleThenSquare = pipe(double, square);

const result = doubleThenSquare(3); // 3 ni avval 2 ga ko'paytiradi,
keyin kvadratni hisoblaydi: (3 * 2)^2 = 36.

console.log(result); // 36
```

@YusufxonToshkandiy

Q: Function composition nima?

A: Function Composition — bu bir nechta funksiyalarni birlashtirib, ulardan yangi bir funksiya yaratish jarayoni. Bunda bir funksiyadan returnda qaytgan qiymat keyingi funksiyaga argument sifatida ishlatilinadi.

#Ex:

Tasavvur qiling, ikkita funksiya bor:

```
function double(x) {
return x * 2;
}

function square(x) {
return x * x;
}
```

Endi biz ushbu ikkita funksiyani birlashtirib, avval sonni ikkiga ko'paytirib, so'ngra kvadratga oshiradigan yangi funksiya yaratamiz:

```
function compose(square, double) {
return function(x) {
return square(double(x));
};
}

const doubleThenSquare = compose(square, double);

console.log(doubleThenSquare(3)); // Natijasi: 36
```

// Bu yerda nima bo'ldi? Bu yerda Callback va Currying metodlaridan foydalanildi. Buni tushunishimiz uchun birinchi compose() funksiyasi ikkita funksiyani argument sifatida qabul qildi va doubleThenSquare ga returnga o'z ichidagi funksiyani qaytarib yubordi. Uning ichidagi funksiya x(3) argumentni birinchi double() funksiyaga argument sifatida berdi va undan qaytgan natija esa square() funksiyasiga argument sifatida berib yuborildi va ushbu funksiya bizga oxirgi natijani qaytarmoqda. Natija: 36.

@YusufxonToshkandiy

O'zi Higher Order Functions qanday ishlaydi ? Misol uchun biz agarda aylananing yuzasini va diametrini hisoblaydigan function yozsak.

```
const radius = [1, 2, 3];

// Bu funksiya aylananing yuzasini hisoblaydi
const calculateArea = function (radius) {
const output = [];
for(let i = 0; i< radius.length; i++){
output.push(Math.PI * radius[i] * radius[i]);
}
return output;
}

// Bu funksiya esa ayalananing diametrini hisoblaydi,
const calculateDiameter = function (radius) {
const output = [];
for(let i = 0; i< radius.length; i++){
output.push(2 * radius[i]);
}
return output;
}

console.log(calculateArea(radius));
console.log(calculateDiameter(radius))

```

Ammo ko'rib turganimizdek bu yerda deyarli bir xil logika ishtilinmoqda va ular reusable ham emas.

Endi aynan shu vazifani bajaradigan funksiyani HOFs (Higher-Order Functions) orqali yozib ko'ramiz

```
const radius = [1, 2, 3];

// Ushbu logika faqat yuzani topish uchun hizmat qiladi.
const area = function(radius){
return Math.PI * radius * radius;
}

// Ushbu logika faqat diametrni hisoblaydi
const diameter = function(radius){
return 2 * radius;
}

// ushbu reusable functionnimiz yuza, diametrlarni hisoblaydi
const calculate = function(radius, logic){
const output = [];
for(let i = 0; i < radius.length; i++){
output.push(logic(radius[i]))
}
return output;
}

console.log(calculate(radius, area));
console.log(calculate(radius, diameter));
```

Endi bu yerda ko'rib turganimizdek biz calculate() nomli bir dona function yozib oldik ayalananing yuzasi va diametrnini topish uchun. Va biz o'zimizga kerak logikani yozdik va uni calculate() ga argument sifatida berib yubordik. Bu yerda axamiyatli jihati shundaki har bir function o'z ishini bajarmoqda hech qanday takrorlanishlarsiz.
Agarda biz keyinchalik aylananing alanasini hisoblamoqchi bo'lsak aynan shu logikani bajaradigan function yozib uni calculate() functionimizga argument sifatida berib yuborsak shuni o'zi kifoya.

```
const circumeference = function(radius){
return 2 * Math.PI * radius;
}

console.log(calculate(radius, circumeference));
```

@YusufxonToshkandiy

Q: Higher-order Functions nima ?

A: Higher-order functions bu bir yoki bir nechta funksiyani argument sifatida qabul qiladigan yoki natija sifatida funksiyani qaytaradigan funksiyadir. Bir necha turdagi Higher Order Function lar mavjud misol uchun map() va reduce()

```
// Callback function, the higher order function ga parameter sifatida berib yuborildi.
function callbackFunction(){
console.log('I am a callback function');
}

// higher order function
function higherOrderFunction(func){
console.log('I am higher order function')
func()
}

higherOrderFunction(callbackFunction);
```

@YusufxonToshkandiy

Eid Muborak ?

Q: First-class function (citizens) nima ?

A: First-class functions (citizens) — bu bir function ni variable orqali e'lon qilish va shu bilan birga Javascript va shunga o'xshash tillarda function boshqa bir function ga argument sifatida beriladi va yana returnda value sifatida boshqa bir function ni qaytarishi hisoblanadi.

Variable orqali funksiya e'lon qilish

const foo = () => { console.log("foobar"); }; foo(); // o'zgaruvchi orqali e'lon qilish

Bir funksiya boshqa bir funksiyaga argument sifatida berilishi

function sayHello() { return "Hello, "; } function greeting(helloMessage, name) { console.log(helloMessage() + name); } // sayHello funksiyasini greeting funksiyasiga argument sifatida berilmoqda greeting(sayHello, "JavaScript!"); // Natija: Hello, JavaScript!

Return da funksiya qaytarish

function sayHello() { return () => { console.log("Hello!"); }; }

@YusufxonToshkandiy

Q: Pure va impure function nima ?

A: Pure function — qaytaradigan natija side effectlardan xoli va har safar bir xil inputga bir xil output qaytaradigan funksiyalardir. Impure functions esa aksi.

Pure Funtion

function updateMyName(newName) { const myNames = ["Oluwatobi", "Sofela"]; myNames[myNames.length] = newName; return myNames; }

Impure Function

```
const myNames = ["Oluwatobi", "Sofela"];

function updateMyName(newName) {
myNames.push(newName);
return myNames;
}
```

side effect — function tashqarisidan nimanidir ishlatish. Tashqari bilan to'g'ridan to'g'ri ishlash.

Q: Functional programming nima ? A: Functional programming — bu declarative programming paradigmlari sinfiga mansub bo'lib, dasturni pure functionlarga bo'lish orqali tuzilishni ilgari suradi. Bu orqali kod tushunarli, boshqarishga osson, qayta ishlatsa…

Q: Functional programming nima ?

A: Functional programming — bu declarative programming paradigmlari sinfiga mansub bo'lib, dasturni pure functionlarga bo'lish orqali tuzilishni ilgari suradi. Bu orqali kod tushunarli, boshqarishga osson, qayta ishlatsa bo'ladigan va testlash uchun osson bo'ladi. Functional programmingning quyidagi conceptlari mavjud: Immutability, Pure functions, High order functions, First class functions, Currying, Recursion, Composition, Referential Transparency lardir