pourquoi utiliser subscribe() plutôt que map() en Angular ?

Question

J'essaie de tirer parti des observables dans angular2 et je me suis demandé pourquoi je devais utiliser map() en subscribe() . Supposons que je reçoive des valeurs d'un webApi, comme ceci

  this.http.get('http://172.17.40.41:8089/api/Master/GetAllCountry')

Utilisant maintenant subscribe(success, error, complete) Je peux obtenir toutes les valeurs sur le callback de succès et je peux retourner les valeurs sur le callback complet. Si je peux faire toutes ces fonctionnalités, alors quel est le besoin de map() ? Donne-t-il un avantage quelconque ?

En bref, pourquoi il faut écrire comme ceci :

this.http.get('http://172.17.40.41:8089/api/Master/GetAllCountry')
    .map(r=>{})
    .subscribe(value => {
    }, error => error, () => {
});

alors qu'ils peuvent simplement écrire ceci sans la fonction map :

this.http.get('http://172.17.40.41:8089/api/Master/GetAllCountry')
    .subscribe(value => {        
    }, error => error, () => {           
});

Answer 1

Si vous voulez renvoyer un Observable à laquelle un autre code peut s'abonner, mais que vous voulez toujours manipuler les événements de données dans la méthode actuelle, utilisez map .

L'utilisateur réel de l'observable doit subscribe() car sans subscribe() l'observable ne sera pas exécuté du tout. ( forEach() o toArray() et probablement d'autres fonctionnent aussi bien pour exécuter l'observable au lieu de subscribe() )

subscribe() renvoie un Subscription qui ne peut pas être souscrit, mais il peut être utilisé pour annuler l'abonnement.

map() renvoie un Observable auxquels il est possible de s'abonner.

Answer 2

Pensez à la carte comme à un intergiciel qui transforme la réponse.

this.http.get('http://172.17.40.41:8089/api/Master/GetAllCountry')
.map(r=>r.json())
 .subscribe(result => {
              // here result would have json object that was parsed by map handler...
            },failurCallback,completeCallback)

subscribe est utilisé pour invoquer l'observable, veuillez lire une bonne doc sur observables à froid contre observables à chaud

Answer 3

Vous devez subscribe pour exécuter votre requête asynchrone. Si vous définissez simplement map - aucune demande ne sera déclenchée. Vous pouvez vérifier.

Bonne pratique à utiliser map de préprocesser vos données car de nombreux abonnés peuvent comsommer vos résultats. Ainsi, au lieu d'ajouter un prétraitement à chaque client (abonné), vous pouvez préparer une sortie unique avec un schéma de données unique pour tous.

Answer 4

.map() est un opérateur rxjs, il affichera le résultat dans le tableau [] former soit .json() formulaire

https://www.learnrxjs.io/operators/transformation/map.html

Answer 5

Les observables sont des flux et ils sont conçus pour être écrits dans des flux fonctionnels. Vous devez utiliser RxJS car il s'agit de la fonctionnel Il s'agit d'un moyen d'implémenter des sous-catégories d'observables. Cela se produit généralement lorsque nous prenons des données en dehors du flux de l'Observable.

Il s'agit d'une opération asynchrone forcée de fonctionner de manière synchrone.

bad_example() {
  let id;
  this.obs.subscribe(param => id = param['id']);
    this.get(id).subscribe(elem => this.elem = elem);
}

Il s'agit d'une opération asynchrone qui fonctionne comme prévu. (Comme un flux)

good_example() {
  this.obs
    .map(param => param['id'])
    .switchMap(id => return this.get(id))
    .subscribe(elem => this.elem = elem);
}