Node.js
Programmation asynchrone

Introduction

Syntaxe

• doQuelque chose ([args], function ([argsCB]) {/ * fait quelque chose quand c'est fait * /});
• doQuelque chose ([args], ([argsCB]) => {/ * fait quelque chose quand c'est fait * /});

Fonctions de rappel

Fonctions de rappel en JavaScript

Les fonctions de rappel sont communes en JavaScript. Les fonctions de rappel sont possibles en JavaScript car les fonctions sont des citoyens de premier ordre .

Rappels synchrones.

Les fonctions de rappel peuvent être synchrones ou asynchrones. Comme les fonctions de rappel asynchrones peuvent être plus complexes, voici un exemple simple de fonction de rappel synchrone.

// a function that uses a callback named `cb` as a parameter
function getSyncMessage(cb) {
    cb("Hello World!");
}

console.log("Before getSyncMessage call");
// calling a function and sending in a callback function as an argument.
getSyncMessage(function(message) {
    console.log(message);
});
console.log("After getSyncMessage call");

La sortie du code ci-dessus est:

> Before getSyncMessage call
> Hello World!
> After getSyncMessage call

Nous allons d'abord passer en revue comment le code ci-dessus est exécuté. C'est plus pour ceux qui ne comprennent pas déjà le concept des rappels si vous comprenez déjà que vous pouvez sauter ce paragraphe. Tout d'abord, le code est analysé, puis la première chose intéressante à faire est que la ligne 6 soit exécutée, ce qui Before getSyncMessage call à la console. Ensuite, la ligne 8 est exécutée et appelle la fonction getSyncMessage envoyant une fonction anonyme en tant qu'argument du paramètre nommé cb dans la fonction getSyncMessage . L'exécution est maintenant effectuée dans la fonction getSyncMessage de la ligne 3 qui exécute la fonction cb qui vient d'être transmise, cet appel envoie une chaîne d'argument "Hello World" pour le message nommé param dans la fonction anonyme passée. L'exécution va ensuite à la ligne 9 qui connecte Hello World! à la console. Ensuite, l'exécution passe par le processus de sortie de la pile d'appels ( voir aussi ) en frappant la ligne 10 puis la ligne 4 puis finalement en revenant à la ligne 11.

Quelques informations à connaître sur les rappels en général:

• La fonction que vous envoyez à une fonction en tant que rappel peut être appelée zéro fois, une fois ou plusieurs fois. Tout dépend de la mise en œuvre.
• La fonction de rappel peut être appelée de manière synchrone ou asynchrone et éventuellement de manière synchrone et asynchrone.
• Tout comme les fonctions normales, les noms que vous attribuez aux paramètres de votre fonction ne sont pas importants, mais l'ordre est. Ainsi, par exemple, à la ligne 8, le message paramètre pourrait avoir été nommé statement , msg ou si vous êtes insensé, comme jellybean . Vous devez donc savoir quels paramètres sont envoyés dans votre callback pour que vous puissiez les obtenir dans le bon ordre avec des noms propres.

Rappels asynchrones.

Une chose à noter à propos de JavaScript est qu'il est synchrone par défaut, mais il existe des API dans l'environnement (navigateur, Node.js, etc.) qui pourraient le rendre asynchrone (il y a plus à ce sujet ici ).

Quelques éléments communs qui sont asynchrones dans les environnements JavaScript qui acceptent les rappels:

• Événements
• setTimeout
• mettreInterval
• l'API d'extraction
• Promesses

De plus, toute fonction qui utilise l'une des fonctions ci-dessus peut être entourée d'une fonction qui prend un rappel et le rappel serait alors un rappel asynchrone (bien que l'encapsulation d'une promesse avec une fonction prenant un rappel serait probablement considérée comme un anti-pattern comme il y a plus de moyens préférés pour gérer les promesses).

Donc, étant donné cette information, nous pouvons construire une fonction asynchrone similaire à celle ci-dessus synchrone.

// a function that uses a callback named `cb` as a parameter
function getAsyncMessage(cb) {
    setTimeout(function () { cb("Hello World!") }, 1000);
}

console.log("Before getSyncMessage call");
// calling a function and sending in a callback function as an argument.
getAsyncMessage(function(message) {
    console.log(message);
});
console.log("After getSyncMessage call");

Qui imprime les éléments suivants sur la console:

> Before getSyncMessage call
> After getSyncMessage call
// pauses for 1000 ms with no output
> Hello World!

L'exécution de ligne passe à la ligne 6 des journaux "Avant l'appel getSyncMessage". Ensuite, l'exécution va à la ligne 8 appelant getAsyncMessage avec un rappel pour le paramètre cb . La ligne 3 est alors exécutée et appelle setTimeout avec un rappel comme premier argument et le numéro 300 comme second argument. setTimeout fait tout ce qu'il fait et retient ce rappel pour pouvoir l'appeler plus tard en 1000 millisecondes, mais après avoir configuré le délai d'attente et avant de suspendre les 1000 millisecondes, il renvoie l'exécution à la ligne 4 , puis la ligne 11, puis s'arrête pendant 1 seconde et setTimeout appelle alors sa fonction de rappel qui getAsyncMessages exécution sur la ligne 3 où le rappel getAsyncMessages est appelé avec la valeur "Hello World" pour son message paramètre qui est ensuite consigné sur la ligne 9 .

Fonctions de rappel dans Node.js

NodeJS a des rappels asynchrones et fournit généralement deux paramètres à vos fonctions, parfois appelés de manière conventionnelle err et data . Un exemple avec la lecture d'un fichier texte.

const fs = require("fs");

fs.readFile("./test.txt", "utf8", function(err, data) {
    if(err) {
        // handle the error 
    } else {
        // process the file text given with data
    }
});

Ceci est un exemple de rappel appelé une seule fois.

Il est recommandé de gérer l'erreur d'une manière ou d'une autre, même si vous ne faites que la connecter ou la lancer. Le reste n'est pas nécessaire si vous lancez ou renvoyez et que vous pouvez le supprimer pour diminuer l'indentation tant que vous arrêtez l'exécution de la fonction en cours dans le if en faisant quelque chose comme lancer ou retourner.

Bien qu'il soit fréquent de voir err , les data ne peut pas toujours être le cas que vos callbacks utiliseront ce modèle , il est préférable de regarder la documentation.

Un autre exemple de rappel provient de la bibliothèque express (express 4.x):

// this code snippet was on http://expressjs.com/en/4x/api.html
const express = require('express');
const app = express();

// this app.get method takes a url route to watch for and a callback
// to call whenever that route is requested by a user.
app.get('/', function(req, res){
  res.send('hello world');
});

app.listen(3000);

Cet exemple montre un rappel appelé plusieurs fois. Le rappel est fourni avec deux objets en tant que paramètres nommés ici comme req et res ces noms correspondent respectivement à la requête et à la réponse, et ils permettent de visualiser la requête et de définir la réponse qui sera envoyée à l'utilisateur.

Comme vous pouvez le voir, il existe différentes manières d’utiliser un rappel pour exécuter la synchronisation et le code asynchrone en JavaScript et les rappels sont très répandus dans JavaScript.

Exemple de code

Question: Quelle est la sortie du code ci-dessous et pourquoi?

setTimeout(function() {
    console.log("A");
}, 1000);

setTimeout(function() {
    console.log("B");
}, 0);

getDataFromDatabase(function(err, data) {
    console.log("C");
    setTimeout(function() {
        console.log("D");
    }, 1000);
});

console.log("E");

Sortie: Ceci est connu avec certitude: EBAD . C est inconnu quand il sera enregistré.

Explication: Le compilateur ne s'arrêtera pas sur les méthodes setTimeout et getDataFromDatabase . Donc, la première ligne qu'il enregistrera est E Les fonctions de rappel (premier argument de setTimeout ) seront exécutées après le délai d'attente défini de manière asynchrone!

Plus de détails:

1. E n'a pas de setTimeout
2. B a un délai d'attente de 0 milliseconde
3. A a un délai d'attente de 1000 millisecondes
4. D doit demander une base de données, après il doit D attendre 1000 millisecondes il vient après A .
5. C est inconnu car il est inconnu lorsque les données de la base de données sont demandées. Cela pourrait être avant ou après A

Traitement d'erreur asynchrone

Essayer attraper

Les erreurs doivent toujours être traitées. Si vous utilisez une programmation synchrone, vous pouvez utiliser un try catch . Mais cela ne fonctionne pas si vous travaillez asynchrone! Exemple:

try {
    setTimeout(function() {
        throw new Error("I'm an uncaught error and will stop the server!");
    }, 100); 
}
catch (ex) {
    console.error("This error will not be work in an asynchronous situation: " + ex);
}

Les erreurs asynchrones ne seront traitées que dans la fonction de rappel!

Possibilités de travail

process.on("UncaughtException", function(err, data) { 
    if (err) {
        // error handling
    }
});

var domain = require("domain");
var d1 = domain.create();
var d2 = domain.create();

d1.run(function() {
    d2.add(setTimeout(function() {
        throw new Error("error on the timer of domain 2");
    }, 0));
});

d1.on("error", function(err) {
    console.log("error at domain 1: " + err);
});

d2.on("error", function(err) {
    console.log("error at domain 2: " + err);
});

Enfer de rappel

Callback hell (également une pyramide d'effet doom ou boomerang) se produit lorsque vous imbriquez trop de fonctions de rappel dans une fonction de rappel. Voici un exemple pour lire un fichier (dans ES6).

const fs = require('fs');
let filename = `${__dirname}/myfile.txt`;

fs.exists(filename, exists => {
    if (exists) {
        fs.stat(filename, (err, stats) => {
            if (err) {
                throw err;
            }
            if (stats.isFile()) {
                fs.readFile(filename, null, (err, data) => {
                    if (err) {
                        throw err;
                    }
                    console.log(data);
                });
            }
            else {
                throw new Error("This location contains not a file");
            }
        });
    }
    else {
        throw new Error("404: file not found");
    }
}); 

Comment éviter "Callback Hell"

Il est recommandé de ne pas imbriquer plus de 2 fonctions de rappel. Cela vous aidera à maintenir la lisibilité du code et sera beaucoup plus facile à maintenir à l'avenir. Si vous devez imbriquer plus de 2 rappels, essayez plutôt d'utiliser des événements distribués .

Il existe également une bibliothèque appelée async qui aide à gérer les callbacks et leur exécution disponible sur npm. Il améliore la lisibilité du code de rappel et vous permet de mieux contrôler le flux de votre code de rappel, en vous permettant notamment de les exécuter en parallèle ou en série.

Promesses autochtones

function timeout (ms) {
  return new Promise(function (resolve, reject) {
    setTimeout(function () {
      resolve("It was resolved!");
    }, ms)
  });
}

timeout(1000).then(function (dataFromPromise) {
  // logs "It was resolved!"
  console.log(dataFromPromise);
})

console.log("waiting...");

waiting...
// << pauses for one second>>
It was resolved!

En savoir plus sur les promesses dans la documentation JavaScript promesses .