ასინქრონული პროგრამირება JavaScript-ში (Callback, Promise, RxJs)

Სალამი ყველას. სერგეი ომელნიცკი დაუკავშირდა. ცოტა ხნის წინ მე ვუმასპინძლე სტრიმინგს რეაქტიული პროგრამირების შესახებ, სადაც ვისაუბრე ასინქრონულობაზე JavaScript-ში. დღეს მსურს ამ მასალის შესახებ შენიშვნები გავაკეთო.

მაგრამ სანამ მთავარ მასალას დავიწყებთ, შესავალი შენიშვნა უნდა გავაკეთოთ. მოდით დავიწყოთ განმარტებებით: რა არის სტეკი და რიგი?

დასტის არის კოლექცია, რომლის ელემენტები მიიღება ბოლო შესვლის, პირველი გამოსვლის LIFO საფუძველზე

რიგში არის კოლექცია, რომლის ელემენტები მიიღება პირველი შესვლის, პირველი გამოსვლის FIFO საფუძველზე

კარგი, გავაგრძელოთ.

JavaScript არის ერთნაკადიანი პროგრამირების ენა. ეს ნიშნავს, რომ არსებობს შესრულების მხოლოდ ერთი ძაფი და ერთი დასტა, რომელზეც ფუნქციები დგას შესასრულებლად. ამიტომ, JavaScript-ს შეუძლია შეასრულოს მხოლოდ ერთი ოპერაცია ერთდროულად, ხოლო სხვა ოპერაციები დაელოდება თავის რიგს სტეკზე, სანამ არ გამოიძახებენ.

ზარის დასტა არის მონაცემთა სტრუქტურა, რომელიც, მარტივად რომ ვთქვათ, იწერს ინფორმაციას იმ ადგილის შესახებ პროგრამაში, სადაც ჩვენ ვართ. თუ ფუნქციაში გადავდივართ, მის შესვლას დავაყენებთ სტეკის ზედა ნაწილში. როდესაც ვბრუნდებით ფუნქციიდან, ჩვენ გამოვყოფთ ყველაზე ზედა ელემენტს დასტადან და ვასრულებთ იქ, სადაც ფუნქციას ვუწოდებთ. ეს არის ყველაფერი, რისი გაკეთებაც სტეკს შეუძლია. ახლა კი ძალიან საინტერესო კითხვა. მაშინ როგორ მუშაობს ასინქრონულობა JavasScript-ში?

სინამდვილეში, სტეკის გარდა, ბრაუზერებს აქვთ სპეციალური რიგი ე.წ. WebAPI-სთან მუშაობისთვის. ფუნქციები ამ რიგში შესრულდება თანმიმდევრობით მხოლოდ მას შემდეგ, რაც დასტა მთლიანად გასუფთავდება. მხოლოდ ამის შემდეგ ისინი მოთავსებულია რიგიდან დასტაზე შესასრულებლად. თუ დასტაზე არის მინიმუმ ერთი ელემენტი ამ მომენტში, მაშინ ისინი ვერ მოხვდებიან სტეკზე. მხოლოდ ამის გამო, ფუნქციების გამოძახება დროის ამოწურვით ხშირად არაზუსტია, ვინაიდან ფუნქცია ვერ მოხვდება რიგიდან დასტამდე, სანამ ის სავსეა.

მოდით შევხედოთ შემდეგ მაგალითს და დავიწყოთ მისი ეტაპობრივი შესრულება. ვნახოთ ასევე რა ხდება სისტემაში.

console.log('Hi');
setTimeout(function cb1() {
    console.log('cb1');
}, 5000);
console.log('Bye');

1) ჯერ არაფერი ხდება. ბრაუზერის კონსოლი ნათელია, ზარის დასტა ცარიელია.

2) შემდეგ ბრძანება console.log('Hi') ემატება ზარის დასტას.

3) და სრულდება

4) შემდეგ console.log('Hi') ამოღებულია ზარის დასტადან.

5) ახლა გადადით ბრძანებაზე setTimeout (ფუნქცია cb1() {… }). ის ემატება ზარების დასტას.

