הקסם של מפעילי שיתוף RXJS וההבדלים ביניהם

בלוג

לפני שנצלול למפעילי שיתוף תחילה עלינו לקבוע איזה סוג של נצפים יש ב- RxJs. בדרך כלל ישנם שני סוגים של נצפים, חַם ו קַר . יש מאמר מעולה תצפיות חמות מול קרות , אבל באופן כללי ההבדל העיקרי הוא זה

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
לדוגמא מרווח () יוצר קור נצפה. הנתונים נוצרים בתוך הנצפה ולכל מנוי חדש ייווצר מרווח חדש
מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
לדוגמה, fromEvent () יוצר חם שניתן לצפות בו מכיוון שמפיק התראות נמצא ב- DOM וקיים ללא קשר למספר המנויים.

לפעמים עלינו לגרום לקור להתראות להתנהג כחם, למשל עם בקשות http. שקול לעקוב אחר דוגמת בקשת http ב- Angular

ngOnInit() { this.user$ = this.http.get(`api/user/1`) this.name$ = this.user$.pipe( map(user => user.name) ); this.age$ = this.user$.pipe( map(user => user.age) ); }

ואנחנו מציגים את שם המשתמש וגילו בתבנית באמצעות צינור אסינכרון (נניח במקומות שונים ולכן לא ניתן לעטוף אותו בצינור אסינכרון אחד)

{ async} {age$ }

בכרטיסיית הרשת של הדפדפן נראה שתי בקשות. הסיבה היא ש- Htp של Angular יוצר תצפית קרה כך שכל מנוי חדש שווה לבקשה חדשה. אנחנו בהחלט לא רוצים שיהיו לנו מספר בקשות. ראשית נפתור את הבעיה ולאחר מכן נראה כיצד היא פועלת.

לפתור את זה ממש קל מאוד. כל שעלינו לעשות הוא להוסיף שיתוף () או פרסום (), refCount () כך

this.user$ = this.http.get(`api/user/1`).pipe( share() ); //or this.user$ = this.http.get(`api/user/1`).pipe( publish(), refCount() );

ועכשיו בכרטיסיית הרשת יש לנו בקשה אחת מכיוון שהנתונים חולקו בין כל המנויים. אז איך שיתוף () או פרסום () פותר בצורה קסומה את הבעיה הזו ומה ההבדל ביניהם אם שניהם עושים את אותו הדבר?

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
על מנת להבין כיצד פועלים אופרטורי שיתוף עלינו להבין מהו ריבוי שידור.
מפיק הודעות ב קַר observables נוצר על ידי הנצפה עצמו ורק כאשר הצופים נרשמים אליו. #### multicast ()

ל- RxJs יש אופרטור multicast () שלוקח מפעל נושא או נושא ומחזיר ConnectableObservable. הנבדק עבר כטיעון מתנהג כמו מתווך ברב שידור שנצפה. הוא פשוט מעביר נתונים מהמקור הנצפים לכל המנויים. ConnectableObservable היא תצפית רגילה, אך היא לא תירשם כמקור עד שתתקשר לשיטת connect (). בואו נשנה את הדוגמה שלמעלה עם multicast () כדי להבין איך זה עובד.

this.user$ = this.http.get(`api/user/1`).pipe( multicast(new Subject()) );

זה לבדו לא יעבוד מכיוון שעלינו להתקשר להתחבר ידנית ()

this.name$ = this.user$.pipe( map(user => user.name) ); this.age$ = this.user$.pipe( map(user => user.age) ); this.user$.connect();

לאחר מכן נראה את אותה התנהגות, תהיה רק ​​שיחת http אחת במקום שתיים. חיבור וניתוק ידני עשוי להיות קשה ליישום, ולכן יש מפעיל refCount () שיתחבר אוטומטית () עם המנוי הראשון, ישמור את מספר המנויים וישמור נושא מחובר ל מָקוֹר כל עוד יש לפחות מנוי אחד. כאשר ספירת_המנויים_ יורדת לאפס, נושא ינותק מה- מָקוֹר .

מָקוֹר ניתן לצפייה בדוגמה שלנו ניתן לצפייה מוחזר על ידי this.http.get ()

