Operators এর ধারণা এবং শ্রেণীবিভাগ

RxJS-এর Operators হলো এমন ফাংশন যা Observable এর ডেটা স্ট্রিমের উপর বিভিন্ন কার্যকরী অপারেশন করতে ব্যবহৃত হয়। এগুলি মূলত ডেটা ফিল্টার, ম্যানিপুলেট, একত্রিত, অথবা পরিবর্তন করতে সহায়ক। RxJS-এর অপারেটরগুলি আপনার অ্যাসিঙ্ক্রোনাস ডেটার উপরে কার্যকরীভাবে কাজ করার ক্ষমতা প্রদান করে, যেমন—ফিল্টারিং, ম্যাপিং, কম্বাইনিং, এবং আরও অনেক কিছু।

RxJS-এর অপারেটরগুলি সাধারণত দুটি ধরণের হয়—একক অপারেটর এবং চেইনেবল অপারেটর।

Operators এর ধারণা

Operators হল কার্যক্রম যা একটি Observable-এর ওপর প্রয়োগ করা হয়। একটি অপারেটর Observable এর ডেটা স্ট্রিমের উপরে কোনো নির্দিষ্ট ট্রান্সফর্মেশন বা অপারেশন সম্পাদন করে। অপারেটরগুলি সাধারণত pipe() মেথডের মাধ্যমে একটি Observable চেইনে যোগ করা হয়।

যখন আপনি pipe() মেথডের মাধ্যমে একাধিক অপারেটর চেইন করেন, তখন আপনি Observable-এ প্রবাহিত ডেটাকে পর্যায়ক্রমে প্রক্রিয়া করতে পারেন।

Operators এর শ্রেণীবিভাগ

RxJS-এর অপারেটরগুলিকে বিভিন্ন শ্রেণীতে ভাগ করা যায়, যেমন:

1. Creation Operators

এগুলি নতুন Observable তৈরি করার জন্য ব্যবহৃত হয়। উদাহরণস্বরূপ, of(), from(), interval() ইত্যাদি অপারেটরগুলি একটি নতুন Observable তৈরি করে।

• of(): এটি একটি নতুন Observable তৈরি করে যা একটি নির্দিষ্ট মান প্রদান করে।

  import { of } from 'rxjs';
  
  const observable = of(1, 2, 3);
  observable.subscribe(console.log); // 1, 2, 3
  

• from(): এটি একটি Array, Promise, বা অন্য Iterable থেকে Observable তৈরি করে।

  import { from } from 'rxjs';
  
  const observable = from([1, 2, 3]);
  observable.subscribe(console.log); // 1, 2, 3
  

2. Transformation Operators

এই অপারেটরগুলির মাধ্যমে আপনি Observable-এ প্রবাহিত ডেটাকে পরিবর্তন করতে পারেন। যেমন, map(), mergeMap(), concatMap() ইত্যাদি।

• map(): এটি একটি নির্দিষ্ট ট্রান্সফর্মেশন ফাংশন প্রয়োগ করে এবং ডেটার মান পরিবর্তন করে।

  import { of } from 'rxjs';
  import { map } from 'rxjs/operators';
  
  const observable = of(1, 2, 3);
  observable.pipe(
    map(x => x * 10)
  ).subscribe(console.log); // 10, 20, 30
  

• mergeMap(): এটি একটি ইনপুট মানের উপর ভিত্তি করে একটি নতুন Observable তৈরি করে এবং সমস্ত ইনপুট Observable একত্রিত করে।

  import { of } from 'rxjs';
  import { mergeMap } from 'rxjs/operators';
  
  const observable = of(1, 2, 3);
  observable.pipe(
    mergeMap(x => of(x * 10))
  ).subscribe(console.log); // 10, 20, 30
  

3. Filtering Operators

এগুলি Observable-এ প্রবাহিত ডেটাকে ফিল্টার করতে ব্যবহৃত হয়, যেমন filter(), take(), takeUntil() ইত্যাদি।

• filter(): এটি একটি নির্দিষ্ট শর্ত অনুসারে ডেটাকে ফিল্টার করে।

  import { of } from 'rxjs';
  import { filter } from 'rxjs/operators';
  
  const observable = of(1, 2, 3, 4, 5);
  observable.pipe(
    filter(x => x % 2 === 0)
  ).subscribe(console.log); // 2, 4
  