6) setTimeout(ფუნქცია cb1() {… }) ბრძანება შესრულებულია. ბრაუზერი ქმნის ტაიმერს, რომელიც არის ვებ API-ს ნაწილი. ის შეასრულებს უკუთვლას.

7) setTimeout(function cb1() {… }) ბრძანებამ დაასრულა მუშაობა და ამოღებულია ზარის დასტადან.

8) ბრძანება console.log('Bye') ემატება ზარის დასტას.

9) console.log('Bye') ბრძანება შესრულებულია.

10) ბრძანება console.log('Bye') ამოღებულია ზარის დასტადან.

11) მას შემდეგ, რაც მინიმუმ 5000 ms გავიდა, ტაიმერი მთავრდება და აყენებს cb1 გამოძახებას უკურეკვის რიგში.

12) მოვლენის მარყუჟი იღებს cb1 ფუნქციას გამოძახების რიგიდან და უბიძგებს მას ზარის დასტაზე.

13) ფუნქცია cb1 შესრულებულია და ამატებს console.log('cb1') ზარის დასტას.

14) ბრძანება console.log('cb1') შესრულებულია.

15) ბრძანება console.log('cb1') ამოღებულია ზარის დასტადან.

16) ფუნქცია cb1 ამოღებულია ზარის დასტადან.

მოდით შევხედოთ მაგალითს დინამიკაში:

კარგად, ჩვენ შევხედეთ, თუ როგორ ხდება ასინქრონულობა JavaScript-ში. ახლა მოკლედ ვისაუბროთ ასინქრონული კოდის ევოლუციაზე.

ასინქრონული კოდის ევოლუცია.

a(function (resultsFromA) {
    b(resultsFromA, function (resultsFromB) {
        c(resultsFromB, function (resultsFromC) {
            d(resultsFromC, function (resultsFromD) {
                e(resultsFromD, function (resultsFromE) {
                    f(resultsFromE, function (resultsFromF) {
                        console.log(resultsFromF);
                    })
                })
            })
        })
    })
});

ასინქრონული პროგრამირება, როგორც ჩვენ ვიცით JavaScript-ში, შეიძლება განხორციელდეს მხოლოდ ფუნქციებით. ისინი შეიძლება გადაეცეს, როგორც ნებისმიერი სხვა ცვლადი სხვა ფუნქციებს. ასე დაიბადა გამოძახებები. და ეს არის მაგარი, მხიარული და მხიარული, სანამ არ გადაიქცევა სევდაში, სევდაში და სევდაში. რატომ? Ეს მარტივია:

• კოდის სირთულის მატებასთან ერთად, პროექტი სწრაფად იქცევა ბუნდოვან, არაერთხელ ჩადგმულ ბლოკებად - „დაბრუნების ჯოჯოხეთი“.
• შეცდომების დამუშავება შეიძლება ადვილად გამოტოვოთ.
• თქვენ არ შეგიძლიათ დააბრუნოთ გამონათქვამები დაბრუნებით.

Promise-ის მოსვლასთან ერთად სიტუაცია ოდნავ გაუმჯობესდა.

new Promise(function(resolve, reject) {
    setTimeout(() => resolve(1), 2000);

}).then((result) => {
    alert(result);
    return result + 2;

}).then((result) => {
    throw new Error('FAILED HERE');
    alert(result);
    return result + 2;

}).then((result) => {
    alert(result);
    return result + 2;

}).catch((e) => {
    console.log('error: ', e);
});

• გაჩნდა დაპირების ჯაჭვები, რამაც გააუმჯობესა კოდის კითხვადობა
• არსებობდა შეცდომების აღკვეთის ცალკე მეთოდი
• დამატებულია პარალელური შესრულების შესაძლებლობა Promise.all-ის გამოყენებით
• ჩვენ შეგვიძლია გადავჭრათ ჩადგმული ასინქრონულობა ასინქრონიზაციის/მოლოდინის გამოყენებით

