Javascript 为什么即使在Express.js中声明在顶部，节点中的fs也会在末尾运行

在我的routes目录中，我有users.js和index.js。 在我的users.js文件中，我编写了一个函数，使用（'fs'）读取文件夹中的文件。该函数写在顶部，但总是在结尾执行。 有人能帮我吗

var express = require('express');
var router = express.Router();
var ObjectID = require('mongoskin').ObjectId;
var BSON = require('mongoskin').BSONPure;
var Parser = require('node-dbf');
var sambaserver = require('smb2');
var fs = require('fs');
var path = require('path');
var sys = require('sys');
var exec = require('child_process').exec;
var spawn = require('child_process').spawn;
var DBF = require('stream-dbf');






function Queue() {
    this.dataStore = [];
    this.enqueue = enqueue;
    this.dequeue = dequeue;
    this.front = front;
    this.back = back;
    this.toString = toString;
    this.empty = empty;
}

function enqueue(element) {
    this.dataStore.push(element);
}
function dequeue(element) {
    return this.dataStore.shift();
}

function front() {
    return this.dataStore[0];
}

function back() {
    return this.dataStore[this.dataStore.length -1];
}



function toString() {
    var retstr = "";
    for (var i =0;i < this.dataStore.length;i++)
    {
        retstr += this.dataStore[i] + "\n";
    }
    return retstr;
}

function empty() {
    if(this.dataStore.length == 0) {
        return true;
    }
    else {
        return false;
    }
}


var q = new Queue ()








var p = "/home/admin/Documents/Project-name/public/folder/",


  currentFile;
fs.readdir(p, function (err, files) {
    if (err) {
        throw err;
    }
    files.map(function (file) {
        // return path.join(p, file);
        return path.join(p, file);
    }).filter(function (file) {
        return fs.statSync(file).isFile();
    }).forEach(function (file) {
        // console.log(file);
        q.enqueue(file);
        // console.log(file);
    });



for(var i = 0;i <= q.dataStore.length;i++)
{

currentFile = q.front();
var parser = new DBF(currentFile,true);
var stream = parser.stream;
     //The first for statement is labeled "loop1"
   stream.on('readable', function() {
  var record = stream.read();
  // do something with the record
   db1.collection('tempDBVis').insert(record, function(err,result){
        (err === null) ? {msg : delete1()} : {msg : console.log("error")};
        q.dequeue();
    });
}); 
stream.on('end', function() {
  console.log('finished');

});
function delete1() {
        fs.unlink(currentFile, function (err) {
            if (err) throw err;
            console.log('successfully deleted FILE');
        });
    }

}

});
module.exports = router;

