La lecture et le renvoi de plusieurs fichiers en Node.js à l'aide de fs.readFile

Je suis en train d'écrire un simple gestionnaire des demandes de retour d'une paire de fichiers css. À l'aide de fs.readFileSync c'était facile. Cependant, je vais avoir des difficultés à accomplir la même tâche à l'aide de la version asynchrone de readFile. Ci-dessous mon code. Avoir ma réponse.méthode write() appels répartis entre deux différents rappels semble être problématique. Quelqu'un peut-il point de ce que j'ai fait de mal? Il est intéressant de noter que ce code fonctionne si je mets la réponse.fin() à l'intérieur de la première instruction else. Cependant, cela crée un problème en ce que le deuxième fichier css ne obtenez pas de retour (car la réponse.fin() a déjà été tiré).

function css(response) {

  response.writeHead(200, {"Content-Type": "text/css"});

  fs.readFile('css/bootstrap.css', function(error, content){
    if(error){
      console.log(error);
    }
    else{
      response.write(content);
    }
  });
  fs.readFile('css/bootstrap-responsive.css', function(error, content){
    if(error){
      console.log(error);
    }
    else{
      response.write(content)
    }
  });
  response.end();
}

Si vous vous essayer d'ajouter les deux fichiers CSS dans une réponse?
Oui, c'est vrai.
Est-il une raison pour laquelle vous devez lire les fichiers chaque fois que quelqu'un fait une demande? Attendez-vous à changer souvent? Si non, il suffit de lire dans la mémoire lorsque le serveur est démarré et retour en cas de besoin. Fonctionne plus rapidement.
Ou, prendre un coup d'oeil à fs.montre nodejs.org/docs/latest/api/...

OriginalL'auteur hughesdan | 2012-02-25

node.js

Le principal problème avec ce que vous avez est que response.end() est appelé tout de suite. Vous devez seulement appeler ça une fois que les fichiers ont fait leur response.write appels.

La façon la plus simple serait d'utiliser un flux de contrôle de la bibliothèque. La gestion de plusieurs rappels asynchrones est généralement compliqué.

https://github.com/joyent/node/wiki/modules#wiki-async-flow

Je vais utiliser le asynchrone bibliothèque parce que c'est celui que je connais le mieux.

var fs = require('fs');
var async = require('async');

function css(response) {
  response.writeHead(200, {"Content-Type": "text/css"});

  async.eachSeries(
    //Pass items to iterate over
    ['css/bootstrap.css', 'css/bootstrap-responsive.css'],
    //Pass iterator function that is called for each item
    function(filename, cb) {
      fs.readFile(filename, function(err, content) {
        if (!err) {
          response.write(content);
        }

        //Calling cb makes it go to the next item.
        cb(err);
      });
    },
    //Final callback after each item has been iterated over.
    function(err) {
      response.end()
    }
  );
}

Si vous voulez atteindre cet objectif sans une bibliothèque, ou voulez juste une autre façon, c'est comment je pourrais le faire plus directement. Fondamentalement, vous gardez un count et appel end une fois que les deux lectures de fichier avez terminé.

function css(response) {
  response.writeHead(200, {"Content-Type": "text/css"});

  var count = 0;
  var handler = function(error, content){
    count++;
    if (error){
      console.log(error);
    }
    else{
      response.write(content);
    }

    if (count == 2) {
      response.end();
    }
  }

  fs.readFile('css/bootstrap.css', handler);
  fs.readFile('css/bootstrap-responsive.css', handler);
}

Je vous remercie. C'était une très instructif de réponse!
un endroit que vous appelez la fonction css?
De l'intérieur de la fonction de rappel pour nodejs.org/api/http.html#http_http_createserver_requestlistener ou tout Nœud de l'API serveur de packages.

OriginalL'auteur loganfsmyth

Vous pouvez simplement compter sur html5 Promesse. Le code peut être aussi simple, comme suit:

var promises= ['file1.css', 'file2.css'].map(function(_path){
    return new Promise(function(_path, resolve, reject){
        fs.readFile(_path, 'utf8', function(err, data){
            if(err){
               console.log(err);
               resolve("");    //following the same code flow
            }else{
               resolve(data);
            }
        });
    }.bind(this, _path));
});

Promise.all(promises).then(function(results){
    //Put your callback logic here
    response.writeHead(200, {"Content-Type": "text/css"});
    results.forEach(function(content){response.write(content)});
    response.end();
});

OriginalL'auteur orabis

Il y a une simple solution commune pour tous avec une fonction de rappel.
Vous pouvez le placer n'importe où dans votre projet de réutilisation dans de nombreux cas différents.

var FS = require('fs');

/**
 * Abstract helper to asyncly read a bulk of files
 * Note that `cb` will receive an array of errors for each file as an array of files data
 * Keys in resulting arrays will be the same as in `paths`
 *
 * @param {Array} paths - file paths array
 * @param {Function} cb
 *   @param {Array} errors - a list of file reading error
 *   @param {Array} data - a list of file content data
 */
function FS_readFiles (paths, cb) {
    var result = [], errors = [], l = paths.length;
    paths.forEach(function (path, k) {

        FS.readFile(path, function (err, data) {
            //decrease waiting files
            --l;
            //just skip non-npm packages and decrease valid files count
            err && (errors[k] = err);
            !err && (result[k] = data);
            //invoke cb if all read
            !l && cb (errors.length? errors : undef, result);
        });

    });
}

Vient de mettre à l'intérieur une masse de fichiers et il revient à chacun d'entre vous d'eux comme un tampon.
Exemple Simple:

var cssFiles = [
   'css/bootstrap.css',
   'css/bootstrap-responsive.css'
];

function css(response) {
    FS_readFiles(cssFiles, function (errors, data) {
        response.writeHead(200, {"Content-Type": "text/css"});
        data.forEach(function (v) {
            response.write(v);
        });
        response.end();
    });
}

Offtopic: Btw, les demandes de ce genre vous feriez mieux de cache sur le serveur proxy frontal comme nginx ou de vernis. Il n'est jamais changer.

OriginalL'auteur

-1

Asynchrone est un jeu génial de lib. Toutefois, la norme pour ces choses est en mouvement dans la direction de promesses pour la manipulation de plusieurs opérations asynchrones. En fait, dans ECMAScript6 ce sera une partie standard de la bibliothèque. Il existe plusieurs bibliothèques qui mettent en œuvre des promesses dont JQuery. Cependant, pour le nœud, j'aime utiliser 'q'

Voici le même code à l'aide de promesses: Une note.. vous pouvez déplacer la première writeHead appel à coïncider avec le succès de la première lecture.

var Q = require('q');

function css(response) {
   response.writeHead(200, {"Content-Type": "text/css"});
   var defer = Q.defer(); 
   fs.readFile('css/bootstrap.css', function(error, content){
         if(error){

           defer.reject(error)
        }
        else{
         response.write(content);
         defer.resolve();
       }
   });
   defer.promise.then(function() { //this gets executed when the first read succeeds and is written
         var secondDefer = Q.defer();
         fs.readFile('css/bootstrap-responsive.css', function(error, content){
            if(error){
              secondDefer.reject(error);
           }
           else{
               response.write(content);
               secondDefer.resolve();
           }
        });
        return secondDefer.promise;
   },
   function(error) { //this gets called when the first read fails
       console.log(error);
        //other error handling
   }).
   done(function() {
        response.end();
   }, 
   function(error) { //this is the error handler for the second read fails
        console.log(error);
         response.end(); //gotta call end anyway
   });

}

OriginalL'auteur Cheruvim

Vous devez vous connecter pour publier un commentaire.