Observables > Introduction

Références

L'actualité

Librairie

L'information

Observables

L'observables fournit un support pour la transmission de messages entre les éditeurs et les abonnés dans votre application. Les observables offrent des avantages importants par rapport aux autres techniques de gestion des événements, de programmation asynchrone et de gestion de plusieurs valeurs.

Les observables sont déclaratifs. En d'autres termes, vous définissez une fonction pour la publication de valeurs, mais celle-ci n'est exécutée que lorsque le consommateur y a souscrit. Le consommateur abonné reçoit ensuite des notifications jusqu'à ce que la fonction soit terminée ou jusqu'à ce qu'il se désabonne.

Un observable peut fournir plusieurs valeurs de n'importe quel type, littéraux, messages ou événements, en fonction du contexte. L'API de réception des valeurs est identique, que les valeurs soient livrées de manière synchrone ou asynchrone. Comme la logique d'installation et de démontage sont toutes deux gérées par l'observable, le code de votre application doit uniquement s'inquiéter de l'abonnement aux valeurs consommées et, une fois l'opération terminée, de la désinscription. Qu'il s'agisse d'une frappe au clavier, d'une réponse HTTP ou d'un minuteur, l'interface permettant d'écouter les valeurs et d'arrêter l'écoute est la même.

En raison de ces avantages, les observables sont largement utilisés dans Angular et sont également recommandés pour le développement d'applications.

Utilisation de base et termes

En tant qu'éditeur, vous créez une instance " Observable " qui définit une fonction d'abonné. C'est la fonction qui est exécutée lorsqu'un consommateur appelle la méthode subscribe(). La fonction abonné définit comment obtenir ou générer des valeurs ou des messages à publier.

Pour exécuter l'observable que vous avez créé et commencer à recevoir des notifications, vous appelez sa méthode subscribe(), en passant par un observateur. Ceci est un objet JavaScript qui définit les gestionnaires pour les notifications que vous recevez. L'appel à subscribe() renvoie un objet Subscription doté d'une méthode unsubscribe(), que vous appelez pour ne plus recevoir de notifications.

Voici un exemple qui illustre le modèle d'utilisation de base en montrant comment un observable peut être utilisé pour fournir des mises à jour de géolocalisation.



Définir les observateurs

Pour recevoir des notifications observables un gestionnaire implémente l'interface Observer. C'est un objet qui définit des méthodes de rappel pour gérer les trois types de notifications qu'un observable peut envoyer :

Type de notification Description
next Champs obligatoires. Un gestionnaire pour chaque valeur livrée. Appelé zéro ou plusieurs fois après le début de l'exécution.
error Optionnel. Un gestionnaire pour une notification d'erreur. Une erreur interrompt l'exécution de l'instance observable.
complete Optionnel. Un gestionnaire pour la notification de fin d'exécution. Les valeurs différées peuvent continuer à être transmises au prochain gestionnaire une fois l'exécution terminée.
Un objet observateur peut définir n'importe quelle combinaison de ces gestionnaires. Si vous ne fournissez pas de gestionnaire pour un type de notification, l'observateur ignore les notifications de ce type.


L'abonnement

Une instance d'observable ne commence à publier des valeurs que lorsque quelqu'un s'y abonne. Vous vous abonnez en appelant la méthode subscribe() de l'instance, en passant un objet observateur pour recevoir les notifications.

Par exemple, l'appel à subscribe() suivant est le même que le précédent:


Dans les deux cas, un handler "next" est requis. Les handler "error" et "complete" sont optionnels.

Notez qu'une fonction next() peut recevoir, par exemple, des chaînes de caractères, des objets d'événement, des valeurs numériques ou des structures, en fonction du contexte. En termes généraux, nous désignons les données publiées par un observable sous forme de flux. Tout type de valeur peut être représenté avec un observable, et les valeurs sont publiées sous forme de flux.

Création d'observables

Utilisez le constructeur de l'Observable pour créer un flux observable. Le constructeur prend comme argument la fonction d'abonné à exécuter lors de l'exécution subscribe() de la méthode de l'observable. Une fonction d'abonné reçoit un objet Observer et peut publier des valeurs dans la méthode next() de l'observateur.

Pour aller encore plus loin dans notre exmple, nous pouvons créer un observable qui publie des événements.
Dans cet exemple, la fonction d'abonné est définie en ligne.

Maintenant, vous pouvez utiliser cette fonction pour créer un observable qui publie des événements keydown :


Multicasting

Un observable typique crée une nouvelle exécution indépendante pour chaque observateur abonné. Lorsqu'un observateur est abonné, l'observable connecte un gestionnaire d'événements et lui fournit des valeurs. Lorsqu'un deuxième observateur s'abonne, l'observable connecte ensuite un nouveau gestionnaire d'événements et fournit des valeurs à ce deuxième observateur dans une exécution séparée.

Parfois, au lieu de démarrer une exécution indépendante pour chaque abonné, vous souhaitez que chaque abonnement reçoive les mêmes valeurs, même si les valeurs ont déjà commencé à émettre. Cela pourrait être le cas avec quelque chose comme un observable de clics sur l'objet de document.

La Multicasting est la pratique consistant à diffuser sur une liste de plusieurs abonnés en une seule exécution. Avec un Multicasting observable, vous n'enregistrez pas plusieurs auditeurs sur le document, mais vous réutilisez le premier auditeur et envoyez des valeurs à chaque abonné.

Lors de la création d'un observable, vous devez déterminer comment vous souhaitez que cet observable soit utilisé et si vous souhaitez ou non Multicaster ses valeurs.

Regardons un exemple qui compte de 1 à 3, avec un délai d'une seconde après chaque nombre émis.


Notez que si vous vous abonnez deux fois, il y aura deux flux distincts, chacun émettant des valeurs toutes les secondes. Cela ressemble à quelque chose comme ça :


Changer l'observable en multicast pourrait ressembler à ceci :


La gestion des erreurs

Comme les variables observables produisent des valeurs de manière asynchrone, try / catch ne détectera pas efficacement les erreurs. Au lieu de cela, vous gérez les erreurs en spécifiant un rappel error sur l'observateur. En produisant une erreur, l'observable nettoie également les abonnements et cesse de produire des valeurs. Un observable peut produire des valeurs (rappelant le next()) ou se terminer en appelant le complete.