RxJS Subject veya Observable'ın mevcut değerini nasıl alabilirim?

Bir Açısal 2 hizmetim var:

import {Storage} from './storage';
import {Injectable} from 'angular2/core';
import {Subject}    from 'rxjs/Subject';

@Injectable()
export class SessionStorage extends Storage {
  private _isLoggedInSource = new Subject<boolean>();
  isLoggedIn = this._isLoggedInSource.asObservable();
  constructor() {
    super('session');
  }
  setIsLoggedIn(value: boolean) {
    this.setItem('_isLoggedIn', value, () => {
      this._isLoggedInSource.next(value);
    });
  }
}

Her şey harika çalışıyor. Ama abone olmama gerek olmayan başka bir bileşenim var, sadece isLoggedIn'in şu andaki değerini belirli bir zamanda alması gerekiyor. Bunu nasıl yapabilirim?

A Subjectveya Observablegeçerli bir değeri yok. Bir değer yayıldığında, abonelere iletilir veObservable yapılır.

Mevcut bir değere sahip olmak istiyorsanız, BehaviorSubjecttam olarak bu amaç için tasarlanmış olanı kullanın .BehaviorSubjectson yayınlanan değeri tutar ve hemen yeni abonelere gönderir.

Ayrıca getValue()geçerli değeri elde etmek için bir yöntemi vardır .

Yapmanız gereken tek yol "dışında" değerlerini elde edilmez bir gözlemlenebilir / Konu abone beraber!

Eğer kullanıyorsanız getValue(), bildirim paradigmasında zorunlu bir şey yapıyorsunuz. Orada bir kaçış kapağı var, ama kullanmamalısınız zamanın% 99.9'u getValue(). Birkaç ilginç şey vargetValue()Yapacak : Özne aboneliği kaldırılmışsa bir hata atar, özne öldüğü için bir değer almanızı önler, çünkü hatalı, vb. Ama yine de, bir kaçış olarak orada nadir durumlar için ambar.

Bir Konudan veya Gözlemlenebilirden en son değeri bir "Rx-y" yoluyla elde etmenin birkaç yolu vardır:

1. Kullanmak BehaviorSubject: Ama aslında abone . İlk abone olduğunuzdaBehaviorSubject olduğunuzda, eşzamanlı olarak aldığı veya başlatıldığı önceki değeri gönderir.
2. A kullanarak ReplaySubject(N): Bu önbelleklenirN Değerleri ve yeni abonelere yeniden oynatır.
3. A.withLatestFrom(B): BGözlenebilir Ayayıldığında gözlemlenebilirden en son değeri almak için bu operatörü kullanın . Dizideki her iki değeri de verir [a, b].
4. A.combineLatest(B): Yalnızca bu operatör en son değerleri elde etmek Ave Bher zaman ya Aya Byayar. Dizideki her iki değeri de verir.
5. shareReplay(): A ile Gözlemlenebilir çok noktaya yayın yapar ReplaySubject, ancak hata durumunda gözlemlenebilir olanı yeniden denemenize olanak tanır. (Temel olarak size söz veren önbellekleme davranışı verir).
6. publishReplay(), publishBehavior(initialValue), multicast(subject: BehaviorSubject | ReplaySubject), Vs: Diğer operatörler bu kaldıraç BehaviorSubjectve ReplaySubject. Aynı şeyin farklı tatları, temelde tüm bildirimleri bir konu aracılığıyla hunlayarak gözlemlenebilir kaynağı çok noktaya yayınlar. connect()Konuyla kaynağa abone olmak için aramanız gerekir .

Geç gelen abonelerin değeri geldikten sonra Konuya abone oldukları benzer bir durum yaşadım.

BehaviorSubject benzer ReplaySubject bu durumda bir cazibe gibi çalışır bulundu . Ve işte daha iyi bir açıklama linki: http://reactivex.io/rxjs/manual/overview.html#replaysubject

const observable = of('response')

function hasValue(value: any) {
  return value !== null && value !== undefined;
}

function getValue<T>(observable: Observable<T>): Promise<T> {
  return observable
    .pipe(
      filter(hasValue),
      first()
    )
    .toPromise();
}

const result = await getValue(observable)
// Do the logic with the result
// .................
// .................
// .................

Nasıl uygulanacağı ile ilgili makalenin tamamını buradan kontrol edebilirsiniz. https://www.imkrish.com/how-to-get-current-value-of-observable-in-a-clean-way/

Başlangıçta Öznenin geçerli değerine sahip olması ve ardından değişiklikleri dinlemek için Özneye abone olması gereken alt bileşenlerde de aynı sorunla karşılaştım. Bileşenlerin, örneğin:

import {Storage} from './storage';
import {Injectable} from 'angular2/core';
import {Subject}    from 'rxjs/Subject';

@Injectable()
export class SessionStorage extends Storage {

  isLoggedIn: boolean;

  private _isLoggedInSource = new Subject<boolean>();
  isLoggedIn = this._isLoggedInSource.asObservable();
  constructor() {
    super('session');
    this.currIsLoggedIn = false;
  }
  setIsLoggedIn(value: boolean) {
    this.setItem('_isLoggedIn', value, () => {
      this._isLoggedInSource.next(value);
    });
    this.isLoggedIn = value;
  }
}

Geçerli değere ihtiyaç duyan bir bileşen, bundan sonra hizmetten erişebilir, yani:

