Code synchrone ou asynchrone avec Node.js

Nous travaillons avec le noeud, surtout pour un projet interne et de comprendre la meilleure façon d'utiliser la technologie.

Pas à venir à partir d'un certain asynchrone arrière-plan de la courbe d'apprentissage peut être un défi, mais nous commençons à nous habituer à le cadre et le processus d'apprentissage.

Une chose qui a polarisé nous, c'est quand le meilleur moment pour utiliser code synchrone vs asynchrone code est. Nous sommes actuellement en utilisant la règle que si rien interagit avec IO alors, il doit être asynchrone via des rappels ou de la manifestation de l'émetteur (c'est un), mais d'autres éléments qui ne sont en aucune manière à l'aide de IO peuvent être construits de façon synchrone fonctions (cela dépend aussi de la lourdeur de la fonction elle-même et comment le bloquer à l'est effectivement), mais est-ce la meilleure approche à prendre lorsque vous travaillez avec Node.js?

Par exemple, la création d'un Hal+JSON builder, ce qui existe actuellement au sein de notre base de code. Elle est synchrone tout simplement parce que tout ça est fait, c'est la création de certains petits objets littéraux et rien de plus, il n'y a pas de dépendances externes et certainement pas d'IO interactions.

Notre approche est bonne à prendre ou pas?

source d'informationauteur Modika

  1. 18

    Disons que vous avez deux fonctions, foo et barqui sont en cours d'exécution en mode synchrone:

    function foo() {
    var returnValue = bar();
    console.log(returnValue);
}

function bar() {
    return "bar";
}

    Afin de rendre l'API "asynchrone" est à modifier pour utiliser les rappels:

    function foo() {
    bar(function(returnValue) {
        console.log(returnValue);
    });
}

function bar(callback) {
    callback("bar");
}

    Mais le fait de la question est, ce code est toujours synchrone. La fonction de rappel est en cours d'exécution sur la même pile, et pas de chargement des optimisations sont faites, aucune évolutivité avantages sont.

    Il devient alors une question de code readablity et le style de codage. Personnellement, je trouve le typique var val = func(); type de code plus lisible et facilement compréhensible. Le seul inconvénient est que si vous avez un jour besoin de changer la fonctionnalité de bar de sorte qu'il en aurait besoin pour effectuer une activité d'e/S ou appeler une autre fonction qui est asynchrone, vous devez changer l'API de bar.

    Mon personnels préférence: utilisation traditionnelle, synchnous motifs, le cas échéant. Toujours utiliser asynchrone style lors de l'I/O est en cause, ou en cas de doute.

  2. 3

    Tournant une fonction synchrone dans un asynchrones à l'aide d'un processus.nextTick() est une option, mais vous devez utiliser uniquement si votre logiciel bloque trop longtemps. Chaque fois que votre fonction synchrone est en cours d'exécution nœud ne peut rien faire d'autre que monothread. Cela signifie que si votre application est un serveur, il ne répond pas.

    Avant de vous séparer de toute fonction synchrone, je vous conseille de tout d'abord faire quelques étalonnage et le profilage de sorte que vous pouvez prendre une décision éclairée. Sinon, vous courez le risque de dong prématuré d'optimisation

    Voir ici pour une bonne discussion https://softwareengineering.stackexchange.com/questions/80084/is-premature-optimization-really-the-root-of-all-evil

    Voici comment vous pouvez faire de votre fonction d'un système, dans le sens qui vous permettra noeud pour faire d'autres choses http://howtonode.org/understanding-process-next-tick

  3. 1

    Je ne sais pas ce que "Hal+Json builder", mais voici ce que je pense de NodeJS. Vous devez écrire votre code asynchrone que possible, en la poussant à ses limites. La simple raison est que le code asynchrone métiers de performance pour la réactivité, qui est dans la plupart des cas de plus en plus important.

    Bien sûr, si certaines opérations sont vraiment rapide, il n'est pas besoin de code asynchrone. Par exemple, considérons ce code:

    var arr = []; //assume array is nonempty
for (var i = 0, l = arr.length; i < l; i++) {
    arr[ i ].doStuff( );
}

    Si arr est petit et doStuff est une opération rapide, alors vous ne devriez pas la peine dans la rédaction de ce code de manière asynchrone. Toutefois, si cela prend un certain temps, alors vous devriez envisager d'écrire comme cela:

    var arr = []; //assume array is nonempty
var process_array_element = function( ) {
    if (arr.length) {
        arr.pop().doStuff( );
        process.nextTick( process_array_element );
    }
};
process_array_element( );

    Maintenant ce code est vraiment asynchrone. Il faudra encore plus de temps pour terminer le travail, mais en attendant, il ne bloque pas tout le serveur. Nous avons échangé des performances de réactivité.

    Conclusion: Cela dépend de votre situation! 🙂