נושא האם הנושא הפנימי הועבר כטיעון אל שידור רב ()

מנויים או משקיפים הם this.name $ ו זה. גיל $ ומשקיפים אחרים הרשומים ל- Subject.

במילים פשוטות כל המנויים שלנו יירשמו אליהם נושא X (עבר לרשת שידור) ו- נושא X עצמה תירשם לשיחת ה- http שלנו. כאשר ניתן לראות אותו חוזר על ידי שיחות http פולטות, שלנו נושא X ייקח ערך זה וישתף בין כל המנויים.

גודל גופן מגיב-מקורי-מגיב

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.

עכשיו בוא נשנה את הקוד שלנו כדי להשתמש ב- refCount (), כך שלא נצטרך להתחבר ידנית.

דוגמה strtok_r
this.user$ = this.http.get(`api/user/1`).pipe( multicast(new Subject()), refCount() );

כעת איננו צריכים להתקשר להתחבר ידנית () ולדאוג לניתוק. refCount () יתחבר בכפוף למקור עם המנוי הראשון אליו ויתנתק כאשר כבר אין צופים.

למעשה בעבר השתמשנו בשילוב של publish (), refCount () וזה לגמרי אותו דבר כמו multicast (New Subject ()), refCount ()

לְפַרְסֵם()

ל- RxJs יש אופרטור publish () ואם נסתכל על קוד המקור נראה שהוא משתמש ברב שידור עם Subject ()

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
publish () מקבל אופציה של בורר למעשה ולמעשה הוא משנה את התנהגותו של המפעיל וראוי למאמר משלו. נדלג על חלק זה ונשקול להשתמש ב- publish () ללא פונקציית בורר.

כך שכאשר אנו משתמשים ב- publish () אנו למעשה משתמשים ב- multicast הישן () עם Subject () ולכן אנו צריכים להמשיך להתחבר ולנתק ידנית, או להשתמש ב- refCount () כדי להפוך את התהליך לאוטומטי.

מכיוון שאנו משתמשים בעיקר ב- publish () עם refCount () יש אופרטור דומה מאוד שמשתמש ב- refCount () באופן פנימי ומתנהג באופן דומה. כלומר שיתוף ()

לַחֲלוֹק()

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
בדוגמה הראשונה שלנו ראינו ששיתוף () עושה את אותו הדבר כמו פרסום (), refCount () וברוב המקרים הם זהים. share () הוא אופרטור שמשתמש ב- refCount () באופן פנימי, כך שאנו לא צריכים לקרוא לזה. share () בדיוק כמו publish () משתמש ברב שידור () אך ההבדל הוא בטיעון שהועבר לרב שידור ().
מפיק הודעות ב קַר observables נוצר על ידי הנצפה עצמו ורק כאשר הצופה נרשם אליו.> מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
זו הסיבה היחידה מדוע איננו יכולים לומר ששיתוף () זהה לפרסום () + refCount (). הבדל זה גורם להתנהגות שונה של מנויים מאוחרים כאשר המקור הושלם.

הבדלים בין share () ופרסום () + refCount ()

עם זאת שניהם משתמשים ב- refCount () לניהול מנויים

מפיק הודעות ב קַר observables נוצר על ידי הנצפה עצמו ורק כאשר הצופה נרשם אליו.> מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
ההבדל עדין אך חשוב מאוד. בוא נשנה את הקוד שלנו כך שיהיה לו כפתור שיעדכן את נתוני המשתמש. בעת לחיצה הוא יביא מחדש את הנתונים מהשרת.

ראשית בואו נשתמש בשיתוף ()

ngOnInit() { this.user$ = this.http.get(`api/user/1`).pipe( share() ) this.name$ = this.user$.pipe( map(user => user.name) ); this.age$ = this.user$.pipe( map(user => user.age) ); } update() { this.name$ = this.user$.pipe( map(user => user.name + 'update') ); this.age$ = this.user$.pipe( map(user => user.age + 'updated') ); }

כאשר נטען בתחילה הנתונים refCount () יספרו את כל ההפניות. אז יהיו לנו שתי הפניות לנושא. ברגע שנקבל נתונים מהשרת Subject נקבל נתונים אלה ממקור ויושלמו. שני המנויים שלנו יקבלו את הנתונים מהנושא וגם ישלימו, כלומר מספר ההתייחסות ב- refCount () יהיה 0. במקרה זה הנושא ינותק מהמקור.

