Qaysi oqimlar bilan ishlash uchun operatorlarni…

Dastur oqimlari bilan ishlash uchun operatorlar, ayniqsa asinxron dasturlash va reaktsion kutubxonalar (masalan, RxJS) kontekstida muhim bo'lib, bir nechta kategoriyalarga bo'linadi.

Yaratish operatorlari (Creation Operators): Yangi oqim yaratish uchun ishlatiladi.

of(): Belgilangan qiymatlar to'plamini chiqaradigan oqim yaratadi.

// RxJS dan
import { of } from 'rxjs';

const source = of(1, 2, 3); // 1, 2, 3 ni chiqaradigan oqim

from(): Turli manbalardan (Promise, Iterable, ArrayLike) oqim yaratadi.

// RxJS dan
import { from } from 'rxjs';

const source = from([10, 20, 30]); // massivdan oqim

interval(): Belgilangan vaqtdan keyin ketma-ket raqamlarni chiqaradigan oqim yaratadi.

// RxJS dan
import { interval } from 'rxjs';

const source = interval(1000); // Har sekundda raqam chiqaradigan oqim

timer(): Belgilangan vaqtdan keyin bir marta qiymat chiqaradigan yoki interval bilan chiqaradigan oqim.
fromEvent(): DOM voqealari yoki EventEmitter dan oqim yaratadi.

Transformatsiya operatorlari (Transformation Operators): Oqim tomonidan chiqarilgan qiymatlarni o'zgartiradi.

map(): Har bir chiqarilgan qiymatga funksiya qo'llash orqali o'zgartiradi.

// RxJS dan
import { of } from 'rxjs';
import { map } from 'rxjs/operators';

const source = of(1, 2, 3);
const result = source.pipe(map(x => x * 2)); // 2, 4, 6 qiymatlari

pluck(): Har bir obyektdan xususiyatni chiqarib oladi.
scan(): Akkumulyator funksiyasini har bir qiymatga qo'llab, o'rtacha natijalarni chiqaradi.

mergeMap() / flatMap(): Har bir qiymatni yangi oqimga proyeksiya qiladi va ularni birlashtiradi. Asinxron operatsiyalar uchun qulay.

// RxJS dan
import { of } from 'rxjs';
import { mergeMap } from 'rxjs/operators';

const source = of(1, 2);
const result = source.pipe(mergeMap(val => of(val + 'a', val + 'b'))); // '1a', '1b', '2a', '2b' qiymatlari

switchMap(): mergeMap ga o'xshash, lekin yangi qiymat chiqarilganda oldingi ichki oqimni bekor qiladi.
concatMap(): Ichki oqimlar ketma-ket bajariladi.

Filtrlash operatorlari (Filtering Operators): Faqat tanlangan qiymatlarni chiqaradi.

filter(): Shartga mos keladigan qiymatlarni chiqaradi.

// RxJS dan
import { of } from 'rxjs';
import { filter } from 'rxjs/operators';

const source = of(1, 2, 3, 4);
const result = source.pipe(filter(x => x % 2 === 0)); // 2, 4

take(): Birinchi N ta qiymatni chiqaradi.
takeUntil(): Boshqa oqim qiymat chiqarishni boshlaguncha chiqaradi.
skip(): Birinchi N ta qiymatni o'tkazib yuboradi.
debounceTime(): Vaqt davomida hech narsa chiqarilmagach, so'ng chiqaradi.
distinctUntilChanged(): Oldingi qiymatdan farq qiladigan qiymatlarni chiqaradi.

Kombinatsiya operatorlari (Combination Operators): Bir nechta oqimni birlashtiradi.

combineLatest(): Har bir o'zgarishda barcha oqimlarning so'nggi qiymatlarini chiqaradi.
zip(): Har bir oqimdan mos indeksdagi qiymatlarni birlashtiradi.
merge(): Barcha oqimlarni birlashtiradi, qiymatlarni ketma-ket chiqaradi.
concat(): Bir oqim tugaguncha, keyin ikkinchi boshlanadi.

Xatoliklarni boshqarish operatorlari (Error Handling Operators): Xatolik yuzaga kelganda qanday harakat qilishni belgilaydi.

catchError(): Xatolikni ushlab, oqimni davom ettiradi yoki o'zgartiradi.

// RxJS dan
import { throwError } from 'rxjs';
import { catchError, of } from 'rxjs/operators';

const source = throwError(() => new Error('Nimadir noto'g'ri ketdi'));
const result = source.pipe(catchError(err => of('Xato ushlanmoqda'))); // 'Xato ushlanmoqda'

retry(): Xatolik yuzaga kelganda N marta qayta urinadi.

Yakunlash operatorlari (Completion Operators): Struym tugagach nima qilishni belgilaydi.

finalize(): Tugash yoki bekor qilishda bajariladi.
tap(): Yon ta'sirlar uchun, masalan, log yozish.

Bu operatorlar frontend dasturlashda, ayniqsa reaktiv yondashuvda, ko'p ishlatiladi.

Qaysi oqimlar bilan ishlash uchun operatorlarni bilasiz?