მაგრამ დაპირებებს თავისი შეზღუდვები აქვს. მაგალითად, დაპირება არ შეიძლება გაუქმდეს ტამბურით ცეკვის გარეშე და რაც მთავარია, ის მუშაობს ერთი ღირებულებით.

კარგად, ჩვენ შეუფერხებლად მივუახლოვდით რეაქტიულ პროგრამირებას. დაიღალა? კარგი, საბედნიეროდ, შეგიძლია წახვიდე ჩაის დალევა, დაფიქრდე და დაბრუნდე და მეტი წაიკითხო. და გავაგრძელებ.

რეაქტიული პროგრამირება - პროგრამირების პარადიგმა, რომელიც ორიენტირებულია მონაცემთა ნაკადებზე და ცვლილებების გავრცელებაზე. მოდით უფრო დეტალურად განვიხილოთ რა არის მონაცემთა ნაკადი.

// Получаем ссылку на элемент
const input = ducument.querySelector('input');

const eventsArray = [];

// Пушим каждое событие в массив eventsArray
input.addEventListener('keyup',
    event => eventsArray.push(event)
);

წარმოვიდგინოთ, რომ გვაქვს შეყვანის ველი. ჩვენ ვქმნით მასივს და შეყვანის მოვლენის ყოველი კლავიშისთვის ჩვენ ვინახავთ მოვლენას ჩვენს მასივში. ამასთან, მინდა აღვნიშნო, რომ ჩვენი მასივი დალაგებულია დროის მიხედვით, ე.ი. გვიანდელი მოვლენების ინდექსი უფრო დიდია, ვიდრე ადრინდელი მოვლენების ინდექსი. ასეთი მასივი არის მონაცემთა ნაკადის გამარტივებული მოდელი, მაგრამ ის ჯერ არ არის ნაკადი. იმისათვის, რომ ამ მასივს უსაფრთხოდ ეწოდოს ნაკადი, მან უნდა შეძლოს როგორმე აცნობოს აბონენტებს, რომ მასში ახალი მონაცემები შემოვიდა. ამრიგად, ჩვენ მივდივართ ნაკადის განსაზღვრებამდე.

მონაცემთა ნაკადი

const { interval } = Rx;
const { take } = RxOperators;

interval(1000).pipe(
    take(4)
)

ნაკადი არის დროის მიხედვით დალაგებული მონაცემების მასივი, რომელიც შეიძლება მიუთითებდეს, რომ მონაცემები შეიცვალა. ახლა წარმოიდგინეთ, რამდენად მოსახერხებელია კოდის დაწერა, რომელშიც ერთი მოქმედება მოითხოვს რამდენიმე მოვლენის გამოძახებას კოდის სხვადასხვა ნაწილში. ჩვენ უბრალოდ გამოვწერთ სტრიმინგს და ის შეგვატყობინებს, როდესაც მოხდება ცვლილებები. და RxJs ბიბლიოთეკას შეუძლია ამის გაკეთება.

RxJS არის ბიბლიოთეკა ასინქრონულ და მოვლენებზე დაფუძნებულ პროგრამებთან მუშაობისთვის დაკვირვებადი მიმდევრობების გამოყენებით. ბიბლიოთეკა გთავაზობთ ძირითად ტიპს დაკვირვებულიარამდენიმე დამხმარე ტიპი (დამკვირვებლები, განრიგები, სუბიექტები) და ოპერატორები მოვლენებთან, ისევე როგორც კოლექციებთან მუშაობისთვის (რუკა, ფილტრი, შემცირება, ყოველი და მსგავსი JavaScript Array-დან).

მოდით გავიგოთ ამ ბიბლიოთეკის ძირითადი ცნებები.

დაკვირვებადი, დამკვირვებელი, პროდიუსერი

დაკვირვებადი არის პირველი ბაზის ტიპი, რომელსაც ჩვენ განვიხილავთ. ეს კლასი შეიცავს RxJs განხორციელების ძირითად ნაწილს. ის ასოცირდება დაკვირვებად ნაკადთან, რომლის გამოწერა შესაძლებელია გამოწერის მეთოდის გამოყენებით.