כאשר נבצע את שיטת העדכון (), מופע Subject () חדש ייווצר ויירשם כמנוי למקור. כך שכל ביצוע של עדכון () אכן ישלח בקשה לשרת.

שקול כעת את אותה דוגמה עם publish (), refCount ()

this.user$ = this.http.get(`api/user/1`).pipe( publish(), refCount() );

שוב יהיה לנו מונה refCount () שנקבע ל -2 וברגע שהמקור פולט ומשלים את המונה יהיה 0. אבל כאשר נבצע את שיטת העדכון () לא יקרה שום דבר, לא יוגשו בקשות לשרת. כפי שנכתב למעלה מנויים חדשים יקבלו התראות 'שלמות' רק לאחר השלמת המקור.

הסיבה שהם מתנהגים כך נמצאת ברב שידור (). מכיוון שפירסום () משתמש במופע Subject, כאשר המקור יושלם, גם Subject יושלם, כך שכל מנוי חדש לאותו נושא יקבל הודעה 'מלאה' בלבד.

share () משתמש בפונקציית המפעל המחזירה מופע Subject. כאשר המקור יושלם, גם Subject יושלם, אך עבור מנויים חדשים תיווצר מופע Subject חדש ויירשם כמנוי למקור.

לעקוף אימות דו-שלבי gmail

multicast () עם סוג נושא אחר

עד עכשיו דנו בנושא שידור מרובה באמצעות Subject. ישנם סוגים אחרים של Subject - ReplaySubject, BehaviorSubject ו- AsyncSubject. העברת נושא שונה לרשת שידור תחזיר את ConnectableObservable, אך התנהגותם תהיה שונה.

ראשית, נסתכל על ReplaySubject (n), הוא לוקח מספר כארגומנט שהוא ספירת הפליטות שהוא ישמור במאגר. עבור כל מנוי חדש הוא ישמיע מחדש פליטות n.

אם נעביר את ReplaySubject (n) לרב שידור () כל המנויים החדשים יקבלו n ערכים משוחזרים.

publishReplay ()

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
publishReplay () מחזיר את ConnectableObservable כך שנצטרך להשתמש ב- connect () או להשתמש ב- refCount () לניהול חיבורים. בואו נשנה את הדוגמה שלנו כך שכל מנוי חדש יקבל ערך שנאגר. אז כאשר נלחץ על עדכון () לא נקבל נתונים חדשים, אלא נקבל ערך במטמון.

this.user$ = this.http.get(`api/user/1`).pipe( publishReplay(1), refCount() );

כל המנויים ל- ReplaySubject לפני השלמת המקור יקבלו ערכים שנפלטו (במקרה שלנו ערך אחד בלבד מכיוון ש- Http פולט רק פעם אחת). עבור כל המנויים החדשים ReplaySubject ישחזר N ערכים שנאגרו.

מכיוון שאנו משתמשים בעיקר ב- publishReplay () עם refCount (), יש אופרטור דומה מאוד שמשתמש במנגנון ספירת הפניות באופן פנימי ומתנהג באופן דומה. זה שיתוף משחק ()

shareReplay ()

shareReplay () הוא מפעיל מעניין מאוד. הוא יכול להתנהג באופן דומה ל- publishReplay () + refCount () אך הוא תלוי באופן בו אנו משתמשים במפעיל זה.

לפני גרסת RxJs 6.4.0 מנגנון ספירת ההפניות ב- shareReplay () עבד בצורה אחרת. החל מ- 6.4.0 נוכל להעביר במפורש טיעון ל- shareReplay () כדי להשתמש במנגנון ספירת הפניות 'רגיל'. בואו נראה בפירוט רב יותר

shareReplay ({refCount: true}) (RXJS 6.4.0 ואילך)

refCount: true אומר shareReplay () להשתמש במנגנון ספירת הפניות, בדומה ל- refCount (). במקרה זה shareReplay ({refCount: true}) הוא כמעט זהה ל- publishReplay () + refCount (). בואו נשנה את הדוגמה שלנו כדי להשתמש ב- shareReplay.

