par Neil lobo, ingénieur logiciel

Une partie de la popularité de node. js est la boucle d'événements. Plutôt que de prendre l'approche multithread des frameworks traditionnels, node. js utilise un modèle d'e/S non bloquant et piloté par des événements. Cela lui donne une empreinte de mémoire plus légère, est plus léger et efficace, et s'adapte bien pour les applications en temps réel intensives de données.

Cette approche non bloquant pilotée par l'événement fonctionne bien pour les applications où le goulot d'étranglement est l'activité d'e/S ou de réseau. En revanche, si l'application nécessite des tâches gourmandes en UC, node. js est probablement un mauvais choix.

Cependant, le travail avec le noeud. js nu exige l'utilisation des rappels asynchrones qui conduisent à l'enfer infâme de rappel. Cela conduit à la logique qui est difficile à suivre

//Callback Soup/Spiral Callback of Doom
function doAsync1(function () {
    doAsync2(function () {
      doAsync3(function () {
        doAsync4(function () {
          //finally do something });
        });
      });
  });

La gestion des erreurs et les rappels imbriqués sont inconfortables à écrire, et leur existence rend le code difficile à maintenir et à mettre à l'échelle. Il existe quelques techniques pour surmonter ces problèmes, les plus populaires étant les fibres et les promesses.  Je veux discuter de l'ancien comme Meteor utilise des fibres pour atteindre synchrone comme le code sur la boucle d'événement.

Fibres

Pour ceux qui ne sont pas familiers avec elle, les fibres est une construction informatique qui utilisent un modèle de coopération multitâche (à la différence des threads utilisent la préemption multitâche)

Le code fileté peut être interrompu à tout moment, même au milieu de l'évaluation d'une expression, pour donner des cycles CPU au code en cours d'exécution dans un autre thread. Avec les fibres, ces interruptions et les commutateurs de contexte ne sont pas déterminés par le CPU ou un processus de niveau inférieur; ils sont déterminés par le programmeur qui décide où son code va céder et donner des cycles CPU à d'autres fibres.

Voici un exemple de code node. js typique qui utilise un callbackFunction qui est passé le résultat.

getDataFromDisk = function(fileName, key, callbackFunction) { 

  résultat var; 

  fs.readFile('/path/fileName', function(err, res) {
    if (err) console.log(err); else {
    result = transform(res, key);
    callbackFunction(result);
  }}};

Permet de viser à écrire est dans un style plus synchrone

getDataFromDisk = function(fileName, key) {
  var result;
  fs.readFile('/path/fileName', function(err, res) {
    if (err) console.log(err);    else result = transform(res, key); 

  }
  return result;// sera toujours indéfini
} ;
// Nous essayons d'utiliser getDataFromDisk pour retourner la valeur, alors
// Imprimez le tout de façon synchrone.
var result = getDataFromDisk('helloWorld',key) ;
console.log(résultat) ;
indéfini // indéfini

Le code ci-dessus retournera toujours non défini, car la boucle d'événements se déplace sur la ligne de résultat de retour (*) sans attendre le résultat du rappel.

Utilisation des fibres

Les fibres sont une classe de fonctions de conteneur qui peut être utilisée pour bloquer une sous-routine en attendant sur certaines e/S ou l'activité du réseau sans bloquer l'ensemble du processus.

var Fiber = Npm.require('fibers');// getDataFromDisk function using Fibers
getDataFromDisk = function(filename, key) {var fiber = Fiber.current; //get the current Fiber
fs.readFile('/path/fileName', function(err, res) {
if (err) console.log(err); else{
/* Resume execution of this fiber. What’s passed to fiber.run will become the value returned by Fiber.yield below */
fiber.run( transform(res, key) );
var result = Fiber.yield();
return result;};
// Finally we wrap our code in a Fiber, then run it
Fiber(function() { 

var result = getDataFromDisk('helloWorld', clé) ;
console.log(résultat) ;
}).run() ;

Presto, nous avons le code prospectif synchrone qui est toujours exécuté de façon asynchrone sur la boucle d'événement.

Pour plus de détails sur les fibres Check out (https://github.com/laverdet/node-fibers)