• take(): এটি নির্দিষ্ট সংখ্যক মান গ্রহণ করে এবং তারপর Observable বন্ধ করে দেয়।

  import { of } from 'rxjs';
  import { take } from 'rxjs/operators';
  
  const observable = of(1, 2, 3, 4, 5);
  observable.pipe(
    take(3)
  ).subscribe(console.log); // 1, 2, 3
  

4. Combination Operators

এগুলি একাধিক Observable-এর ডেটা একত্রিত করে, যেমন merge(), concat(), combineLatest() ইত্যাদি।

• merge(): এটি একাধিক Observable-এর ডেটা একত্রিত করে একটি নতুন Observable তৈরি করে।

  import { of, merge } from 'rxjs';
  
  const observable1 = of(1, 2, 3);
  const observable2 = of(4, 5, 6);
  
  merge(observable1, observable2).subscribe(console.log); // 1, 2, 3, 4, 5, 6
  

• combineLatest(): এটি একাধিক Observable থেকে সর্বশেষ মানগুলিকে একত্রিত করে এবং প্রতিবার যে কোনো একটি Observable মান প্রদান করলে তা আপডেট করে।

  import { of, combineLatest } from 'rxjs';
  
  const observable1 = of(1, 2, 3);
  const observable2 = of(4, 5, 6);
  
  combineLatest(observable1, observable2).subscribe(console.log); // [3, 6]
  

5. Utility Operators

এগুলি Observable-এর সাথে যুক্ত নির্দিষ্ট কার্যকলাপ বা অপারেশন সম্পাদন করতে ব্যবহৃত হয়, যেমন tap(), delay(), finalize() ইত্যাদি।

• tap(): এটি একটি অপারেটর যা Observable-এ প্রবাহিত ডেটাকে পর্যবেক্ষণ করার জন্য ব্যবহৃত হয়, তবে এটি ডেটার মান পরিবর্তন করে না।

  import { of } from 'rxjs';
  import { tap } from 'rxjs/operators';
  
  const observable = of(1, 2, 3);
  observable.pipe(
    tap(x => console.log('Before:', x))
  ).subscribe(console.log); // Before: 1, 1, 2, 3
  

• delay(): এটি নির্দিষ্ট সময়ের জন্য ডেটা পাঠানোকে বিলম্বিত করে।

  import { of } from 'rxjs';
  import { delay } from 'rxjs/operators';
  
  const observable = of(1, 2, 3);
  observable.pipe(
    delay(1000)
  ).subscribe(console.log); // 1, 2, 3 (After 1 second delay)
  

সারাংশ

RxJS এর Operators ব্যবহার করে আপনি Observables-এর ডেটা স্ট্রিমের উপর বিভিন্ন ধরনের ট্রান্সফর্মেশন, ফিল্টার, এবং কম্বাইনিং কার্যক্রম করতে পারেন। এগুলি সাধারণত পাঁচটি শ্রেণীতে বিভক্ত হয়: Creation Operators, Transformation Operators, Filtering Operators, Combination Operators, এবং Utility Operators। এই অপারেটরগুলো RxJS ব্যবহারকারীকে একটি শক্তিশালী এবং উন্নতমানের অ্যাসিঙ্ক্রোনাস ডেটা ম্যানেজমেন্টের অভিজ্ঞতা প্রদান করে।

RxJS এর Operators হল এমন ফাংশন যা Observables এর উপর কার্যকরী অপারেশন বা ট্রান্সফর্মেশন করতে সাহায্য করে। Operators ব্যবহার করে আমরা Observable থেকে আসা ডেটাকে বিভিন্নভাবে পরিবর্তন করতে পারি, যেমন: ফিল্টার করা, ম্যাপ করা, একত্রিত করা বা অন্য কোনো ট্রান্সফর্মেশন করা। RxJS-এর মধ্যে অনেক ধরনের Operators রয়েছে, যা অ্যাসিঙ্ক্রোনাস এবং ইভেন্ট-ভিত্তিক ডেটার প্রক্রিয়াকরণের জন্য ব্যবহৃত হয়।

Operators এর ধরন

RxJS-এ Operators বিভিন্ন ধরনের হতে পারে এবং এগুলিকে সাধারণত দুইটি ক্যাটাগরিতে ভাগ করা হয়:

1. Creation Operators:
   এই ধরনের অপারেটরগুলি নতুন Observable তৈরি করতে সাহায্য করে। উদাহরণস্বরূপ, of(), from(), interval() ইত্যাদি।