this.user$ = this.http.get(`api/user/1`).pipe( shareReplay({refCount: true, bufferSize: 1}) );

כפי שאתה יכול לראות אנו לא משתמשים ב- refCount () יותר מכיוון ש- ShareReplay ({refCount: true}) משתמש במנגנון ספירת הפניות משלו.

התוצאה תהיה זהה. כל המנויים ל- ReplaySubject יקבלו ערכים כל עוד הוא פולט אותם. כל המנויים החדשים יקבלו N ערכים שנאגרו.

לפני שנדבר על דרכים אחרות לשימוש ב- shareReplay, בואו נראה את ההבדלים ביניהם.

הבדלים בין shareReplay ({refCount: true}) ו- publishReplay () + refCount ()

שניהם משתמשים ב- ReplaySubject () אך shareReplay () אינו מיושם עם שידור רב ().

מפיק הודעות ב קַר observables נוצר על ידי הנצפה עצמו ורק כאשר הצופה נרשם אליו.> מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
כדי לראות את ההבדל הבה נשתמש במרווח () כך שלמנויים חדשים המקור לא יושלם

this.source = interval(1000).pipe( publishReplay(1), refCount() ); const sub1 = this.source.subscribe(x => console.log('sub 1', x)); const sub2 = this.source.subscribe(x => console.log('sub 2', x)); setTimeout(() => { sub1.unsubscribe(); sub2.unsubscribe(); }, 2000);

יש לנו 2 הרשמות ל- ReplaySubject, sub1 ו- sub2. לאחר 2 שניות שניהם יבטלו את המנוי לנושא. מכיוון שאנו משתמשים ב- refCount () כאשר לא יהיו יותר מנויים (למשל מספר ההפניות יורד לאפס) זה ינתק את ReplaySubject מהמקור. עד כאן בקונסולה נראה.

sub 1– 0 sub 2– 0 sub 1– 1 sub 2– 1

כעת נניח שנוצר מנוי חדש ל- ReplaySubject בלחיצת כפתור. (לאחר refCount יורד לאפס)

newSub() { const sub3 = this.source.subscribe(x => console.log(‘sub 3’, x)); }

כאשר newSub () יופעל תתקבל sub3 ערך שנאגר אחרון מ- ReplaySubject (שיהיה 1 ) ובדוק אם המקור הושלם. אם הושלם, תת 3 תקבל הודעה 'שהושלמה' ותשלים גם כן. אולם מכיוון שאנו משתמשים במרווח (), המקור לא יושלם ו- ReplaySubject הפנימי יירשם מחדש למקור שוב. התוצאה תהיה

sub 1– 0 sub 2– 0 sub 1– 1 sub 2– 1 /**** execution of newSub() ****/ sub 3– 1 <- replayed value sub 3– 0 <- new subscription sub 3– 1 sub 3– 2 ...

פנימי ReplaySubject משחזר ערכים שנאגרו לצופים חדשים או משלים או נרשם מחדש למקור בהתאם למצב של השלמת המקור.

עכשיו אותה דוגמת מרווח () באמצעות shareReplay ({refCount: true})

this.source = interval(1000).pipe( shareReplay({refCount: true, bufferSize: 1}) ); const sub1 = this.source.subscribe(x => console.log('sub 1', x)); const sub2 = this.source.subscribe(x => console.log('sub 2', x)); setTimeout(() => { sub1.unsubscribe(); sub2.unsubscribe(); }, 2000); //execute newSub() after sub1 and sub2 unsubscribe newSub() { const sub3 = this.source.subscribe(x => console.log(‘sub 3’, x)); }

shareReplay () אינו מיושם עם שידור רב, אך הוא משתמש בפונקציית מפעל באופן פנימי ואם נשתמש בו עם refCount: ספירת אמת ו- ref יורדת לאפס, עבור כל מנוי חדש אם המקור השלים הוא ישחזר ערכים שנאגרו ויפלט הודעה 'שהושלמה'. . אם המקור לא הושלם עבור כל מנוי חדש, ReplaySubject החדש ייווצר ויירשם כמנוי למקור.

