node.js异步函数是否在循环？

Question

I am having some problems with node.js. What I'm trying to do is get an array of the directories in "./"+req.user.email and loop through them finding out their size and adding a table row to output, as you can see in the code. At the end I wan't to send all the table rows using res.send().

However the only output I am getting is:

<tr></tr>

for each file in the array. It seems that the forEach function is not waiting for readSizeRecursive at all. The readSizeRecursive function is asynchronous, and I believe that is what's causing the problem, but I don't know how I can fix this.

Any help would be greatly appreciated, I have included the readSizeRecursive function too. Thank you!

  var output = "";
  fs.readdir("./" + req.user.email, function (err, files) {
    files.forEach(function(file){
      output += "<tr>";
      readSizeRecursive("./"+req.user.email+"/"+file, function (err, total){
        output += '<td>' + file + '</td><td>' + total + '</td>';
      });
      output += "</tr>"
    });
    res.send(output)
  });

readSizeRecursive() :

// Function to find the size of a directory
function readSizeRecursive(item, cb) {
  fs.lstat(item, function(err, stats) {
    var total = stats.size;

    if (!err && stats.isDirectory()) {
      fs.readdir(item, function(err, list) {
        async.forEach(
          list,
          function(diritem, callback) {
            readSizeRecursive(path.join(item, diritem), function(err, size) {
              total += size;
              callback(err);
            }); 
          },  
          function(err) {
            cb(err, total);
          }   
        );  
      }); 
    }   
    else {
      cb(err, total);
    }   
  }); 
}

Answer 1

Please use the async module for this kind of pattern. Using async.each will allow you to compute the size for each folder asynchronously, and then return the sizes once you're done computing everything individually.

var output = [];

fs.readdir('./' + req.user.email, function (err, files) {
  async.each(compute, report);
});

function compute (file, done) {
  // calculate size, then callback to signal completion
  // produce a result like below, then invoke done()
  var obj = { files: [
    { name: file, size: size },
    { name: file, size: size },
    { name: file, size: size }
  ]};
  output.push(obj);
  done();
}

// doesn't need to be this awful
function format (list) {
  var result = [];

  list.forEach(function (item) {
    var description = item.files.map(function (file) {
      return util.format('<td>%s</td><td>%s</td>', file.name, file.size);
    });
    result.push(description);
  });

  result.unshift('<tr>');
  result.push('</tr>');
  return result.join('</tr><tr>');
}

function report (err) {
  if (err) { return next(err); }

  var result = format(output);
  res.send(result);
}

This way you can easily swap out the different pieces of functionality, changing the formatting without altering the computing of the file size tree, for example.

Your main issue was control flow. You return with res.send while you are asynchronously looping and figuring out the sizes.

Answer 2

var fs = require ("fs");

var createTableContent = function (p, cb){
    var read = function (p, cb){
        //Prevent recursion if error
        if (err) return cb ();

        fs.stat (p, function (error, stats){
            if (error){
                err = error;
                return cb ();
            }

            if (stats.isDirectory ()){
                var dirSize = 0;

                fs.readdir (p, function (error, entries){
                    if (error){
                        err = error;
                        return cb ();
                    }

                    var pending = entries.length;
                    //Empty dir
                    if (!pending) return cb (0);

                    entries.forEach (function (entry){
                        read (p + "/" + entry, function (entrySize){
                            dirSize += entrySize;
                            if (!--pending) return cb (dirSize);
                        });
                    });
                });
            }else{
                cb (stats.size);
            }
        });
    };

    //A lot of errors can be produced, return only the first one
    var err = null;

    //Suppose p is a dir
    fs.readdir (p, function (error, entries){
        if (error) return cb (error);

        var content = "";
        var pending = entries.length;
        if (!pending) return cb (null, content);

        entries.forEach (function (entry){
            read (p + "/" + entry, function (totalSize){
                if (err) return cb (err);
                content += "<tr><td>" + entry + "</td><td>" + totalSize + "</td></tr>";
                if (!--pending){
                    //End
                    cb (null, content);
                }
            });
        });
    });
};

//Here goes the "email" path
createTableContent (".", function (error, content){
    if (error) return console.error (error);

    console.log (content);
});