2. Transformation Operators:
   এই অপারেটরগুলি Observable-এর ডেটা বা মানের উপর বিভিন্ন পরিবর্তন ঘটানোর জন্য ব্যবহৃত হয়। যেমন map(), filter(), scan() ইত্যাদি।
3. Combination Operators:
   এই অপারেটরগুলি একাধিক Observable এর মধ্যে একত্রিত (combine) করার জন্য ব্যবহৃত হয়। যেমন merge(), concat(), combineLatest() ইত্যাদি।
4. Utility Operators:
   এই অপারেটরগুলির মাধ্যমে আমরা বিভিন্ন ইউটিলিটি ফাংশন প্রয়োগ করতে পারি, যেমন tap(), finalize() ইত্যাদি।
5. Error Handling Operators:
   এই অপারেটরগুলি Observable এর ত্রুটি (error) হ্যান্ডল করতে ব্যবহৃত হয়। যেমন catchError(), retry() ইত্যাদি।
6. Conditional and Boolean Operators:
   এই ধরনের অপারেটরগুলি কোনো শর্ত বা boolean মানের ভিত্তিতে স্ট্রিমের ডেটা প্রসেস করে। উদাহরণস্বরূপ takeWhile(), defaultIfEmpty() ইত্যাদি।

RxJS এর Operators কেন ব্যবহার করা হয়?

RxJS এর Operators ব্যবহারের প্রধান উদ্দেশ্য হলো ডেটা স্ট্রিমের উপর কার্যকরীভাবে অপারেশন চালানো এবং Declarative কোড লেখা। এর মাধ্যমে, আপনি ডেটার ট্রান্সফর্মেশন, একত্রিতকরণ, ফিল্টারিং এবং অন্যান্য বিভিন্ন কাজগুলোকে সহজে ও কম কোডের মধ্যে করতে পারেন।

Operators ব্যবহারের সুবিধা

1. Declarative কোড:
   RxJS এর Operators আপনার কোডকে আরও Declarative (অথবা স্পষ্ট) করে তোলে। এর মাধ্যমে আপনি কি করতে চান, তা সহজে প্রকাশ করতে পারেন, যেমন “এটা ফিল্টার কর”, “এই মানকে ১০ গুণ বাড়িয়ে দাও” ইত্যাদি। এতে কোডের পড়া এবং বুঝতে সুবিধা হয়।

   উদাহরণস্বরূপ:

   import { of } from 'rxjs';
   import { map, filter } from 'rxjs/operators';
   
   const observable = of(1, 2, 3, 4, 5);
   observable.pipe(
     filter(x => x % 2 === 0),  // ফিল্টার করা
     map(x => x * 10)            // ম্যাপ করা
   ).subscribe(console.log);     // আউটপুট হবে: 20, 40
   

   এই কোডে, আমরা প্রথমে মানগুলো ফিল্টার করেছি এবং তারপর ম্যাপ অপারেটরের মাধ্যমে প্রতিটি মানকে ১০ গুণ বৃদ্ধি করেছি।

2. কমপ্লেক্স ডেটা স্ট্রিম ম্যানিপুলেশন:
   RxJS এর মাধ্যমে একাধিক স্ট্রিমকে একত্রিত করা, বিভিন্ন ধরণের ট্রান্সফর্মেশন বা ফিল্টারিং করা সহজ হয়। Operators একত্রে ব্যবহার করে আপনি আরো জটিল কার্যক্রম সম্পাদন করতে পারেন।
3. ক্লিন এবং মেইন্টেনেবল কোড:
   Operators ব্যবহার করলে কোড কমপ্লেক্সিটি কমে যায় এবং কোডটি আরও পরিষ্কার ও মেইন্টেনেবল হয়ে ওঠে। আপনি সহজেই বিভিন্ন স্ট্রিমের উপর অপারেশনগুলির লজিক চেইন করতে পারেন।
4. এ্যাসিঙ্ক্রোনাস ডেটার সাথে কার্যকরী কাজ:
   RxJS-এর Operators বিশেষভাবে ডিজাইন করা হয়েছে অ্যাসিঙ্ক্রোনাস ডেটার জন্য। আপনি যখন অনেক ধরনের অ্যাসিঙ্ক্রোনাস কার্যক্রম যেমন HTTP রিকোয়েস্ট, ইউজার ইভেন্ট ইত্যাদি একত্রে পরিচালনা করতে চান, তখন Operators খুবই সহায়ক হয়ে দাঁড়ায়।