Observable ახორციელებს განახლებების შექმნის დამხმარე მექანიზმს, ე.წ დამკვირვებელთა. Observer-ისთვის ღირებულებების წყარო ეწოდება წითელი მშრალი ღვინო. ეს შეიძლება იყოს მასივი, იტერატორი, ვებ სოკეტი, რაიმე სახის მოვლენა და ა.შ. ასე რომ, შეგვიძლია ვთქვათ, რომ დაკვირვებადი არის გამტარი პროდიუსერსა და დამკვირვებელს შორის.

Observable მართავს სამი სახის დამკვირვებლის მოვლენებს:

• შემდეგი - ახალი მონაცემები
• შეცდომა - შეცდომა, თუ თანმიმდევრობა შეწყდა გამონაკლისის გამო. ეს მოვლენა ასევე გულისხმობს მიმდევრობის დასასრულს.
• სრული - სიგნალი თანმიმდევრობის დასრულების შესახებ. ეს ნიშნავს, რომ ახალი მონაცემები აღარ იქნება.

ვნახოთ დემო ვერსია:

დასაწყისში ჩვენ დავამუშავებთ მნიშვნელობებს 1, 2, 3 და 1 წამის შემდეგ. ჩვენ მივიღებთ 4-ს და დავასრულებთ ჩვენს ნაკადს.

ხმამაღლა ფიქრი

შემდეგ მივხვდი, რომ ამის თქმა უფრო საინტერესო იყო, ვიდრე წერა. 😀

გამოწერა

როდესაც ჩვენ ვიწერთ ნაკადს, ჩვენ ვქმნით ახალ კლასს გამოწერარაც მეთოდის გამოყენებით გამოწერის გაუქმების შესაძლებლობას გვაძლევს გაუქმება. ჩვენ ასევე შეგვიძლია გამოწერების დაჯგუფება მეთოდის გამოყენებით დავამატებთ. ისე, ლოგიკურია, რომ ჩვენ შეგვიძლია გავაერთიანოთ ძაფები გამოყენებით ამოიღონ. დამატებისა და წაშლის მეთოდები იღებენ სხვა გამოწერას შეყვანად. მინდა აღვნიშნო, რომ გამოწერის გაუქმებისას, ჩვენ ვხსნით ყველა ბავშვის გამოწერას, თითქოს მათ ასევე უწოდეს გამოწერის გაუქმება. Განაგრძე.

ნაკადების სახეები

ცხელი
ᲪᲘᲕᲘ

პროდიუსერი იქმნება დაკვირვებადობის მიღმა
პროდიუსერი იქმნება დაკვირვებადი შიგნით

მონაცემთა გადაცემა ხდება დაკვირვების შექმნის დროს
მონაცემები მოწოდებულია გამოწერის დროს.

მეტი ლოგიკაა საჭირო გამოწერის გასაუქმებლად
თემა თავისთავად წყდება

იყენებს ერთ-ერთ ბევრ ურთიერთობას
იყენებს ერთერთ ურთიერთობას

ყველა გამოწერას ერთი და იგივე მნიშვნელობა აქვს
გამოწერები დამოუკიდებელია

მონაცემები შეიძლება დაიკარგოს, თუ გამოწერა არ არის
ხელახლა გამოსცემს ნაკადის ყველა მნიშვნელობას ახალი გამოწერისთვის

ანალოგიის რომ მოვიყვან, ცხელ ნაკადს მოვიფიქრებ, როგორც კინოს თეატრში. დროის რომელ მომენტში ჩამოხვედი, იმ მომენტიდან დაიწყე ყურება. მე შევადარებდი ცივ ნაკადს ტექნიკურ ზარს. მხარდაჭერა. ნებისმიერი აბონენტი უსმენს ხმოვანი ფოსტის ჩანაწერს თავიდან ბოლომდე, მაგრამ შეგიძლიათ გათიშოთ გამოწერის გაუქმებით.

