Comment envelopper les appels de fonction asynchrone dans une fonction de synchronisation dans Node.js ou Javascript?

Supposons que vous mainteniez une bibliothèque qui expose une fonction getData. Vos utilisateurs l'appellent pour obtenir des données réelles:
var output = getData();
sous le capot, les données sont enregistrées dans un fichier, vous l'avez donc implémenté à l' getDataaide de Node.js intégré fs.readFileSync. C'est évident à la fois getDataet ce fs.readFileSyncsont des fonctions de synchronisation. Un jour, on vous a dit de basculer la source de données sous-jacente vers un dépôt tel que MongoDB qui ne peut être accédé que de manière asynchrone. On vous a également dit d'éviter d'énerver vos utilisateurs,getData API ne peut pas être modifiée pour renvoyer simplement une promesse ou exiger un paramètre de rappel. Comment répondez-vous aux deux exigences?

La fonction asynchrone utilisant le rappel / la promesse est l'ADN de JavasSript et Node.js. Toute application JS non triviale est probablement imprégnée de ce style de codage. Mais cette pratique peut facilement conduire à la soi-disant pyramide de callback of doom. Pire encore, si un code dans un appelant dans la chaîne d'appels dépend du résultat de la fonction asynchrone, ce code doit également être enveloppé dans la fonction de rappel, imposant une contrainte de style de codage à l'appelant. De temps en temps, je trouve le besoin d'encapsuler une fonction asynchrone (souvent fournie dans une bibliothèque tierce) dans une fonction de synchronisation afin d'éviter une refactorisation globale massive. La recherche d'une solution à ce sujet aboutissait généralement à des Node Fiberspackages ou npm dérivés. Mais Fibers ne peut tout simplement pas résoudre le problème auquel je suis confronté. Même l'exemple fourni par l'auteur de Fibers illustre la carence:

...
Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

Sortie réelle:

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)

Si la fonction Fibre transforme réellement le sommeil de la fonction asynchrone en synchronisation, la sortie doit être:

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)
back in main

J'ai créé un autre exemple simple dans JSFiddle et je cherche du code pour produire la sortie attendue. J'accepterai une solution qui ne fonctionne que dans Node.js, vous êtes donc libre d'exiger n'importe quel package npm même si vous ne travaillez pas dans JSFiddle.

deasync transforme la fonction async en synchronisation, implémentée avec un mécanisme de blocage en appelant la boucle d'événement Node.js au niveau de la couche JavaScript. En conséquence, deasync bloque uniquement l'exécution du code suivant sans bloquer tout le thread, ni entraîner une attente occupée. Avec ce module, voici la réponse au défi jsFiddle:

function AnticipatedSyncFunction(){
  var ret;
  setTimeout(function(){
      ret = "hello";
  },3000);
  while(ret === undefined) {
    require('deasync').runLoopOnce();
  }
  return ret;    
}


var output = AnticipatedSyncFunction();
//expected: output=hello (after waiting for 3 sec)
console.log("output="+output);
//actual: output=hello (after waiting for 3 sec)

