Tutoriel JavaScript promet avec des exemples

Bien que disponibles auparavant via des bibliothèques tierces, des promesses ont été présentées en JavaScript, en tant que natif
fonctionnalité, avec ecmascript6.

Ils fournissent une alternative aux rappels lorsqu'ils traitent avec un code asynchrone, à fournir,
entre autres choses, une façon plus propre de gérer les erreurs. Dans ce tutoriel, nous verrons comment fonctionnent les promesses, comment
les créer et comment utiliser leurs méthodes.

Dans ce tutoriel, vous apprendrez:

• Qu'est-ce qu'une promesse JavaScript.
• Comment créer une promesse JavaScript.
• Comment les promesses peuvent être utilisées pour gérer le code asynchrone.
• Quelles sont les méthodes qui peuvent être utilisées avec une promesse.

Exigences et conventions logicielles utilisées

Qu'est-ce qu'une «promesse»?

En javascript, un promesse Un objet est-il renvoyé à la suite de
une opération asynchrone et non bloquante, telle, par exemple, celle réalisée par le aller chercher
fonction intégrée. Les promesses ont été introduites comme une caractéristique native, avec Ecmascript6: ils représentent un
Alternative plus propre aux rappels, grâce à des fonctionnalités telles que les méthodes et le fait qu'ils fournissent un
façon de gérer les erreurs qui ressemblent à la gestion des exceptions dans le code synchrone. Il y a trois États un promis
peut être dans:

• En attente
• Résolu
• Rejeté

Comme son nom l'indique, nous disons qu'une promesse est en attente Quand son résultat n'a pas encore été décidé,
Ainsi, il peut toujours être résolu ou rejeté. Nous disons qu'une promesse est réalisé Quand l'asynchrone
L'opération a réussi: la promesse a été résolue et contient le résultat de l'opération elle-même.
Enfin, une promesse serait rejeté Lorsque l'opération asynchrone échoue: dans ce cas
La promesse contiendra la raison de l'échec.

Créer une promesse JavaScript

Comme mentionné ci-dessus, certaines fonctions qui effectuent des opérations asynchrones, comme aller chercher, retour
Une promesse par défaut, nous pouvons donc utiliser les méthodes et les modèles que nous décrire plus loin dans ce tutoriel hors de la boîte. Autres fonctions
ne prend pas encore en charge les promesses, donc nous voulons peut-être créer une promesse autour d'eux. Le constructeur d'une promesse prend un argument,
qui est une fonction de rappel qui lui-même prend deux arguments: le résoudre et rejeter rappels, qui
sont appelés à résoudre ou à rejeter la promesse, respectivement. Voyons un exemple rapide sur la façon de créer une promesse triviale:

const promers = new promest (fonction (résolution, rejet) setTimeout (résolution, 100, 'Success!'); ); 

Avec le code ci-dessus, nous avons créé une promesse, qui sera en fait toujours résolue, car en utilisant le
Settimeout fonction, nous appelons le résoudre rappel après un délai de 100 millisecondes,
Passer la chaîne «Succès!"Comme seul argument du rappel. De la même manière, si nous voulions la promesse
Pour être rejeté, nous aurions dû invoquer le rejeter rappeler. Évidemment une promesse comme le
Un ci-dessus ne nous est pas très utile, nous allons donc maintenant essayer de créer une promesse autour d'une fonction réellement utile.

Le lecture Méthode de la FS module, lit asynchrone le contenu d'un fichier, et
Prend trois arguments: deux d'entre eux sont obligatoires, et l'un est facultatif. Le premier argument est le chemin du fichier
être lu. Le deuxième argument est facultatif, et avec lui, nous pouvons, par exemple, spécifier le
codage à utiliser. Le troisième argument est une fonction de rappel, qui lui-même prend deux arguments:
se tromper et données.

Si l'opération de lecture échoue, le premier argument contiendra un Erreur
objet et le second ne sera pas défini; Si l'opération est réussie, le deuxième argument sera un
chaîne représentant le contenu du fichier, ou un tampon brut si aucun encodage n'est spécifié, tandis que le premier argument
être nul. Dites par exemple que je veux lire mon .vimrc Fichier en utilisant cette fonction:

const fs = require ('fs'); FS.ReadFile ('.vimrc ',' utf-8 ', fonction (err, data) if (err) throw err console.log (data)); 

Tout d'abord, nous avons besoin du FS module et l'a attribué au FS constant, que
Nous avons procédé à invoquer le lecture méthode. Dans le rappel accepté comme le dernier argument de la fonction, nous effectuons
les opérations nécessaires en fonction du résultat obtenu. Dans le code ci-dessus lancer une exception si une erreur se produit
Lorsque vous essayez de lire le fichier, alors que nous imprimons simplement le contenu du fichier si tout se passe comme prévu. Dans ce cas, ce serait
Le résultat (tronqué):