მინდა აღვნიშნო, რომ არის ეგრეთ წოდებული თბილი ნაკადებიც (ასეთი განსაზღვრება ძალიან იშვიათად და მხოლოდ უცხო თემებში შემხვედრია) - ეს არის ნაკადი, რომელიც ცივი ნაკადიდან ცხელში გარდაიქმნება. ჩნდება კითხვა - სად გამოვიყენოთ)) მაგალითს მოვიყვან პრაქტიკიდან.

მე ვმუშაობ Angular-თან. ის აქტიურად იყენებს rxjs-ს. სერვერზე მონაცემების მისაღებად, ველოდები ცივ თემას და გამოვიყენებ ამ თემას შაბლონში asyncPipe-ის გამოყენებით. თუ ამ მილს რამდენჯერმე გამოვიყენებ, მაშინ, ცივი ნაკადის განმარტებას დავუბრუნდები, თითოეული მილი ითხოვს მონაცემებს სერვერისგან, რაც რბილად რომ ვთქვათ უცნაურია. და თუ ცივ ნაკადს გადავიყვან თბილად, მაშინ მოთხოვნა ერთხელ მოხდება.

ზოგადად, ნაკადების ტიპის გაგება საკმაოდ რთულია დამწყებთათვის, მაგრამ მნიშვნელოვანია.

ოპერატორები

return this.http.get(`${environment.apiUrl}/${this.apiUrl}/trade_companies`)
    .pipe(
        tap(({ data }: TradeCompanyList) => this.companies$$.next(cloneDeep(data))),
        map(({ data }: TradeCompanyList) => data)
    );

ოპერატორები გვაძლევენ შესაძლებლობას გავაფართოვოთ ნაკადებთან მუშაობის უნარი. ისინი ეხმარებიან დაკვირვებადში მომხდარი მოვლენების კონტროლს. ჩვენ განვიხილავთ რამდენიმე ყველაზე პოპულარულს და მეტი დეტალი ოპერატორების შესახებ შეგიძლიათ იხილოთ სასარგებლო ინფორმაციის ბმულების გამოყენებით.

ოპერატორები - დან

დავიწყოთ დამხმარე ოპერატორით. ის ქმნის Observable-ს მარტივი მნიშვნელობის საფუძველზე.

ოპერატორები - ფილტრი

ფილტრის ოპერატორი, როგორც სახელი გვთავაზობს, ფილტრავს ნაკადის სიგნალს. თუ ოპერატორი დააბრუნებს true, მაშინ ის გამოტოვებს შემდგომ.

ოპერატორები - იღებენ

take — იღებს ემიტერების რაოდენობის მნიშვნელობას, რის შემდეგაც ძაფი მთავრდება.

Operators-debounceTime

debounceTime - უგულებელყოფს ემიტირებული მნიშვნელობებს, რომლებიც ხვდება გამოტანებს შორის მითითებულ დროის ინტერვალში - დროის ინტერვალის გავლის შემდეგ, გამოსცემს ბოლო მნიშვნელობას.

const { Observable } = Rx;
const { debounceTime, take } = RxOperators;

Observable.create((observer) => {
  let i = 1;
  observer.next(i++);
  // Испускаем значение раз в 1000мс
  setInterval(() => {
    observer.next(i++)
  }, 1000);

 // Испускаем значение раз в 1500мс
  setInterval(() => {
    observer.next(i++)
  }, 1500);
}).pipe(
  debounceTime(700),  // Ожидаем 700мс значения прежде чем обработать
  take(3)
);  

ოპერატორები-takeWhile

ასხივებს მნიშვნელობებს, სანამ takeWhile არ დააბრუნებს false-ს, რის შემდეგაც ის გააუქმებს თემას.

const { Observable } = Rx;
const { debounceTime, takeWhile } = RxOperators;

Observable.create((observer) => {
  let i = 1;
  observer.next(i++);
  // Испускаем значение раз в 1000мс
  setInterval(() => {
    observer.next(i++)
  }, 1000);
}).pipe(
  takeWhile( producer =>  producer < 5 )
);  

ოპერატორები - combinationLatest