(avertissement: je suis le co-auteur de deasync. Le module a été créé après la publication de cette question et n'a trouvé aucune proposition viable.)

Il existe également un module de synchronisation npm. qui est utilisé pour synchroniser le processus d'exécution de la requête.

Lorsque vous souhaitez exécuter des requêtes parallèles de manière synchrone, le nœud se limite à le faire car il n'attend jamais de réponse. et le module de synchronisation est parfait pour ce type de solution.

Exemple de code

/*require sync module*/
var Sync = require('sync');
    app.get('/',function(req,res,next){
      story.find().exec(function(err,data){
        var sync_function_data = find_user.sync(null, {name: "sanjeev"});
          res.send({story:data,user:sync_function_data});
        });
    });


    /*****sync function defined here *******/
    function find_user(req_json, callback) {
        process.nextTick(function () {

            users.find(req_json,function (err,data)
            {
                if (!err) {
                    callback(null, data);
                } else {
                    callback(null, err);
                }
            });
        });
    }

lien de référence: https://www.npmjs.com/package/sync

Si la fonction Fibre transforme vraiment le sommeil de la fonction asynchrone en synchronisation

Oui. À l'intérieur de la fibre, la fonction attend avant de se connecter ok. Les fibres ne rendent pas les fonctions asynchrones synchrones, mais permettent d'écrire du code d'apparence synchrone qui utilise des fonctions asynchrones, puis s'exécutera de manière asynchrone dans un fichier Fiber.

De temps en temps, je trouve le besoin d'encapsuler une fonction asynchrone dans une fonction de synchronisation afin d'éviter une refactorisation globale massive.

Vous ne pouvez pas. Il est impossible de rendre le code asynchrone synchrone. Vous devrez anticiper cela dans votre code global et l'écrire dans un style asynchrone depuis le début. Que vous enveloppiez le code global dans une fibre, utilisiez des promesses, des générateurs de promesses ou de simples rappels dépend de vos préférences.

Mon objectif est de minimiser l'impact sur l'appelant lorsque la méthode d'acquisition de données passe de sync à async

Les promesses et les fibres peuvent le faire.

Vous devez utiliser les promesses:

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async () => {
    return await asyncOperation();
}

const topDog = () => {
    asyncFunction().then((res) => {
        console.log(res);
    });
}

J'aime plus les définitions des fonctions fléchées. Mais toute chaîne de la forme "() => {...}" pourrait aussi être écrite comme "function () {...}"

Ainsi, topDog n'est pas asynchrone malgré l'appel d'une fonction async.

EDIT: Je me rends compte que la plupart du temps, vous devez envelopper une fonction asynchrone dans une fonction de synchronisation à l'intérieur d'un contrôleur. Pour ces situations, voici une astuce de fête:

const getDemSweetDataz = (req, res) => {
    (async () => {
        try{
            res.status(200).json(
                await asyncOperation()
            );
        }
        catch(e){
            res.status(500).json(serviceResponse); //or whatever
        }
    })() //So we defined and immediately called this async function.
}

En utilisant cela avec des rappels, vous pouvez faire un wrap qui n'utilise pas de promesses:

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async (callback) => {
    let res = await asyncOperation();
    callback(res);
}

const topDog = () => {
    let callback = (res) => {
        console.log(res);
    };

    (async () => {
        await asyncFunction(callback)
    })()
}

En appliquant cette astuce à un EventEmitter, vous pouvez obtenir les mêmes résultats. Définissez l'écouteur de l'EventEmitter où j'ai défini le rappel et émettez l'événement où j'ai appelé le rappel.

Je ne trouve pas de scénario qui ne puisse pas être résolu en utilisant des fibres de nœuds. L'exemple que vous avez fourni à l'aide de nœuds-fibres se comporte comme prévu. La clé est d'exécuter tout le code pertinent à l'intérieur d'une fibre, afin que vous n'ayez pas à démarrer une nouvelle fibre dans des positions aléatoires.

Voyons un exemple: disons que vous utilisez un framework, qui est le point d'entrée de votre application (vous ne pouvez pas modifier ce framework). Ce framework charge les modules nodejs en tant que plugins et appelle certaines méthodes sur les plugins. Disons que ce cadre n'accepte que les fonctions synchrones et n'utilise pas de fibres par lui-même.

Il existe une bibliothèque que vous souhaitez utiliser dans l'un de vos plugins, mais cette bibliothèque est asynchrone et vous ne souhaitez pas non plus la modifier.

Le thread principal ne peut pas être généré lorsqu'aucune fibre n'est en cours d'exécution, mais vous pouvez toujours créer des plugins en utilisant des fibres! Créez simplement une entrée wrapper qui démarre tout le framework à l'intérieur d'une fibre, afin de pouvoir générer l'exécution à partir des plugins.

Inconvénient: si le framework utilise setTimeoutou Promises en interne, il échappera au contexte de la fibre. Cela peut être contourné en se moquant setTimeout, Promise.thenet tous les gestionnaires d'événements.

C'est ainsi que vous pouvez produire une fibre jusqu'à ce que a Promisesoit résolu. Ce code prend une fonction asynchrone (Promise retournant) et reprend la fibre lorsque la promesse est résolue:

framework-entry.js

console.log(require("./my-plugin").run());

async-lib.js

exports.getValueAsync = () => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve("Async Value");
    }, 100);
  });
};

mon-plugin.js

const Fiber = require("fibers");

function fiberWaitFor(promiseOrValue) {
  var fiber = Fiber.current, error, value;
  Promise.resolve(promiseOrValue).then(v => {
    error = false;
    value = v;
    fiber.run();
  }, e => {
    error = true;
    value = e;
    fiber.run();
  });
  Fiber.yield();
  if (error) {
    throw value;
  } else {
    return value;
  }
}

const asyncLib = require("./async-lib");

exports.run = () => {
  return fiberWaitFor(asyncLib.getValueAsync());
};

mon-entrée.js

require("fibers")(() => {
  require("./framework-entry");
}).run();

Lorsque vous exécutez node framework-entry.jsil lancera une erreur: Error: yield() called with no fiber running. Si vous exécutez node my-entry.jscela fonctionne comme prévu.