[…] Set fileFormat = Unix set textWidth = 79 set noswapfile set FoldMethod = indent set FollLevel = 99 set SplitRight set SlitBelow set hlsearch set incsearch set set ignorecase set smartcase […] 

La méthode que nous venons d'utiliser, lecture, Effectue l'opération de lecture de manière asynchrone, donc elle ne bloque pas. Par défaut, ce n'est pas,
Cependant, les promesses de soutien. Si nous voulons «promettre» l'utilisation de cette méthode, nous devons créer une promesse autour de nous-mêmes:

const fs = require ('fs'); fonction readFilePromise (filepath) return new promed (function (résoudre, rejeter) fs.readFile (filepath, 'utf-8', fonction (err, data) if (err) reject (err); else résolve (data);); );  

Regardez le code ci-dessus, qu'est-ce que nous avons changé? Nous avons créé le lecture Fonction: à l'intérieur
une promesse basée sur le résultat du FS.lecture la méthode est créée et retournée. Dans l'exemple précédent,
Nous avons ajusté le code pour lancer une exception si une erreur dans l'opération de lecture était présente: dans ce cas
tiennent une promesse, si une erreur se produit, nous appelons le rejeter rappel, passer l'erreur comme son seul argument,
de cette façon rejetant la promesse. Si l'opération de lecture est effectuée avec succès, nous appelons plutôt résoudre, qui passe
Les données résultant de l'opération de lecture comme argument, remplissant ainsi la promesse. Dans le paragraphe suivant, nous verrons comment
Pour consommer réellement la promesse que nous venons de créer.

Méthodes de promesse

Un objet de promesse ne serait d'aucune utilité si nous n'avions pas de moyens d'interagir avec lui et de le consommer. Dans cette section, nous allons
Décrivez les méthodes que nous pouvons utiliser sur l'objet Promise. Chacune de ces méthodes fonctionne sur une promesse et, à son tour, renvoie une promesse
lui-même, nous permettant de créer une «pile» et effectuer une méthode chaînage.

Le alors méthode

Le alors La méthode prend deux arguments, qui sont en fait deux rappels à exécuter respectivement lorsque la promesse
est rempli et lorsqu'il est rejeté, et renvoie une promesse. S'en tenir à l'exemple ci-dessus, voici comment nous pourrions utiliser cette méthode
pour interagir avec la promesse retournée lorsque nous appelons le lecture fonction:

