Як отримати поточне значення предмета RxJS або спостережуваного?

У мене є послуга Angular 2:

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);
    });
  }
}

Все чудово працює. Але в мене є ще один компонент, на який не потрібно підписуватися, він просто повинен отримати поточне значення isLoggedIn в певний момент часу. Як я можу це зробити?

SubjectАбо Observableне має значення струму. Коли значення випромінюється, воно передається абонентам іObservable це робиться з ним.

Якщо ви хочете мати поточне значення, використовуйте BehaviorSubjectяке розроблено саме для цієї мети.BehaviorSubjectзберігає останнє випромінене значення і негайно передає його новим абонентам.

Він також має метод getValue()отримання поточного значення.

Єдиний спосіб, коли вам слід отримати значення "з" спостережуваного / тематичного, - це підписатися!

Якщо ви використовуєте, getValue()ви робите щось імперативне в декларативній парадигмі. Це там, як люк для втечі, але 99,9% часу НЕ слід використовувати getValue(). Є кілька цікавих речей, якіgetValue() : це призведе до помилки, якщо суб’єкт був відписаний, це не дозволить вам отримати значення, якщо предмет мертвий, тому що він помилився, і т. Д. Але, знову ж таки, це є як втеча люк для рідкісних обставин.

Існує кілька способів отримання останнього значення з предмета чи спостережуваного способу "Rx-y":

1. Використання BehaviorSubject: Але насправді підписавшись на нього . Коли ви вперше підписалися наBehaviorSubject нього, він синхронно надішле попереднє значення, яке воно отримало або було ініціалізовано.
2. Використання ReplaySubject(N): Це буде кешуватиN значення та відтворюватиме їх новим підписникам.
3. A.withLatestFrom(B): Використовуйте цей оператор, щоб отримати останнє значення, яке можна побачити, Bколи спостережуване Aвипромінює Дасть вам обидва значення в масиві [a, b].
4. A.combineLatest(B): Використовуйте цей оператор , щоб отримати найостанніші значення від Aі Bкожен раз , коли або Aчи Bвипускає. Дасть вам обидва значення в масиві.
5. shareReplay(): Здійснює спостережливе багатоадресневе повідомлення через ReplaySubject, але дозволяє повторити спробу, що спостерігається помилково. (В основному це дає вам таку обіцянку - кешування поведінки).
6. publishReplay(), publishBehavior(initialValue), multicast(subject: BehaviorSubject | ReplaySubject)І т.д .: Інші оператори , які використовують BehaviorSubjectі ReplaySubject. Різні смаки одного і того ж, вони, в основному, передають джерело, яке можна побачити, перенаправляючи всі сповіщення через тему. Вам потрібно зателефонувати, connect()щоб підписатися на джерело з темою.

У мене була подібна ситуація, коли пізні абоненти підписуються на Тему після надходження її вартості.

Я знайшов ReplaySubject, який схожий на BehaviorSubject, працює як шарм у цьому випадку. Ось посилання на краще пояснення: 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
// .................
// .................
// .................

Ви можете переглянути повну статтю про те, як це реалізувати звідси. https://www.imkrish.com/how-to-get-current-value-of-observable-in-a-clean-way/

Я зіткнувся з тією ж проблемою в дочірніх компонентах, де спочатку він повинен був мати поточне значення Subject, а потім підписатися на Subject, щоб прослухати зміни. Я просто підтримую поточне значення в Сервісі, щоб воно було доступне для компонентів, наприклад:

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;
  }
}

Компонент, який потребує поточного значення, може лише потім отримати доступ до нього зі служби, тобто:

sessionStorage.isLoggedIn

Не впевнений, чи це правильна практика :)

Аналогічний шукає відповідь була downvoted. Але я думаю, що можу виправдати те, що пропоную тут, для обмежених випадків.

Хоча це правда, що спостережуване не має поточного значення, але дуже часто воно матиме одразу доступне значення. Наприклад, у магазинах redux / flux / akita ви можете запитувати дані в центральному магазині на основі ряду спостережуваних даних, і це значення, як правило, буде негайно доступним.

Якщо це так, тоді, коли ви subscribe, значення повернеться негайно.

Тож скажімо, що ви дзвонили в службу, і після завершення ви хочете отримати останнє значення чогось із вашого магазину, яке потенційно може не випромінювати :

Ви можете спробувати зробити це (і вам слід якомога більше тримати речі «всередині труб»):

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

                        // we have serviceCallResponse and customer 
                     });

Проблема в цьому полягає в тому, що він блокується, поки вторинне спостережуване не видасть значення, яке потенційно може бути ніколи.

Нещодавно я виявив потребу в оцінці спостережуваного лише в тому випадку, якщо значення було одразу доступне , і що ще важливіше, я мав змогу виявити, якщо це не було. Я закінчила це робити:

 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');
                        }
                     });

Зауважте, що для всього вищесказаного я використовую subscribeдля отримання значення (як @Ben обговорює). Не використовую .valueвласність, навіть якщо б у мене був BehaviorSubject.

Хоча це може здатися надмірним, це просто ще одне "можливе" рішення для збереження типу " Спостережуваність" та зменшення котлової панелі ...

Ви завжди можете створити розширення, щоб отримати поточне значення спостережуваного.

Для цього вам потрібно буде розширити Observable<T>інтерфейс у global.d.tsфайлі декларації про типізацію. Потім реалізуйте геттер розширення у observable.extension.tsфайл і, нарешті, включіть у програму як типізацію, так і файл розширення.

Ви можете посилатися на цей відповідь StackOverflow, щоб знати, як включити розширення до програми Angular.

// 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...
  });

Ви можете зберігати останнє випромінене значення окремо від спостеріганого. Потім прочитайте його, коли потрібно.

let lastValue: number;

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

Найкращий спосіб зробити це за допомогою Behaviur Subject, ось приклад:

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

Підписку можна створити і після зняття першого випущеного елемента знищити. Труба - це функція, яка використовує спостережуваний як свій вхід і повертає інший спостережуваний як вихід, не змінюючи першого спостережуваного. Кутовий 8.1.0. Пакети: "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);
      });

    }
  }