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

Q: Callback function nima ?

A: Callback function — bu JavaScript'da bir funksiyaga argument sifatida berilishi va keyinchalik boshqa funksiyalar tomonidan chaqirilishi mumkin bo'lgan funksiyadir. Callback funksiyalar asosan asinxron operatsiyalarni boshqarish uchun ishlatiladi, masalan, ma'lumotlar yuklanishini kutib turganda yoki qanchadir vaqt o'tkazgandan keyin biror kodni ishlatish uchun.

```
function greeting(name, callback) {
console.log("Hello, " + name);
callback();
}

function additional() {
console.log("This is an additional function");
}

greet("Ali", additional);

//Bu yerda greeting() funksiyasi birinchi argument sifatida ismni qabul qiladi va ikkinchi argument sifatida callback funksiyasini yani additional() qabul qiladi. greeting() funksiyasi birinchi qatorni o'qigandan keyin, u berilgan callback funksiyasini chaqiradi va natija quyidagicha chiqadi.

// Hello, Ali
// This is an additional function

```

@YusufxonToshkandiy

Q: Recursion nima ? A: Recursion — bu funksinal programmingda bir funksiya o'zini o'zi chaqirishiga nisbatan aytilinadi va bunday funksiyalar ''Recursive function'' deyiladi. Rekursiyaning asosiy qismi: — Asosiy holat (Base Case): Bu funksiyani o‘z…

Q: Recursion nima ?

A: Recursion — bu funksinal programmingda bir funksiya o'zini o'zi chaqirishiga nisbatan aytilinadi va bunday funksiyalar ''Recursive function'' deyiladi.

Rekursiyaning asosiy qismi:

— Asosiy holat (Base Case): Bu funksiyani o‘z-o‘zini chaqirishni to‘xtatish uchun berilgan shart. Asosiy holat funksiyaning tugashi uchun zarur.
— Rekursiv chaqiruv (Recursive Call): Bu qism, funksiya o‘zini-o‘zi chaqiradigan qism.

Oddiy misol: Faktorial hisoblash
Faktorial — bu berilgan sonning barcha natural sonlar ko‘paytmasi. Masalan, 5! (5 faktorial) 5 x 4 x 3 x 2 x 1 = 120 ga teng.

Faktorialni rekursiv ravishda hisoblash uchun quyidagi kodni ko‘rib chiqamiz:

```
function factorial(n) {
// Asosiy holat: n 1 ga teng bo'lsa, 1 qaytarish
if (n === 1) {
return 1;
}

// Rekursiv chaqiruv: n * factorial(n - 1)
return n * factorial(n - 1);
}

console.log(factorial(5)); // 120
```

Qanday ishlaydi?

— Factorial(5) funksiyasini chaqirasiz. Bu 5 * factorial(4) ni qaytadi. Factorial(4) chaqiriladi va bu 4 * factorial(3) ni qaytaradi. Shu tarzda davom etib, factorial(1) chaqirilganda 1 qaytariladi va barcha hisoblashlar tugallanadi.

@YusufxonToshkandiy

Yana bir misol:

// Bu yerda ham funksiyalar zanjiri tugamaguncha qiymatlar berilib oxirgi qiymatgacha boriladi va natija chiqadi.

```
function sum(a) {
return function(b) {
return function(c) {
return a + b + c;
};
};
}

// Ishlatish:
console.log(sum(1)(2)(3)); // 6
```

Q: Currying nima ?

A: Currying — bu funksiylarini bir nechta kichik funksiylarga ajratish usuli. Bu usul, funksiyaga bir vaqtning o'zida bitta argument berib, yangi funksiya hosil qilishni ta'minlaydi va bu yangi funksiya keyingi argumentni qabul qiladi. Bu funksiyalar zanjirini yaratadi, bunda har bir funksiya yakuniy natijaga erishilgunga qadar boshqa funksiyani qaytaradi.

#Ex
Tasavvur qiling, oddiy ikki argumentli funksiya bor:

```
function add(a, b) {
return a + b;
}

console.log(add(1, 2)); // 3
```

Bu funksiyani currying funksiya qilamiz:

```
function curriedAdd(a) {
return function(b) {
return a + b;
};
}

// Ishlatish:
const addOne = curriedAdd(1); // Bu yerda curriedAdd funksiyasi argument qabul qildi va returnga o'zining ichidagi qiymatni qaytardi.

console.log(addOne(2)); // Bu yerda esa addOne funksiyasi oxirgi qiymatga yetib bordi va natijani qaytardi 3.

// Bu funksiyani to'g'ridan to'g'ri ishlatsak ham bo'ladi bunda birinichi qiymat birinchi funksiyaga argument sifatida qa'bul qiladi va returnda funksiya qaytganligi sababli ikkinchi qiymatni o'sha funksiyaga argument sifadida berib yuboradi.
console.log(curriedAdd(1)(2)); // 3

```

@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