Je recherche sur Google depuis quelques jours et j'ai trouvé de nombreux scénarios différents sur la façon d'utiliser les appels d'API Async avec Angular 5 (ou 2-3-4, peu importe)).
Quelqu'un peut-il me donner un exemple correct (un bon cas d'utilisation) à ce sujet?
ex.
Merci !
Je vais vous donner une réponse basée sur mon avis et comment j'ai appris. Alors ne le prenez pas pour la vérité absolue, mais remettez-le en question!
Tout d'abord, vous devez savoir que dans TypeScript, il existe deux façons d'effectuer des appels asynchrones: Promises et Observables.
Les promesses sont natives dans ES6, les observables font partie de Rx JS.
Puisque c'est mon avis, je vais vous dire d'utiliser Observables, car
Tout cela, les promesses ne peuvent pas le faire.
Très simple: vous devez d'abord importer le module responsable de cela:
import { HttpClientModule } from '@angular/common/http';
// ...
imports: [HttpClientModule]
Il s'agit du nouveau service http amélioré en Angular 5. Je vous recommande fortement de l'utiliser, car l'ancien (Http
) sera bientôt être obsolète.
Maintenant, dans vos services, vous pouvez utiliser le HttpClient
comme ça
import { HttpClient } from '@angular/common/http';
// ...
constructor(
private http: HttpClient
) {}
// ...
getAny(): Observable<any> {
return this.http.get<any>('url'); // request options as second parameter
}
Dans votre composant, vous pouvez maintenant faire
import { MyService } from '../myservice/myservice.service';
// ..
constructor(private myService: MyService) {
this.myService.getAny().subscribe(() => {});
}
// ..
Supposons que vous souhaitiez afficher une barre de progression ou gérer les erreurs: pour ce faire, vous devrez utiliser Interceptors. Les intercepteurs sont des services qui intercepteront votre demande avant (ou après) son envoi et feront quelque chose.
Voici un intercepteur simple pour les erreurs:
import { Injectable } from '@angular/core';
import { HttpInterceptor, HttpHandler, HttpRequest, HttpEvent, HttpResponse } from '@angular/common/http';
import { Observable } from 'rxjs/Observable';
@Injectable()
export class ErrorHandlerService implements HttpInterceptor {
constructor() { }
intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
return next
.handle(req)
.catch(err => {
console.log('error occured');
return Observable.throw(err);
});
}
}
Pour l'utiliser, indiquez simplement votre valeur dans votre module:
providers: [
{ provide: HTTP_INTERCEPTORS, useClass: ErrorHandlerService, multi: true }
]
Je pense que vous l'avez deviné, mais vous pouvez également l'utiliser pour gérer les barres de progression;)
Comme vous l'avez déjà vu, vous pouvez vous abonner à un appel http.
Si vous souhaitez gérer des erreurs spécifiques et faire de la logique dans votre composant, voici comment:
myService.getAny().subscribe(
responseAfterSuccess => {},
responseAfterError => {}
);
Avec ce code, vous gérerez le succès et l'erreur.
Dernière chose, le pipe async: le pipe async transforme un observable en données. Pour l'utiliser, faites-le
this.myVar = myService.getAny();
Votre variable myVar
contiendra un observable. Maintenant, dans votre HTML, avec ce
<div *ngFor="let item of myVar | async">{{ item }}</div>
Angular va attendre que les données arrivent avant d'afficher quoi que ce soit, et transformera l'Observable en données, comme si vous l'aviez fait à la main.