Angular2. Comment puis-je vérifier si un observable est terminé?

Dans ma page, il y a un bouton qui génère un rapport. Que le rapport de besoin de données qui est chargé à l'aide d'un appel http à un point de terminaison rest lorsque la page est chargée, mais je n'ai pas de garantie qu'ils sont chargés lorsque l'utilisateur appuie sur le bouton rapport.

Comment puis-je regarder les observables pour voir si elle est terminée, et si elle est incomplète, à attendre sur l'action jusqu'à ce que le http appel est terminé? Voici une partie du code:

loadCompanies(): void {
    this._companyService.getCompanies().subscribe(
        response => {
            this.companiesModel = response;
        },
        err => console.log(err)
    );
}

generateReport() {
   //check if observable that loads companies is completed and do the 
   //action using companiesModel.
}

Une option est un indicateur défini dans le chargement des entreprises avec des valeurs de "chargement" et "terminé", et de les faire attendre dans generateReport() jusqu'à ce que le drapeau est terminé,
mais je préfère une solution à l'aide de la Observable API si possible.

il suffit de faire une si(companiesModel) qui fera l'affaire, je l'espère

OriginalL'auteur csm86 | 2017-07-11

10

Vous pouvez le faire en utilisant onCompleted rappel dans subscription. Par exemple, disons que vous montrer la barre de chargement lorsque l'utilisateur presse le bouton de rapport;
```
loadCompanies(): void {
     this._companyService.getCompanies().subscribe(
          response => {
               this.companiesModel = response;
          },
          err => {
               console.log(err);
               //closeLoadingBar();
          },
          () => {
               //do whatever you want
               //closeLoadingBar()
          }
     )
}

generateReport() {
    //showLoadingBar()
    this.loadCompanies();
}
```
Si vous obtenez l'erreur à partir de votre appel http, onCompleted méthode ne sera pas invoquée, que onError sera invoquée. Si elle est couronnée de succès, onCompleted méthode sera appelée après votre onNext méthode.

Voici la documentation pour abonnez-vous. J'espère que cela aide!

OriginalL'auteur ulubeyn
3

La solution:

Fait souscrire fonction prend trois paramètres:

onNext
onError
onCompleted
```
this._companyService.getCompanies().subscribe(
    (response) => { this.companiesModel = response; },
    (err) => { console.log(err) },
    (finally) => { console.log('finally') }
);
```
Merci pour la réponse. Je sais à ce sujet. Mais ma situation est différente.Je n'ai pas besoin de déclencher mon action lors de l'observable est complète. Lors de mon action est fait j'ai besoin de vérifier si l'observable est terminé, et si pas, attendre jusqu'à ce que soit terminée.
de même. Suis-je obligé de définir un indicateur dans ce rappel? Qui se sent plus difficile qu'elle ne devrait l'être. N'est-ce pas là un fait observable.isComplete propriété?

OriginalL'auteur Valery Lyatsevich

Dans ce genre de cas, il est très utile d'utiliser concatMap opérateur de garantie pour exécuter l'opération suivante que lorsque la précédente a fait.

loadCompanies(): void {
    this._companyService.getCompanies()
    .concatMap(companyList => this.getObservableGenerateReport(companyList))
    .subscribe(
        response => {
            this.companiesModel = response;
        },
        err => console.log(err)
    );
}


//Create observable to generate the report
getObservableGenerateReport(response: any): Observable<myReportList> {

    return Observable.create(observer => {

      if (generateReport().isSuccessful) {
        observer.next(myReportList);
        observer.complete();
      } else {
        console.log(err, 'Ups, something was wrong!');
        observer.next({});
        observer.complete();
      }

    });
  }

Merci. Quelque chose comme ce que je cherchais. Permettez-moi d'essayer si fonctionne comme prévu, et je vais marquer cette réponse.

OriginalL'auteur yaircarreno

1

Méthode
```
finally()
```
Appelle une action spécifiée après la source observables séquence
se termine normalement ou exceptionnellement.

https://github.com/Reactive-Extensions/RxJS/blob/master/doc/api/core/operators/finally.md

OriginalL'auteur Valery Lyatsevich

La solution que j'ai trouvé est d'utiliser un partagées observables, enregistrer la requête en tant qu'chaud observable que lorsque le rapport bouton est cliqué, il va attendre la demande ou de générer immédiatement si la demande est complète.

public companiesModel: Company[];

/** pending request, hot Observable (will emit immediately if complete) */
private companiesRequest: Observable<Company[]>;

constructor(
  private _companyService: CompanyService
) {}

public ngOnInit(): void {
  this.loadCompanies();
}

public generateReport(): void {
  if (this.companiesRequest) {
    //will not make an other network request
    this.companiesRequest.subscribe(
      response => {
        //action using companiesModel.
      },
      err => console.log(err)
    );
  }
}

private loadCompanies(): void {
  this.companiesRequest = this._companyService.getCompanies().pipe(shareReplay());
  this.companiesRequest.subscribe(
    response => {
      this.companiesModel = response;
    },
    err => console.log(err)
  );
}

https://stackblitz.com/edit/check-if-an-observable-is-completed?file=src%2Fapp%2Fapp.component.ts

Mise à jour: Vous pouvez prendre un peu plus loin et rendre l'INTERFACE asynchrone
https://stackblitz.com/edit/check-if-an-observable-is-completed-async-ui?file=src%2Fapp%2Fapp.component.html

OriginalL'auteur William Lohan

Vous devez vous connecter pour publier un commentaire.