Operators এর উদাহরণ

1. map():
   map() অপারেটর একটি Observable-এর মানে ট্রান্সফর্মেশন বা পরিবর্তন করতে ব্যবহৃত হয়।

   import { of } from 'rxjs';
   import { map } from 'rxjs/operators';
   
   const observable = of(1, 2, 3);
   observable.pipe(
     map(x => x * 10)
   ).subscribe(console.log); // আউটপুট: 10, 20, 30
   

2. filter():
   filter() অপারেটর দিয়ে আপনি Observable এর ডেটা স্ট্রিম থেকে নির্দিষ্ট মান ফিল্টার করতে পারেন।

   import { of } from 'rxjs';
   import { filter } from 'rxjs/operators';
   
   const observable = of(1, 2, 3, 4, 5);
   observable.pipe(
     filter(x => x % 2 === 0)
   ).subscribe(console.log); // আউটপুট: 2, 4
   

3. merge():
   merge() অপারেটর একাধিক Observable কে একত্রিত করতে ব্যবহৃত হয়।

   import { of, merge } from 'rxjs';
   
   const observable1 = of('A', 'B');
   const observable2 = of('C', 'D');
   
   merge(observable1, observable2).subscribe(console.log); // আউটপুট: A, B, C, D
   

সারাংশ

RxJS-এর Operators ডেটা স্ট্রিমের উপর কার্যকরী অপারেশন চালানোর জন্য ব্যবহৃত হয়। এগুলি Declarative কোড লেখার জন্য অপরিহার্য এবং অ্যাসিঙ্ক্রোনাস ডেটার সাথে কাজ করার ক্ষেত্রে অসাধারণ সুবিধা প্রদান করে। RxJS এর Operators ব্যবহার করে আপনি ডেটা স্ট্রিমের উপর ম্যাপিং, ফিল্টারিং, একত্রিতকরণ, এবং অন্যান্য কার্যক্রম খুব সহজেই এবং পরিষ্কারভাবে করতে পারবেন।

RxJS-এ Operators দুটি প্রধান শ্রেণীতে বিভক্ত: Pipeable Operators এবং Creation Operators। এগুলোর মাধ্যমে আপনি Observable-দের উপর বিভিন্ন ধরনের কার্যক্রম বা ট্রান্সফর্মেশন করতে পারেন।

Pipeable Operators

Pipeable Operators এমন অপারেটর যেগুলো আপনি pipe() মেথডের মধ্যে ব্যবহার করতে পারেন। pipe() মেথড ব্যবহার করে একাধিক অপারেটর চেইন করা যায়, যাতে Observable-এর স্ট্রিমের উপর বিভিন্ন অপারেশন করা যায়। এগুলো সাধারণত একটি Observable-এর ডেটা বা ইভেন্টকে ট্রান্সফর্ম করে।

Pipeable Operators এর উদাহরণ:

1. map:
   map অপারেটরটি একটি মানের উপর ট্রান্সফর্মেশন প্রয়োগ করে এবং সেই ট্রান্সফর্মড মানটি নতুন Observable-এ পাঠায়।

   উদাহরণ:

   import { of } from 'rxjs';
   import { map } from 'rxjs/operators';
   
   const observable = of(1, 2, 3);
   observable.pipe(
     map(x => x * 10)
   ).subscribe(console.log);
   // আউটপুট: 10, 20, 30
   

2. filter:
   filter অপারেটরটি একটি Observable-এর মানগুলিকে ফিল্টার করে। এটি শুধুমাত্র সেই মানগুলো পাঠায় যা নির্দিষ্ট শর্ত পূরণ করে।

   উদাহরণ:

   import { of } from 'rxjs';
   import { filter } from 'rxjs/operators';
   
   const observable = of(1, 2, 3, 4, 5);
   observable.pipe(
     filter(x => x % 2 === 0)
   ).subscribe(console.log);
   // আউটপুট: 2, 4
   

3. take:
   take অপারেটরটি একটি নির্দিষ্ট সংখ্যা পর্যন্ত মানগুলো গ্রহণ করে এবং তারপর Observable বন্ধ করে দেয়।

   উদাহরণ:

   import { of } from 'rxjs';
   import { take } from 'rxjs/operators';
   
   const observable = of(1, 2, 3, 4, 5);
   observable.pipe(
     take(3)
   ).subscribe(console.log);
   // আউটপুট: 1, 2, 3
   