La synchronisation du code Node.js est essentielle dans certains aspects tels que la base de données. Mais l'avantage réel de Node.js réside dans le code asynchrone. Comme il s'agit d'un seul thread non bloquant.

nous pouvons le synchroniser en utilisant une fonctionnalité importante Fiber () Utilisez await () et defer () nous appelons toutes les méthodes en utilisant await (). puis remplacez les fonctions de rappel par defer ().

Code Async normal, qui utilise les fonctions de rappel.

function add (var a, var b, function(err,res){
       console.log(res);
});

 function sub (var res2, var b, function(err,res1){
           console.log(res);
    });

 function div (var res2, var b, function(err,res3){
           console.log(res3);
    });

Synchronisez le code ci-dessus en utilisant Fiber (), await () et defer ()

fiber(function(){
     var obj1 = await(function add(var a, var b,defer()));
     var obj2 = await(function sub(var obj1, var b, defer()));
     var obj3 = await(function sub(var obj2, var b, defer()));

});

J'espère que cela aidera. Merci

De nos jours, ce modèle de générateur peut être une solution dans de nombreuses situations.

Voici un exemple d'invites de console séquentielles dans nodejs à l'aide de la fonction async readline.question:

var main = (function* () {

  // just import and initialize 'readline' in nodejs
  var r = require('readline')
  var rl = r.createInterface({input: process.stdin, output: process.stdout })

  // magic here, the callback is the iterator.next
  var answerA = yield rl.question('do you want this? ', r=>main.next(r))    

  // and again, in a sync fashion
  var answerB = yield rl.question('are you sure? ', r=>main.next(r))        

  // readline boilerplate
  rl.close()

  console.log(answerA, answerB)

})()  // <-- executed: iterator created from generator
main.next()     // kick off the iterator, 
                // runs until the first 'yield', including rightmost code
                // and waits until another main.next() happens

Vous ne devriez pas regarder ce qui se passe autour de l'appel qui crée la fibre, mais plutôt ce qui se passe à l' intérieur de la fibre. Une fois que vous êtes à l'intérieur de la fibre, vous pouvez programmer dans le style de synchronisation. Par exemple:

fonction f1 () {
    console.log ('attendre ...' + nouvelle date);
    sommeil (1000);
    console.log ('ok ...' + nouvelle date);   
}

fonction f2 () {
    f1 ();
    f1 ();
}

Fibre (fonction () {
    f2 ();
}).courir();

À l'intérieur de la fibre que vous appelez f1, f2et sleepcomme s'ils étaient synchronisés.

Dans une application Web classique, vous allez créer la fibre dans votre répartiteur de requêtes HTTP. Une fois que vous avez fait cela, vous pouvez écrire toute votre logique de gestion des demandes dans le style de synchronisation, même si elle appelle des fonctions asynchrones (fs, bases de données, etc.).

J'ai eu du mal avec cela au début avec node.js et async.js est la meilleure bibliothèque que j'ai trouvée pour vous aider à gérer cela. Si vous souhaitez écrire du code synchrone avec node, l'approche est la suivante.

var async = require('async');

console.log('in main');

doABunchOfThings(function() {
  console.log('back in main');
});

function doABunchOfThings(fnCallback) {
  async.series([
    function(callback) {
      console.log('step 1');
      callback();
    },
    function(callback) {
      setTimeout(callback, 1000);
    },
    function(callback) {
      console.log('step 2');
      callback();
    },
    function(callback) {
      setTimeout(callback, 2000);
    },
    function(callback) {
      console.log('step 3');
      callback();
    },
  ], function(err, results) {
    console.log('done with things');
    fnCallback();
  });
}

ce programme produira TOUJOURS ce qui suit ...

in main
step 1
step 2
step 3
done with things
back in main

Javascript est un langage à thread unique, vous ne voulez pas bloquer tout votre serveur! Le code async élimine les conditions de concurrence en rendant les dépendances explicites.

Apprenez à aimer le code asynchrone!

Jetez un œil au promisescode asynchrone sans créer une pyramide de l'enfer des rappels. Je recommande la bibliothèque promiseQ pour node.js

httpGet(url.parse("http://example.org/")).then(function (res) {
    console.log(res.statusCode);  // maybe 302
    return httpGet(url.parse(res.headers["location"]));
}).then(function (res) {
    console.log(res.statusCode);  // maybe 200
});

http://howtonode.org/promises

EDIT: c'est de loin ma réponse la plus controversée, node a maintenant le mot-clé yield, qui vous permet de traiter le code asynchrone comme s'il était synchrone. http://blog.alexmaccaw.com/how-yield-will-transform-node