JavaScript-ში Observable ობიექტი რომელ მონაცემთა სტრუქტურას ჰგავს?

දත්ත ව්‍යුහය සීතල Observable (ඉංග්‍රීසි Cold Observable), එය ප්‍රතික්‍රියාවකරණ වැඩසටහනේ සංකල්පයක් (උදාහරණයක් ලෙස RxJS පුස්තකාලයේ).

ප්‍රධාන සමානතා:

• අහිතකර ස්වභාවය: Observable එක සක්‍රීය වන්නේ පමණක් ලිපිගොනුකරු (subscriber) පවතින විට පමණි. ලිපිගොනුකරු නොමැතිනම්, Observable ක්‍රියාකාරී නොවේ.
• බොහෝ ලිපිගොනුකරු, ස්වාධීන නාලිකා: නව ලිපිගොනුකරු එක් එක් ආරම්භක අගයන් සම්පූර්ණයෙන් ලබා ගනී, අනෙක් ලිපිගොනුකරුන්ගෙන් ස්වාධීනව. මෙය සෑම ලිපිගොනුකරුටම ස්වාධීන දත්ත නාලිකා නිර්මාණය කරයි.

උදාහරණයක් ලෙස, සීතල observable ව්‍යුහය (සංකල්පික):

// මෙය කිසිවක් "උත්පාදක" ලෙස සැලකිය හැක
function generateValues() {
  let i = 0;
  return {
    // ක්‍රමය, එය ඊළඟ අගය ආපසු දෙයි (ඒක ඉල්ලූ විට)
    next: function() {
      return { value: i++, done: false };
    }
  };
}

// "Observable" - මූලිකව, සරල ක්‍රියාවලියක්, එය ලිපිගොනුකරු ලබා ගනී
function coldObservableExample(subscriber) {
  const generator = generateValues();

  // අගයන් නිකුත් කිරීමේ අනුකරණය
  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 100);

  setTimeout(() => {
    subscriber.next(generator.next().value);
  }, 200);

  setTimeout(() => {
    subscriber.complete(); // නාලිකා අවසන්
  }, 300);

  // ලිපිගොනුකරු වස්තුව ආපසු ලබා දීම (අවලංගු කිරීම)
  return {
    unsubscribe: () => {
      console.log('අවලංගු කිරීම');
      // මෙහි, ජනකය/කාලගුණ නවතා දැමීමේ තර්කය තිබිය හැක
    }
  };
}

// පළමු ලිපිගොනුකරු
const subscription1 = coldObservableExample({
  next: (value) => console.log('ලිපිගොනුකරු 1 ලබා ගත්තේ:', value),
  error: (err) => console.error('දෝෂය 1:', err),
  complete: () => console.log('ලිපිගොනුකරු 1 අවසන්')
});

// දෙවැනි ලිපිගොනුකරු (ආරම්භයෙන් අරඹයි)
setTimeout(() => {
  const subscription2 = coldObservableExample({
    next: (value) => console.log('ලිපිගොනුකරු 2 ලබා ගත්තේ:', value),
    error: (err) => console.error('දෝෂය 2:', err),
    complete: () => console.log('ලිපිගොනුකරු 2 අවසන්')
  });
}, 150);

// පළමු ලිපිගොනුකරු අහෝසි කිරීම
setTimeout(() => {
  subscription1.unsubscribe();
}, 250);

උණුසුම් observable (Hot Observable) සමඟ වෙනස්ව, එය වහාම අගයන් නිකුත් කිරීමට ආරම්භ කරයි, ලිපිගොනුකරුන්ගෙන් ස්වාධීනව, සහ සියලු ලිපිගොනුකරුන්ට අගයන් ලබා ගත හැක, මොහොතේ ලියාපදිංචි වීමේ සිට, නමුත් සීතල observable එක සෑම නව ලිපිගොනුකරුටම සම්පූර්ණ දත්ත නාලිකාව රඳවාගෙන නැවත නිකුත් කරයි. මෙම ගුණාංගය එය JavaScript Observable (RxJS සහ සමාන පුස්තකාලවල) සංකල්පයට ආසයි.

සරලව සසඳුම:

ලක්ෂණය	සීතල Observable	උණුසුම් Observable
ආරම්භය	ලියාපදිංචිය සමඟ	තත්පරික
නාලිකාව ලිපිගොනුකරුන්ට	සම්පූර්ණ නාලිකාව සෑම අයට	ලියාපදිංචි වීමේ මොහොතෙන් අගයන්
භාවිතය	HTTP ඉල්ලීම්, ගොනු කියවීම, ආවරණ	DOM සිදුවීම්, වෙබ් සොකට්, වේලාවන්