4. concatMap:
   concatMap অপারেটরটি একটি Observable থেকে পাওয়া প্রতিটি মানকে অন্য একটি Observable-এ ম্যাপ করে এবং তাদের সিরিয়ালি (একটি একে পরবর্তী) সম্পাদন করে।

   উদাহরণ:

   import { of } from 'rxjs';
   import { concatMap } from 'rxjs/operators';
   
   const observable = of(1, 2, 3);
   observable.pipe(
     concatMap(x => of(x * 10))
   ).subscribe(console.log);
   // আউটপুট: 10, 20, 30
   

Creation Operators

Creation Operators এমন অপারেটর যা দিয়ে আপনি নতুন Observable তৈরি করতে পারেন। এগুলি আপনাকে Observable সৃষ্টি করার জন্য বিভিন্ন পদ্ধতি প্রদান করে, যাতে অ্যাসিঙ্ক্রোনাস ডেটা অথবা স্ট্রিমগুলির সাথে কাজ করা সহজ হয়।

Creation Operators এর উদাহরণ:

1. of:
   of অপারেটরটি একটি Observable তৈরি করে যেটি নির্দিষ্ট মানগুলি একের পর এক প্রেরণ করে।

   উদাহরণ:

   import { of } from 'rxjs';
   
   const observable = of(1, 2, 3);
   observable.subscribe(console.log);
   // আউটপুট: 1, 2, 3
   

2. from:
   from অপারেটরটি একটি অ্যারে, ইটারেবল, পমিস বা অন্য কোনো ডেটা স্ট্রিম থেকে একটি Observable তৈরি করে।

   উদাহরণ:

   import { from } from 'rxjs';
   
   const observable = from([1, 2, 3]);
   observable.subscribe(console.log);
   // আউটপুট: 1, 2, 3
   

3. interval:
   interval অপারেটরটি নির্দিষ্ট সময় ব্যবধানে সংখ্যা তৈরি করতে পারে। এটি একটি অ্যাসিঙ্ক্রোনাস Observable তৈরি করে যা নির্দিষ্ট সময় পরে একে একে সংখ্যা পাঠায়।

   উদাহরণ:

   import { interval } from 'rxjs';
   
   const observable = interval(1000); // প্রতি ১ সেকেন্ড পর পর
   observable.subscribe(console.log);
   // আউটপুট: 0, 1, 2, 3, ...
   

4. timer:
   timer অপারেটরটি একটি নির্দিষ্ট বিলম্ব পরে একটি সংখ্যা পাঠায় এবং এরপর একটি পুনরাবৃত্তি শুরু করে।

   উদাহরণ:

   import { timer } from 'rxjs';
   
   const observable = timer(2000, 1000); // ২ সেকেন্ড পর শুরু হবে এবং প্রতি ১ সেকেন্ডে একটি সংখ্যা পাঠাবে
   observable.subscribe(console.log);
   // আউটপুট: 0, 1, 2, 3, ...
   

সারাংশ

RxJS-এর Pipeable Operators এবং Creation Operators দুটি মৌলিক উপাদান যা আপনাকে ডেটা স্ট্রিমের উপর বিভিন্ন কার্যক্রম করতে সাহায্য করে। Pipeable Operators ব্যবহার করে আপনি একাধিক অপারেশন চেইন করতে পারেন এবং Creation Operators ব্যবহার করে আপনি নতুন Observable তৈরি করতে পারেন। এগুলি RxJS ব্যবহার করে অ্যাসিঙ্ক্রোনাস ডেটা এবং ইভেন্ট স্ট্রিমগুলির সাথে কার্যকরভাবে কাজ করার জন্য অপরিহার্য টুল।

RxJS-এ Operators এমন ফাংশন যা Observable ডেটা স্ট্রিমের উপর কাজ করে, এবং তাদের বিভিন্ন ধরনের অপারেশন করতে সহায়ক। এই অপারেটরগুলোকে সাধারণত পাঁচটি মূল শ্রেণীতে ভাগ করা যায়: Transformation, Filtering, Combination, Error Handling, এবং Utility।

এখানে এই অপারেটরগুলির প্রতিটির ব্যাখ্যা এবং কিছু উদাহরণ দেওয়া হলো।

Transformation Operators