sessionStorage.isLoggedIn

Bunun doğru uygulama olup olmadığından emin değilim :)

Benzer görünümlü bir cevap indirildi. Ancak, sınırlı durumlar için burada önerdiğimi haklı çıkarabileceğimi düşünüyorum.

Bir gözlemlenebilir öğenin geçerli bir değeri olmadığı doğru olsa da , çoğu zaman hemen kullanılabilir bir değere sahip olacaktır . Örneğin redux / flux / akita mağazalarında, bir dizi gözlemlenebilir veriye dayalı olarak merkezi bir mağazadan veri talep edebilirsiniz ve bu değer genellikle hemen kullanılabilir olacaktır.

Eğer durum buysa, o zaman subscribedeğer hemen geri gelecektir.

Diyelim ki bir hizmet çağrınız var ve tamamlandığında mağazanızdan potansiyel olarak yaymayabilecek bir şeyin en son değerini almak istiyorsunuz :

Bunu yapmaya çalışabilirsiniz (ve işleri mümkün olduğunca 'boruların içinde' tutmalısınız):

 serviceCallResponse$.pipe(withLatestFrom(store$.select(x => x.customer)))
                     .subscribe(([ serviceCallResponse, customer] => {

                        // we have serviceCallResponse and customer 
                     });

Buradaki sorun, ikincil gözlemlenebilir bir değer yayana kadar bloke olacağıdır, bu potansiyel olarak asla olamaz.

Kendimi son zamanlarda gözlemlenebilir bir değerlendirmeyi sadece bir değer mevcut olduğunda değerlendirmeye ihtiyaç duyduğumu gördüm ve daha da önemlisi, olmadığını tespit edebilmem gerekiyordu. Sonunda bunu yaptım:

 serviceCallResponse$.pipe()
                     .subscribe(serviceCallResponse => {

                        // immediately try to subscribe to get the 'available' value
                        // note: immediately unsubscribe afterward to 'cancel' if needed
                        let customer = undefined;

                        // whatever the secondary observable is
                        const secondary$ = store$.select(x => x.customer);

                        // subscribe to it, and assign to closure scope
                        sub = secondary$.pipe(take(1)).subscribe(_customer => customer = _customer);
                        sub.unsubscribe();

                        // if there's a delay or customer isn't available the value won't have been set before we get here
                        if (customer === undefined) 
                        {
                           // handle, or ignore as needed
                           return throwError('Customer was not immediately available');
                        }
                     });

Yukarıdakilerin tümü subscribeiçin değeri almak için kullanıyorum (@Ben tartıştığı gibi). Ben bir .valueözellik olmasa bile BehaviorSubject.

Kulağa aşırı gelebilir gibi gelse de, bu sadece Gözlemlenebilir tutmak için başka bir "olası" çözümdür tipte ve kazan plakasını azaltmak ...

Bir Gözlemlenebilir öğesinin geçerli değerini almak için her zaman bir uzantı alıcısı oluşturabilirsiniz .

Bunu yapmak için, Observable<T>arabirimi bir global.d.tsbildirimler bildirim dosyasında genişletmeniz gerekir . Ardından, uzantıobservable.extension.ts alıcıyı bir dosyaya uygulayın ve son olarak uygulamanıza hem yazımları hem de uzantı dosyasını ekleyin.

Uzantıları Açısal uygulamanıza nasıl ekleyeceğinizi öğrenmek için bu StackOverflow Yanıtına başvurabilirsiniz .

// global.d.ts
declare module 'rxjs' {
  interface Observable<T> {
    /**
     * _Extension Method_ - Returns current value of an Observable.
     * Value is retrieved using _first()_ operator to avoid the need to unsubscribe.
     */
    value: Observable<T>;
  }
}

// observable.extension.ts
Object.defineProperty(Observable.prototype, 'value', {
  get <T>(this: Observable<T>): Observable<T> {
    return this.pipe(
      filter(value => value !== null && value !== undefined),
      first());
  },
});

// using the extension getter example
this.myObservable$.value
  .subscribe(value => {
    // whatever code you need...
  });

En son yayınlanan değeri Gözlemlenebilir'den ayrı olarak saklayabilirsiniz. Sonra gerektiğinde okuyun.

let lastValue: number;

const subscription = new Service().start();
subscription
    .subscribe((data) => {
        lastValue = data;
    }
);

Bunu yapmanın en iyi yolu kullanmaktır Behaviur Subject, işte bir örnek:

var sub = new rxjs.BehaviorSubject([0, 1])
sub.next([2, 3])
setTimeout(() => {sub.next([4, 5])}, 1500)
sub.subscribe(a => console.log(a)) //2, 3 (current value) -> wait 2 sec -> 4, 5

Bir abonelik oluşturulabilir ve yayılan ilk öğe kaldırıldıktan sonra. Boru, giriş olarak Gözlemlenebilir kullanan bir işlevdir ve ilk gözlemlenebilirliği değiştirmeden başka bir Gözlemlenebilir çıkış döndürür. Açısal 8.1.0. Paketler: "rxjs": "6.5.3","rxjs-observable": "0.0.7"

  ngOnInit() {

    ...

    // If loading with previously saved value
    if (this.controlValue) {

      // Take says once you have 1, then close the subscription
      this.selectList.pipe(take(1)).subscribe(x => {
        let opt = x.find(y => y.value === this.controlValue);
        this.updateValue(opt);
      });

    }
  }