כתוצאה מכך לאחר הפעלת הקוד למעלה והפעלת newSub () נראה.

sub 1– 0 sub 2– 0 sub 1– 1 sub 2– 1 /**** execution of newSub() ****/ sub 3– 0 <- new subscription sub 3– 1 sub 3– 2 ...

כפי שאתה יכול לראות שום ערך לא שוחזר מחדש עבור sub3. הסיבה היא שכאשר sub1 ו- sub2 יירשמו, ספירת השופטים תהיה אפס ואם המקור השלים כל המנויים החדשים כמו sub3 יקבלו את כל הערכים שנאגרו והודעת 'הושלמה', אך מכיוון שאנו משתמשים במרווח () והמקור לא יהיה הושלם, ReplaySubject יהרס וכל מנוי חדש כמו sub3 ייצור מופע ReplaySubject חדש ויירשם שוב למקור.

shareReplay () ללא refCount

עד עכשיו השתמשנו ב- shareReplay עם refCount: נכון. אנו יכולים להשתמש ב- shareReplay עם refCount המוגדר כ- false או לא מוגדר כלל ולציין רק גודל חיץ - למשל shareReplay ({refCount: false, bufferSize: 3}) ו- shareReplay (3) זהים. המשמעות היא ש- ReplaySubject יפיק 3 ערכים אחרונים ו- refCount יהיה שקר. זה לא אומר שלא יהיה מנגנון ספירת התייחסות, הוא פשוט יתנהג אחרת.

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
refCount: false פירושו כי עם ההרשמה הראשונה ל- ReplaySubject היא תירשם כמקור. אבל זה לא ינתק את ReplaySubject מהמקור שבו אין יותר מנויים ל- ReplaySubject. בואו נשנה את הדוגמה שלנו שוב באמצעות refCount false