Transformation operators একটি Observable-এর মান পরিবর্তন বা রূপান্তর করতে ব্যবহৃত হয়। এর মাধ্যমে আপনি আসা ডেটাকে একটি নতুন ফর্ম্যাটে পরিবর্তন করতে পারেন, যেমন একটি মানকে ম্যাপ করা বা অ্যারে তৈরির জন্য রূপান্তর করা।

• map(): এটি একটি মানকে পরিবর্তন করে একটি নতুন মান তৈরি করে।
• pluck(): এটি একটি নির্দিষ্ট প্রপার্টি থেকে মান বের করে।
• scan(): এটি একটি অ্যাকুমুলেটর ফাংশন প্রয়োগ করে ক্রমান্বয়ে মান সংগ্রহ করে।

উদাহরণ:

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

const observable = of(1, 2, 3);

observable.pipe(
  map(x => x * 10)
).subscribe(console.log);

এখানে, map() অপারেটরটি প্রতিটি মানকে ১০ গুণে রূপান্তর করবে, এবং আউটপুট হবে 10, 20, 30।

Filtering Operators

Filtering operators কোনো Observable থেকে নির্দিষ্ট শর্ত অনুযায়ী ডেটা ফিল্টার বা নির্বাচন করতে ব্যবহৃত হয়। এটি বিশেষভাবে ব্যবহার হয় যখন আপনি কিছু ডেটা প্রক্রিয়া করতে চান যা একটি নির্দিষ্ট শর্ত পূরণ করে।

• filter(): এটি একটি নির্দিষ্ট শর্তের ওপর ভিত্তি করে মান ফিল্টার করে।
• take(): এটি শুধুমাত্র প্রথম N সংখ্যক মান গ্রহণ করে।
• distinct(): এটি ডুপ্লিকেট মানগুলো বাদ দেয়।

উদাহরণ:

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

const observable = of(1, 2, 3, 4, 5);

observable.pipe(
  filter(x => x % 2 === 0)  // শুধু even সংখ্যা
).subscribe(console.log);

এখানে, filter() অপারেটরটি শুধুমাত্র even সংখ্যা গুলোই নির্বাচন করবে এবং আউটপুট হবে 2, 4।

Combination Operators

Combination operators একাধিক Observable-কে একত্রিত করতে ব্যবহৃত হয়। এটি আপনাকে বিভিন্ন স্ট্রিম একত্রিত বা সমন্বিতভাবে পরিচালনা করতে সাহায্য করে।

• merge(): এটি একাধিক Observable কে একত্রিত করে, যেগুলি প্যারালালভাবে চলে।
• concat(): এটি একাধিক Observable কে একত্রিত করে কিন্তু একে একে একটার পর একটি চালানো হয়।
• combineLatest(): এটি একাধিক Observable থেকে সর্বশেষ মান নিয়ে কাজ করে।

উদাহরণ:

import { of } from 'rxjs';
import { merge } from 'rxjs/operators';

const obs1 = of(1, 2);
const obs2 = of(3, 4);

obs1.pipe(
  merge(obs2)
).subscribe(console.log);

এখানে, merge() অপারেটরটি দুটি Observable কে একত্রিত করে এবং আউটপুট হবে 1, 2, 3, 4।

Error Handling Operators

Error handling operators ব্যবহৃত হয় যখন কোনো Observable এর মধ্যে ত্রুটি (error) ঘটে। এই অপারেটরগুলো দ্বারা ত্রুটির ক্ষেত্রেও কার্যক্রম চালানো সম্ভব হয় এবং প্রোগ্রামটি ক্র্যাশ না হয়ে চলতে থাকে।

• catchError(): এটি একটি ত্রুটি ধরতে এবং অন্য একটি Observable দিয়ে পুনরায় চেষ্টা করতে সাহায্য করে।
• retry(): এটি ত্রুটি ঘটলে পুনরায় অপারেশনটি চালাতে সাহায্য করে।

উদাহরণ:

import { of } from 'rxjs';
import { catchError } from 'rxjs/operators';

const observable = new Observable(subscriber => {
  subscriber.next('Data 1');
  subscriber.error('Something went wrong');
});

observable.pipe(
  catchError(error => of('Recovered from error'))  // ত্রুটি ঘটলে নতুন Observable দিয়ে রিপ্লেস
).subscribe(console.log);

এখানে, catchError() ত্রুটির পর একটি নতুন Observable of('Recovered from error') প্রদান করবে এবং আউটপুট হবে 'Recovered from error'।

Utility Operators