კომბინირებული ოპერატორი combineLatest გარკვეულწილად ჰგავს soz.all-ს. ის აერთიანებს მრავალ ნაკადს ერთში. მას შემდეგ, რაც თითოეულ ძაფს აქვს მინიმუმ ერთი გამოსხივება, ჩვენ ვიღებთ უახლეს მნიშვნელობებს თითოეულიდან მასივის სახით. გარდა ამისა, კომბინირებული ნაკადებიდან ნებისმიერი გამოსხივების შემდეგ, ის მისცემს ახალ მნიშვნელობებს.

const { combineLatest, Observable } = Rx;
const { take } = RxOperators;

const observer_1 = Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 1000мс
  setInterval(() => {
    observer.next('a: ' + i++);
  }, 1000);
});

const observer_2 = Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 750мс
  setInterval(() => {
    observer.next('b: ' + i++);
  }, 750);
});

combineLatest(observer_1, observer_2).pipe(take(5));

ოპერატორები-zip

Zip - ელოდება მნიშვნელობას თითოეული ძაფიდან და აყალიბებს მასივს ამ მნიშვნელობების საფუძველზე. თუ მნიშვნელობა არ მოდის რომელიმე ძაფიდან, მაშინ ჯგუფი არ ჩამოყალიბდება.

const { zip, Observable } = Rx;
const { take } = RxOperators;

const observer_1 = Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 1000мс
  setInterval(() => {
    observer.next('a: ' + i++);
  }, 1000);
});

const observer_2 = Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 750
  setInterval(() => {
    observer.next('b: ' + i++);
  }, 750);
});

const observer_3 = Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 500
  setInterval(() => {
    observer.next('c: ' + i++);
  }, 500);
});

zip(observer_1, observer_2, observer_3).pipe(take(5));

ოპერატორები - forkJoin

forkJoin ასევე უერთდება ძაფებს, მაგრამ ის გამოსცემს მნიშვნელობას მხოლოდ მაშინ, როდესაც ყველა თემა დასრულებულია.

const { forkJoin, Observable } = Rx;
const { take } = RxOperators;

const observer_1 = Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 1000мс
  setInterval(() => {
    observer.next('a: ' + i++);
  }, 1000);
}).pipe(take(3));

const observer_2 = Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 750
  setInterval(() => {
    observer.next('b: ' + i++);
  }, 750);
}).pipe(take(5));

const observer_3 = Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 500
  setInterval(() => {
    observer.next('c: ' + i++);
  }, 500);
}).pipe(take(4));

forkJoin(observer_1, observer_2, observer_3);

ოპერატორების რუკა

რუკის ტრანსფორმაციის ოპერატორი გარდაქმნის ემიტერის მნიშვნელობას ახალში.

const {  Observable } = Rx;
const { take, map } = RxOperators;

Observable.create((observer) => {
  let i = 1;
  // Испускаем значение раз в 1000мс
  setInterval(() => {
    observer.next(i++);
  }, 1000);
}).pipe(
  map(x => x * 10),
  take(3)
);

ოპერატორები - გააზიარეთ, შეეხეთ

ონკანის ოპერატორი საშუალებას გაძლევთ გააკეთოთ გვერდითი მოვლენები, ანუ ნებისმიერი ქმედება, რომელიც არ იმოქმედებს თანმიმდევრობაზე.

წილი კომუნალური ოპერატორს შეუძლია ცივი ნაკადი გადააქციოს ცხელ ნაკადად.

ჩვენ დავასრულეთ ოპერატორებთან. გადავიდეთ თემაზე.

ხმამაღლა ფიქრი

შემდეგ წავედი ჩაის დასალევად. დავიღალე ამ მაგალითებით 😀

საგნობრივი ოჯახი

საგნობრივი ოჯახი ცხელი ძაფების მთავარი მაგალითია. ეს კლასები ერთგვარი ჰიბრიდია, რომელიც ერთდროულად მოქმედებს როგორც დაკვირვებადი და დამკვირვებელი. ვინაიდან თემა არის ცხელი ნაკადი, მისი გამოწერა უნდა გაუქმდეს. თუ ვსაუბრობთ ძირითად მეთოდებზე, მაშინ ესენია:

• შემდეგი - ახალი მონაცემების გადაცემა ნაკადში
• შეცდომა - შეცდომა და ძაფის შეწყვეტა
• სრული - ძაფის დასრულება
• გამოწერა - გამოიწერეთ ნაკადი
• გაუქმება - გამოწერის გაუქმება ნაკადიდან
• asobservable - გადაიქცევა დამკვირვებლად
• toPromise - გარდაიქმნება დაპირებად

არსებობს 4 5 ტიპის საგანი.

ხმამაღლა ფიქრი

სტრიმინგზე 4 ადამიანი საუბრობდა, მაგრამ თურმე ერთი დაამატეს. როგორც ამბობენ, იცხოვრე და ისწავლე.

მარტივი საგანი new Subject()- უმარტივესი სახის საგნები. შექმნილია პარამეტრების გარეშე. გადის მნიშვნელობებს, რომლებიც მოვიდა მხოლოდ გამოწერის შემდეგ.

ქცევის საგანი new BehaviorSubject( defaultData<T> ) – ჩემი აზრით, ყველაზე გავრცელებული ტიპის საგანი. შეყვანა იღებს ნაგულისხმევ მნიშვნელობას. ყოველთვის ინახავს ბოლო გამოშვების მონაცემებს, რომლებიც გადაცემულია გამოწერისას. ამ კლასს ასევე აქვს სასარგებლო მნიშვნელობის მეთოდი, რომელიც აბრუნებს ნაკადის მიმდინარე მნიშვნელობას.

ReplaySubject new ReplaySubject(bufferSize?: number, windowTime?: number) — შეყვანა შეიძლება სურვილისამებრ პირველ არგუმენტად აიღოს მნიშვნელობების ბუფერის ზომა, რომელსაც ის თავისთავად შეინახავს და მეორედ დრო, რომლის დროსაც ჩვენ გვჭირდება ცვლილებები.

AsyncSubject new AsyncSubject() - არაფერი ხდება გამოწერისას და ღირებულება დაბრუნდება მხოლოდ დასრულებისას. დაბრუნდება ნაკადის მხოლოდ ბოლო მნიშვნელობა.

WebSocketSubject new WebSocketSubject(urlConfigOrSource: string | WebSocketSubjectConfig<T> | Observable<T>, destination?: Observer<T>) - მასზე დოკუმენტაცია დუმს და პირველად ვნახე. თუ ვინმემ იცის რას აკეთებს დაწერეთ და დავამატებთ.

ფუ. კარგად, ჩვენ განვიხილეთ ყველაფერი, რისი თქმაც მინდოდა დღეს. იმედია ეს ინფორმაცია სასარგებლო იყო. თქვენ შეგიძლიათ წაიკითხოთ ლიტერატურის სია დამოუკიდებლად სასარგებლო ინფორმაციის ჩანართში.

სასარგებლო ინფორმაცია

• სტრიმინგის ბმული
• როგორ მუშაობს JS: ძრავის მიმოხილვა, მუშაობის დროის მექანიზმები, ზარის დასტა
• როგორ მუშაობს JS: Event Loop, Asynchrony და ხუთი გზა თქვენი კოდის გასაუმჯობესებლად async/wait-ით
• როგორ მუშაობს Event Loop JavaSript-ში
• ასინქრონული JavaScript-ის ევოლუცია
• რა არის RxJS და რატომ არის სასარგებლო ამის შესახებ ცოდნა?
  
• RxJS-ის პრაქტიკული გამოყენება
• RxJS Observables Tutorial — Observables-ის შექმნა და გამოწერა
• RXJS: ცხელი და ცივი დაკვირვებადი
• კლასები, ფუნქციები Observable-ის შესაქმნელად. ოპერატორები.
• RxJS ოპერატორები მაგალითით
• API სია
• საგნისა და განრიგის ვარიაციები RxJS-ში

წყარო: www.habr.com