var express=require（'express'）；
var router=express.router（）；
var ObjectID=require（'mongoskin'）。ObjectID；
var BSON=require（'mongoskin'）.BSONPure；
var Parser=require（'node-dbf'）；
var sambaserver=require（'smb2'）；
var fs=需要（'fs'）；
var path=require（'path'）；
var sys=需要（'sys'）；
var exec=require（'child_process'）。exec；
var spawn=require（'child_process'）。spawn；
var DBF=require（'stream-DBF'）；
函数队列（）{
this.dataStore=[]；
this.enqueue=enqueue；
this.dequeue=dequeue；
this.front=front；
this.back=back；
this.toString=toString；
this.empty=空；
}
函数排队（元素）{
this.dataStore.push（元素）；
}
函数出列（元素）{
返回此.dataStore.shift（）；
}
函数前（）{
返回此.dataStore[0]；
}
函数back（）{
返回this.dataStore[this.dataStore.length-1]；
}
函数toString（）{
var retstr=“”；
for（var i=0；i对于（var i=0；i，如果您像这样传递回调：

fs.readFile(filename, function (err, data) {
    ...
});

然后，您正在执行
readFile
，它会立即返回，并且您的代码将继续。您作为第二个参数传递给
readFile
的函数在
fs
包完成文件读取后会异步执行，这很可能是在您的其余代码完成之后

异步编程非常棒，但一开始可能会让人困惑

var first = "this line executes first"

fs.readFile("test.json", function (err, data) {
    var third = "this line executes last"
    // The FS package has to read from the filesystem (spinning up the disc,
    // waiting on the operating system etc) and this may take several
    // milliseconds.  Rather than 'blocking' the rest of your code from
    // executing, the fs package IMMEDIATELY RETURNS from the 'readFile'
    // function and promises to call THIS CALLBACK FUNCTION at a later
    // time (when it has finished reading the file)
});

var second = "this line executes second"

这里有一些代码可以帮助您找到正确的方向。它可以进一步细分（可能是
processItem
函数），但希望这是一个开始

var express = require('express');
var router = express.Router();
var fs = require('fs');
var path = require('path');
var sys = require('sys');

var ObjectID = require('mongoskin').ObjectId;
var BSON = require('mongoskin').BSONPure;
var Parser = require('node-dbf');
var sambaserver = require('smb2');
var exec = require('child_process').exec;
var spawn = require('child_process').spawn;
var DBF = require('stream-dbf');






function Queue() {
    this.dataStore = [];
}

Queue.prototype = {
    enqueue: function (element) {
        this.dataStore.push(element);
    },

    dequeue: function (element) {
        var index;

        if (element) {
            index = this.dataStore.indexOf(element);
            if (index > -1) {
                return this.dataStore.splice(this.dataStore.indexOf(element))
            }
        }

        return this.dataStore.shift();
    },

    front: function () {
        return this.dataStore[0];
    },

    back: function () {
        return this.dataStore[this.dataStore.length -1];
    },

    toString: function () {
        return this.dataStore.join('\n');
    },

    empty: function () {
        return this.dataStore.length === 0;
    },

    size: function () {
        return this.dataStore.length;
    }
}











var queue = new Queue ();
var myPath = "/home/kesari-alnoorkhan/Documents/KesariReporting/public/DbfFiles2/";

fs.readdir(path, function (err, files) {
    if (err) throw err;

    files.map(function (file) {
        return path.join(path, file);
    }).filter(function (file) {
        return fs.statSync(file).isFile();
    }).forEach(function (file) {
        queue.enqueue(file);
    });

    // Now that all the files have been read/filtered/enqueued, you can process them
    processRecords();
});


function processRecords () {
    var file;
    var parser;
    var stream;

    for (var i = 0, len = queue.size(); i < len; i++) {
        file = queue.front();
        parser = new DBF(file, true);
        stream = parser.stream;

        attachHandlersToStream(stream, file);
    }
}

function attachHandlersToStream(stream, file) {
    // Readable handler
    stream.on('readable', function () {
        var record = this.read();

        // what is "db1" ??  This is where you do whatever you want with the item
        db1.collection('tempDBVis').insert(record, function (err, result) {
            // this line here looks suspicious - what are you trying to do?
            //(err === null) ? {msg : delete1()} : {msg : console.log("error")};

            // something like this?
            if (err) {
                console.log('Error', err);
            }
            else {
                fs.unlink(file, function (err) {
                    if (err) throw err;

                    console.log('successfully deleted FILE');
                });
            }

            queue.dequeue(file);
        });
    });

    // End handler
    stream.on('end', function () {
        queue.dequeue(file);
        console.log('finished:', file);
    });
}











module.exports = router;

var express=require（'express'）；
var router=express.router（）；
var fs=需要（'fs'）；
var path=require（'path'）；
var sys=需要（'sys'）；
var ObjectID=require（'mongoskin'）。ObjectID；
var BSON=require（'mongoskin'）.BSONPure；
var Parser=require（'node-dbf'）；
var sambaserver=require（'smb2'）；
var exec=require（'child_process'）。exec；
var spawn=require（'child_process'）。spawn；
var DBF=require（'stream-DBF'）；
函数队列（）{
this.dataStore=[]；
}
Queue.prototype={
排队：函数（元素）{
this.dataStore.push（元素）；
},
出列：函数（元素）{
var指数；
if（元素）{
index=this.dataStore.indexOf（元素）；
如果（索引>-1）{
返回this.dataStore.splice（this.dataStore.indexOf（元素））
}
}
返回此.dataStore.shift（）；
},
前面：函数（）{
返回此.dataStore[0]；
},
返回：函数（）{
返回this.dataStore[this.dataStore.length-1]；
},
toString:函数（）{
返回此.dataStore.join（'\n'）；
},
空：函数（）{
返回this.dataStore.length==0；
},
大小：函数（）{
返回this.dataStore.length；
}
}
var queue=新队列（）；
var myPath=“/home/kesari-alnoorkhan/Documents/KesariReporting/public/DbfFiles2/”；
fs.readdir（路径、函数（错误、文件）{
如果（错误）抛出错误；
file.map（函数（文件）{
返回path.join（路径、文件）；
}).filter（函数（文件）{
返回fs.statSync（file.isFile（）；
}).forEach（函数（文件）{
queue.enqueue（文件）；
});
//现在所有文件都已读取/过滤/排队，您可以处理它们了
processRecords（）；
});
函数processRecords（）{
var文件；
var解析器；
var流；
对于（var i=0，len=queue.size（）；i
Node.js是一个异步环境。因此，在顶部写入并不意味着它将首先运行。您可以尝试使用fs.readFileAsync方法而不是fs.readFile，这样做会像您期望的那样。但不要对大文件读取执行此操作，因为这将导致性能问题。
在
for（var i=0；i
for
行中