readFilepromise ('.vimrc ').puis (fonction onResolveCallback (data) console.journal (données); , fonction onrejectCallback (raison) console.log ('Le message d'erreur est $ Raison'); ) 

Lorsque la promesse sort du en attente état, et donc il est soit résolu ou rejeté, le alors Méthode
réalisé. Si la promesse est résolue, le premier rappel (dans ce cas, nous avons nommé les rappels juste pour rendre plus facile à comprendre leurs rôles)
est exécuté, son argument détenant le résultat de l'opération asynchrone (dans ce cas, le contenu du «.VIMRC ”Fichier en tant que chaîne).
Si la promesse est rejetée, le deuxième rappel (nous l'avons nommé OnRejectCallback) serait exécuté: son argument contiendra l'erreur
ce qui a fait échouer l'opération de lecture.

Le attraper méthode

Contrairement à alors, qui gère à la fois lorsqu'une promesse est résolue et rejetée, le attraper la méthode est plus spécifique,
et ne traite que de ce dernier cas. L'utilisation de cette méthode est l'équivalent de l'utilisation alors avec indéfini comme le
Premier argument, au lieu du rappel utilisé pour gérer le cas lorsque la promesse est tenue, et avec un rappel valide pour gérer le
cas lorsque la promesse est rejetée, comme la seconde. Cette méthode renvoie une promesse, et en l'utilisant, nous pouvons réécrire le code au-dessus de cette manière:

readFilepromise ('.vimrc ') // à l'intérieur' puis 'nous gérons le cas lorsque la promesse est tenue, traitant // avec des erreurs possibles à l'intérieur de' Catch ' .alors (fonction (data) console.journal (données); ) .catch (fonction (raison) console.log ('Le message d'erreur est $ Raison'); ) 

Observez comment nous avons attaché le attraper Méthode après alors: c'est possible
Parce que, comme nous l'avons dit ci-dessus, chaque méthode renvoie une promesse elle-même, et afin qu'ils puissent être enchaînés.

Le enfin méthode

Comme les méthodes que nous avons vues ci-dessus, enfin Renvoie une promesse. Il est toujours exécuté quel que soit l'état de la promesse,
Les deux s'ils sont résolus ou rejetés. Pour cette raison, le rappel ne prend aucun argument, car lorsqu'il s'exécute, il n'y a aucun moyen de déterminer
Si la promesse a été rejetée ou résolue. Nous utilisons cette méthode lorsque nous voulons exécuter du code générique qui devrait être exécuté dans tous les cas.

readFilepromise ('.vimrc ') .alors (fonction (data) console.journal (données); ) .catch (fonction (raison) console.log ('Le message d'erreur est $ Raison'); ) .Enfin (fonction () console.Log ("Je suis toujours exécuté!");) 

Dans l'exemple ci-dessus, que la promesse soit résolue ou rejetée, la chaîne «Je suis toujours exécutée!"Il est imprimé sur la console.

Le course méthode

Cette méthode prend un itérable (un tableau par exemple) comme argument. Il renvoie une promesse résolue ou rejetée dès qu'un
la promesse contenue dans l'IITARable, existe l'état en attente et devient soit rejeté ou résolu. La promesse retournée, aura le
valeur de réalisation ou raison de rejet de ladite promesse.

const p1 = nouvelle promesse (fonction (résoudre, rejeter) setTimeout (résolution, 100, 'résolu!'); ); const p2 = nouvelle promesse (fonction (résoudre, rejeter) setTimeout (rejeter, 50, 'rejeté!'); ); Promesse.Race ([P1, P2]) .alors (fonction (data) console.journal (données); ) .catch (fonction (raison) console.journal (raison); ) 

Dans cet exemple, nous avons créé deux nouvelles promesses: la première, P1, sera résolu après 100 millisecondes;
le deuxième, P2, sera rejeté après 50 millisecondes. Nous avons passé un itérable contenant les deux promesses comme le
argument unique du Promesse.course méthode. Si nous exécutons le code ci-dessus, nous obtenons le résultat suivant:

rejeté!

Ce qui s'est passé? Comme prévu P2 La promesse est la première à régler (elle est rejetée), par conséquent la promesse
retourné par le Promesse.course Méthode, rejette avec la même raison. Comme vous pouvez le voir, l'état de la promesse n'est pas pertinent:
le premier qui obtient en fait un statut autre que en attente est celui qui compte.

Le tous méthode

Comme course, le tous La méthode prend un itérable comme son seul argument. Il renvoie une promesse qui
se résoudra une fois que toutes les promesses contenues dans l'itérable se résoudront (ou quand l'IDéable ne contient aucune promesse) ou
rejeter avec la raison de la première promesse de l'Itérable qui rejetera. Par exemple:

const p1 = nouvelle promesse (fonction (résolution, rejet) setTimeout (résolution, 100, 'p1 résolu!'); ) const p2 = nouvelle promesse (fonction (résoudre, rejeter) setTimeout (Resolve, 100, 'p2 résolu!'); ) Promesse.Tous ([P1, P2]) .alors (fonction (valeurs) console.log (valeurs); ) 

Le code ci-dessus reviendra:

['P1 résolu!',' 'P2 a résolu!']

Toutes les promesses contenues dans l'itérable ont résolu, donc la promesse en attente retournée par le tous méthode
Résolu également, sa valeur étant un tableau contenant les valeurs de toutes les promesses résolues. Si un (et dès) l'une des promesses
Dans les rejets itérables, la promesse renvoyée par la méthode rejette également, avec la même raison. Si l'itérable passait comme l'argument
été vide, une promesse déjà résolu aurait été retournée. Si l'itérable ne contenait aucune promesse, la méthode serait revenue
Une promesse résolue asynchrone ou une promesse déjà résolue en fonction de l'environnement.

Le résoudre et rejeter méthodes

Ces deux méthodes sont explicites.

Le résoudre La méthode prend un argument qui est la valeur à résoudre par la promesse.
Il renvoie une promesse qui est résolue avec cette valeur. Le rejeter la méthode, de même, prend un argument qui est la raison avec
La promesse doit être rejetée et renvoie une promesse qui est rejetée avec la raison donnée. Par exemple:

// résoudre une promesse prometteuse.résolution («valeur résolue»); // rejeter une promesse prometteuse.rejeter («raison de rejeter»); 

Conclusions

Dans ce tutoriel, nous avons appris à connaître et à utiliser des promesses en javascript. Nous avons vu comment pouvons-nous faire nos propres promesses, quelles sont les méthodes associées
avec une promesse, et comment pouvons-nous l'utiliser pour gérer le code asynchrone, comme une alternative plus propre aux rappels. Une source valable pour augmenter encore
Votre connaissance des promesses c'est celle fournie par Mozilla.
Dans le prochain tutoriel JavaScript, nous apprendrons à utiliser fonctions flèches. Restez à l'écoute sur LinuxConfig.org!

Tutoriels Linux connexes:

• Comment créer une application Tkinter à l'aide d'un objet orienté…
• Tutoriel de débogage GDB pour les débutants
• Comment travailler avec l'API WooCommerce REST avec Python
• Python Expressions régulières avec des exemples
• Advanced Bash Regex avec des exemples
• Masterring Bash Script Loops
• Boucles imbriquées dans les scripts bash
• Comment configurer un serveur OpenVPN sur Ubuntu 20.04
• Installez Arch Linux dans VMware Workstation
• Boucles de bash avec des exemples