באיזו שפה כתוב טוויץ'
this.source = interval(1000).pipe( shareReplay({refCount: false, bufferSize: 2}) //or just shareReplay(2) ); const sub1 = this.source.subscribe(x => console.log('sub 1', x)); const sub2 = this.source.subscribe(x => console.log('sub 2', x)); setTimeout(() => { sub1.unsubscribe(); sub2.unsubscribe(); }, 2000); setTimeout(() => { const sub3 = this.source.subscribe(x => console.log(‘sub 3’, x)); }, 4000);

sub1 ו- sub2 נרשמים ל- ReplaySubject ו- ReplaySubject מנויים על מרווח המקורות. לאחר 2 שניות תת ו -1 תתבטלו 2, אך במקרה זה ReplaySubject לא יבטל את המנוי מהמקור. המקור ימשיך לפלוט ערכים למרות שאין מנויים לתפוס ערכי תזות.

לאחר 4 שניות נרשם מנוי חדש ל- ReplaySubject ויקבל את 2 הערכים האחרונים שנאגרו וימשיך לקבל ערכים ממקור. התוצאה תהיה

sub 1– 0 sub 2– 0 sub 1– 1 sub 2– 1 /**** after 4 seconds ****/ sub 3– 2 <- replayed values sub 3– 3 <- sub 3– 4 <- continues receiving values sub 3– 5 ...

sub1 ו- sub2 נרשמו, ערכים מודפסים ולאחר שתי שניות ביטול המנוי, אך מכיוון שהמקור עדיין לא הושלם, ReplaySubject יקבל נתונים מהמקור ולכן כאשר לאחר 4 שניות תתבצע sub3 הרשמה ל- ReplaySubject הוא לא יקבל את 0 ו 1 כערכים שנאגרו, אבל 2 ו 3 , כי באותה תקופה הצליח ReplaySubject להשיג ערכים חדשים ממקור ולעדכן את המאגר שלו. המקרה היחיד שבו ReplaySubject יבטל את המנוי מהמקור הוא כאשר המקור יושלם או שגיאות. כל מנוי חדש במקרה זה יקבל ערכים חוזרים ויושלם.

מפיק הודעות ב קַר observables נוצר על ידי הנצפה עצמו ורק כאשר הצופים נרשמים אליו. #### publishBehavior ()

publishBehavior () משתמש ברב שידור עם נושא אחר. התנהגות בנושא

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
publishBehavior () מחזיר את ConnectableObservable ולכן עלינו להשתמש ב- refCount () או להתחבר באופן ידני.

publishBehavior () מקבל ערך ברירת מחדל כפרמטר ויפליט ערך זה לכל המנויים אם המקור לא נפלט. שקול דוגמה זו

this.source = interval(1000).pipe( publishBehavior(47), refCount() ); const sub1 = this.source.subscribe(x => console.log('sub 1', x)); const sub2 = this.source.subscribe(x => console.log('sub 2', x)); setTimeout(() => { sub1.unsubscribe(); sub2.unsubscribe(); }, 2000); setTimeout(() => { const sub3 = this.source.subscribe(x => console.log('sub 3', x)); }, 4000);

התוצאה תהיה

sub 1– 47 <- default values sub 2– 47 <- sub 1– 0 sub 2– 0 sub 1– 1 sub 2– 1 /**** after 4 seconds ****/ sub 3– 1 <- last buffered value sub 3– 1 sub 3– 2 ...

מכיוון שהמרווח הוא אסינקי, כאשר sub1 ו- sub2 נרשמים ל- BehaviorSubject, באותו זמן המקור עדיין לא נפלט, כך שתת1 ו- sub2 יקבלו ערכי ברירת מחדל מ- BehaviorSubject. לאחר שתי שניות תת- sub2 ו- sub2 יבטלו את המנוי מ- BehaviorSubject ו- BehaviorSubject עצמו יבטל את המנוי מהמקור. לאחר 4 שניות תתבצע sub3 מנוי ל- BehaviorSubject ומכיוון שהמקור עדיין לא הושלם, תת 3 יקבל את הערך האחרון שנפלט ויירשם מחדש ל- Source באמצעות אותו BehaviorSubject.

מפיק הודעות ב קַר observables נוצר על ידי הנצפה עצמו ורק כאשר הצופים נרשמים אליו. #### publishLast ()

publishLast () משתמש ברב שידור עם AsyncSubject

מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
כמו כל מפעילי ריבוי שידור, publishLast () משמש בצורה הטובה ביותר עם refCount ().

AsyncSubject המשמש באופרטור זה מעניין מאוד. הוא לא יפיק ערכים אם יירשם כמנוי עד להשלמתו ולאחר מכן פולטת הערך האחרון.

this.source = interval(1000).pipe( take(2), publishLast(), refCount() ); const sub1 = this.source.subscribe(x => console.log('sub 1', x)); const sub2 = this.source.subscribe(x => console.log('sub 2', x)); setTimeout(() => { const sub3 = this.source.subscribe(x => console.log('sub 3', x)); }, 7000);

מכיוון שמרווח ניתן לצפייה אינסופית השתמשנו ב- take (2) כך שהוא יפיק 2 ערכים וישלים. זו התוצאה

sub 1– 1 //completed sub 2– 1 //completed /**** after 7 seconds ****/ sub 3– 1 //completed

כאשר sub1 ו- sub2 נרשמים ל- AsyncSubject הם לא יקבלו ערכים עד להשלמת המקור. כאשר המקור ישלים AsyncSubject יעביר את הערך האחרון לכל הצופים וישלים גם הוא. לאחר 7 שניות sub3 נרשם ל- AsyncSubject ומכיוון שהוא הושלם הוא יעביר את הערך האחרון וההודעה 'הושלמה' גם ל- sub3.

מפיק הודעות ב קַר observables נוצר על ידי הנצפה עצמו ורק כאשר הצופה נרשם אליו.> מפיק הודעות ב קַר תצפיות נוצרות על ידי הנצפה עצמה ורק כאשר הצופה מנויים עליה.
יש הרבה דברים ב- Rxjs ורב שידור הוא אחד הדברים החשובים ביותר בספרייה. מקווה שמאמר זה עזר לך להבין כיצד פועלים אופרטורי שיתוף ומה ההבדל ביניהם. תודה שקראתם.

#javascript #מלבני #angular.js

node js קרא קובץ אקסל

codequs.com

הקסם של מפעילי שיתוף RXJS וההבדלים ביניהם

הקסם של מפעילי שיתוף RXJS וההבדלים ביניהם