Utility operators কিছু কমন কার্যকলাপ সম্পাদন করতে ব্যবহৃত হয়, যেমন টেম্পোরারি ডিলের জন্য বা ডেটার লগিং করার জন্য। এগুলো কোডের ব্যবহারে আরও কার্যকরী হতে সাহায্য করে।

• tap(): এটি Observable এর মধ্যবর্তী কোনো পর্যায়ে কার্যকলাপ (যেমন লগিং) করার জন্য ব্যবহৃত হয়, কিন্তু এটি Observable-এর মূল প্রবাহ পরিবর্তন করে না।
• finalize(): এটি সম্পূর্ণ হওয়ার পর কোনো ফাংশন চালানোর জন্য ব্যবহৃত হয় (যেমন ক্লিনআপ কোড)।

উদাহরণ:

import { of } from 'rxjs';
import { tap } from 'rxjs/operators';

const observable = of(1, 2, 3);

observable.pipe(
  tap(value => console.log('Value:', value))  // মান গুলোর লগিং
).subscribe(console.log);

এখানে, tap() অপারেটরটি প্রতি মানের জন্য লগ প্রিন্ট করবে, এবং আউটপুট হবে:

Value: 1
1
Value: 2
2
Value: 3
3

সারাংশ

RxJS-এ Operators এর বিভিন্ন শ্রেণী রয়েছে, যেমন Transformation, Filtering, Combination, Error Handling, এবং Utility। প্রতিটি শ্রেণীর অপারেটর আলাদা আলাদা উদ্দেশ্য সম্পাদন করে এবং Observable ডেটার ওপর নানা ধরনের কার্যক্রম পরিচালনা করে। এই অপারেটরগুলো আপনাকে আরও ক্ষমতাশালী, রিয়্যাক্টিভ, এবং অ্যাসিঙ্ক্রোনাস প্রোগ্রামিং করতে সহায়ক হয়।

RxJS (Reactive Extensions for JavaScript) অ্যাসিঙ্ক্রোনাস প্রোগ্রামিংয়ে ব্যবহৃত একটি শক্তিশালী লাইব্রেরি, যা Observables (ডেটা স্ট্রিম) এবং Operators ব্যবহার করে ডেটা প্রক্রিয়া করতে সাহায্য করে। RxJS এ pipe() এবং subscribe() দুটি গুরুত্বপূর্ণ মেথড, যা Observables এবং অপারেটরের মাধ্যমে ডেটা স্ট্রিম পরিচালনার জন্য ব্যবহৃত হয়।

pipe() মেথড

pipe() হল একটি অত্যন্ত গুরুত্বপূর্ণ ফাংশন, যা RxJS-এর Operators এর সাথে একাধিক অপারেশন চেইন করতে ব্যবহৃত হয়। এটি একটি ফাংশনাল প্রোগ্রামিং প্যাটার্নে কাজ করে এবং ডেটা স্ট্রিমের উপর একটি বা একাধিক অপারেশন পরিচালনা করে।

pipe() এর বৈশিষ্ট্য:

• চেইনেবল অপারেটর: pipe() মেথড ব্যবহার করে একাধিক অপারেটরকে চেইন করা যায়, যেমন map, filter, merge, debounceTime ইত্যাদি।
• ডেটা ট্রান্সফরমেশন: আপনি অপারেটরগুলির মাধ্যমে ডেটা স্ট্রিমকে পরিবর্তন বা ট্রান্সফর্ম করতে পারেন।
• সময়সীমা নিয়ন্ত্রণ: কিছু অপারেটর যেমন debounceTime ব্যবহার করে আপনি স্ট্রিমের গতির উপর নিয়ন্ত্রণ রাখতে পারেন।

উদাহরণ:

import { of } from 'rxjs';
import { map, filter } from 'rxjs/operators';

const observable = of(1, 2, 3, 4, 5);

observable.pipe(
  filter(x => x % 2 === 0), // ফিল্টার করে শুধু even সংখ্যা
  map(x => x * 10) // প্রতিটি মানকে ১০ গুণ করবে
).subscribe(result => console.log(result));

এখানে, pipe() মেথডটি filter এবং map অপারেটরগুলিকে চেইন করে, যাতে even সংখ্যাগুলোকে ১০ গুণ করা হয়। আউটপুট হবে:

20
40

subscribe() মেথড

subscribe() মেথড হলো RxJS-এর অবজার্ভেবল থেকে ডেটা গ্রহণ করার জন্য ব্যবহৃত একটি মেথড। এটি অবজার্ভেবল স্ট্রিমের সাথে যুক্ত হয়ে ডেটা গ্রহণ শুরু করে এবং নির্দিষ্ট প্রক্রিয়া (callback) কল করে যখন কোনো নতুন মান আসে।

subscribe() এর বৈশিষ্ট্য:

• ডেটা প্রাপ্তি: subscribe() মেথডের মাধ্যমে, আপনি অবজার্ভেবল স্ট্রিম থেকে ডেটা গ্রহণ করতে পারেন।
• কনফিগারেশন: subscribe() এর মধ্যে আপনি next, error, এবং complete হ্যান্ডলারগুলিকে ডিফাইন করতে পারেন, যা ডেটার স্ট্রিমের বিভিন্ন স্টেজে প্রতিক্রিয়া জানায়।
  • next(): নতুন ডেটা স্ট্রিমের মান গ্রহণ করে।
  • error(): কোনো ত্রুটি (error) হলে তা হ্যান্ডেল করে।
  • complete(): স্ট্রিম শেষ হলে এটি কল হয়।

উদাহরণ:

import { of } from 'rxjs';

const observable = of(1, 2, 3, 4, 5);

observable.subscribe({
  next(x) { console.log('Next:', x); }, // নতুন ডেটা মান দেখাবে
  complete() { console.log('Completed!'); } // যখন স্ট্রিম শেষ হবে
});

এখানে, subscribe() মেথডটি ডেটার প্রতি প্রতিক্রিয়া জানাতে ব্যবহৃত হয়েছে এবং next() কলব্যাক ফাংশনটি প্রতিটি মান প্রিন্ট করবে। আউটপুট হবে:

Next: 1
Next: 2
Next: 3
Next: 4
Next: 5
Completed!

pipe() এবং subscribe() এর সমন্বয়

RxJS-এ pipe() এবং subscribe() দুটি মেথড সাধারণত একসাথে ব্যবহৃত হয়। প্রথমত, pipe() মেথডটি ডেটা স্ট্রিমের উপর একাধিক অপারেটর প্রয়োগ করে এবং তারপর subscribe() মেথডটির মাধ্যমে সেই পরিবর্তিত ডেটা স্ট্রিমের ফলাফল গ্রহণ করা হয়।

উদাহরণ:

import { interval } from 'rxjs';
import { take, map } from 'rxjs/operators';

const observable = interval(1000).pipe(
  take(5), // ৫টি মান নেবে
  map(x => x * 2) // প্রতিটি মানকে ২ গুণ করবে
);

observable.subscribe({
  next(x) { console.log(x); }, // প্রতি এক সেকেন্ডে ২ গুণ মান প্রিন্ট হবে
  complete() { console.log('Completed!'); }
});

এখানে, interval(1000) প্রতি সেকেন্ডে একটি মান প্রদান করে। pipe() ব্যবহার করে আমরা প্রথমে take(5) দিয়ে শুধুমাত্র ৫টি মান নিলাম, এরপর map() অপারেটর দিয়ে প্রতিটি মানকে ২ গুণ করেছি। subscribe() মেথডটি ডেটা স্ট্রিমের ফলাফল গ্রহণ করে এবং প্রতি সেকেন্ডে ২ গুণ মান প্রদর্শন করে।

আউটপুট হবে:

0
2
4
6
8
Completed!

সারাংশ

• pipe() মেথড: এটি RxJS এর অপারেটরগুলিকে চেইন করতে ব্যবহৃত হয়। আপনি একাধিক অপারেটর ব্যবহার করে ডেটা স্ট্রিমের উপর কার্যকরী ট্রান্সফরমেশন এবং ফিল্টারিং করতে পারেন।
• subscribe() মেথড: এটি অবজার্ভেবল থেকে ডেটা গ্রহণ করতে ব্যবহৃত হয়। এটি next(), error(), এবং complete() কনফিগারেশন গ্রহণ করে, যা ডেটার স্ট্রিমের প্রতিটি ধাপের প্রতিক্রিয়া জানাতে সাহায্য করে।

এই দুটি মেথডের সমন্বয়ে RxJS ডেটা স্ট্রিম এবং অ্যাসিঙ্ক্রোনাস কার্যক্রম পরিচালনার জন্য একটি শক্তিশালী টুল সরবরাহ করে।