Javascript Multer使用数据创建新文件夹

我用

问题1 当我将以下代码片段放入

app.js

app.use(multer({
        dest: './uploads'
    }
).single('file'));

它会在根文件夹下创建一个新文件夹，我的问题是关于这个新文件夹的生命周期，何时删除？100次呼叫后，文件夹的大小可以是多少

问题2 如果我不想限制文件大小，我应该在配置中添加什么

app.use(multer({
    dest: './public/profile/img/',
    limits: {
        fieldNameSize: 50,
        files: 1,
        fields: 5,
        fileSize: 1024 * 1024
    },

更新

html
  head
    title
  body
    form(method="post",enctype="multipart/form-data",action="/upload")
      p
        input(type="file",name="file")
      p
        input(type="submit")

我的应用程序是这样构建的

app.js文件包含

    app.use(multer({
            dest: './uploads'
        }
    ).single('file'));

app.use('/', routes, function (req, res, next) {
    next();
});

路由文件如下所示

appRouter
    .post('*', function (req, res) {
        handler.dispatch(req, res)
    })
    .get('*', function (req, res) {
        handler.dispatch(req, res)
    })

update: function (req, res) {
  var filePath = path.join(req.file.destination, req.file.filename);
            var unzipper = new Unzipper(filePath);
            unzipper.on("extract", function () {
                console.log("Finished extracting");
                res.sendStatus(200);
            });
            unzipper.on('progress', function (fileIndex, fileCount) {
                console.log('Extracted file ' + (fileIndex + 1) + ' of ' + fileCount);
            });
            unzipper.on('list', function (files) {
                console.log('The archive contains:');
                console.log(files);
            });

            unzipper.on('error', function (err) {
                console.log('Caught an error', err);
            });

            unzipper.extract({
                path: "./"
            });
        }

在第三个文件中，我使用如下解压

appRouter
    .post('*', function (req, res) {
        handler.dispatch(req, res)
    })
    .get('*', function (req, res) {
        handler.dispatch(req, res)
    })

update: function (req, res) {
  var filePath = path.join(req.file.destination, req.file.filename);
            var unzipper = new Unzipper(filePath);
            unzipper.on("extract", function () {
                console.log("Finished extracting");
                res.sendStatus(200);
            });
            unzipper.on('progress', function (fileIndex, fileCount) {
                console.log('Extracted file ' + (fileIndex + 1) + ' of ' + fileCount);
            });
            unzipper.on('list', function (files) {
                console.log('The archive contains:');
                console.log(files);
            });

            unzipper.on('error', function (err) {
                console.log('Caught an error', err);
            });

            unzipper.extract({
                path: "./"
            });
        }

下面是我的节点应用程序的结构，是否有人可以建议如何以及在何处（哪个文件）建议使用Raf代码向文件添加日期时间，我可以添加排序…

（1）当您拨打以下电话时，您是在告诉multer将上传的文件放入名为

uploads

的目录中。因此，如果应用程序启动时目录尚未出现，它将为您创建该目录

app.use(multer({
        dest: './uploads'
    }
).single('file'));

就该目录的生命周期而言，只要您不删除它，并且仍然要求multer将其用作目标，它就会一直存在。上传的文件被添加到那里，因此其内容的大小取决于上传的内容

（2）对于文件大小的限制，根据文档的默认值为无穷大。所以没有限制，除非你设定一个

但是，由于不了解您的应用程序，我仍然强烈建议设置一个限制，即使您需要相当高的限制。完全取消尺寸限制可能会导致大问题

---

编辑
如果要在上载新文件时删除

/uploads

的内容，则节点提供了一种删除文件的方法：。另见

---

在上载处理程序中，检查

/uploads

的内容，并

取消与当前请求中未使用的文件的链接。查看当前上传的
req.file
。
我将尝试用一个真实的例子来回答您的问题，至少您可以从中学到一些东西。如果您希望删除除最近的上传之外的所有内容，那么您需要编写某种逻辑代码来区分哪些上传是最近的，哪些是旧的。下面我将描述，我将如何着手解决这个问题，可能并不完美，但这就是我如何做到的

除非以手动或编程方式删除文件夹，否则该文件夹永远不会自动删除

包含100个调用的文件夹的大小，假设在每次调用中上载的文件大小为x乘以100

您不想限制文件上载，不提供限制配置，但建议指定文件上载限制

显然，您可以将multer附加到应用程序，或者创建其实例并将其传递到路由。我更喜欢第二种方法：

multer配置

var storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/')
  },
  filename: function (req, file, cb) {
    var filename = file.originalname;
    var fileExtension = filename.split(".")[1];
    cb(null, Date.now() + "." + fileExtension);
  }
}); 

如上所示，我不允许multer为上传的文件提供随机名称。我要做的是，获取文件名，去掉其扩展名，然后使用
Date.now（）
，它将为我提供当前时间戳以及上载的文件扩展名。如果我上传了六次，它们将显示如下（我的大部分上传是.jpg，这是从文件名中获取的）

上传将如何结束（时间戳会有所不同）

我将上述
存储
附加到multer的一个实例，如下所示：

var upload = multer({storage: storage});

现在，我可以将
上传
传递到处理文件上传的路径，如下所示：

var upload = multer({storage: storage});

如下图所示将上传附加到路由

//simple route to return upload form, simple jade file
app.get('/upload', function(req, res){
  res.render('upload');
});

//this route processes the upload request, see below upload.single('file') 
//is the passed multer
app.post('/upload', upload.single('file'),  function(req,res){
  res.status(204).end();
});

假设您一直在上载，然后在某个时候希望列出上载目录中的所有文件。路线如下：

var upload = multer({storage: storage});

列出上载目录中的所有文件

//lists all files in the uploads directory and return it to browser as json response
app.get('/listAllFiles', function(req, res) {
  //reading directory in synchronous way
  var files = fs.readdirSync('./uploads');
  res.json(files);
});

//delete all files in the upload direcotry asynchronously
app.get('/deleteAllFiles', function(req, res) {
  fs.readdir('./uploads', function(err, items) {
    items.forEach(function(file) {
        fs.unlink('./uploads/' + file);
        console.log('Deleted ' + file);
    });
    res.status(204).end();
  });
});

如果要删除上载目录中的所有文件，路由如下所示：

var upload = multer({storage: storage});

删除上载目录中的所有文件

//lists all files in the uploads directory and return it to browser as json response
app.get('/listAllFiles', function(req, res) {
  //reading directory in synchronous way
  var files = fs.readdirSync('./uploads');
  res.json(files);
});

//delete all files in the upload direcotry asynchronously
app.get('/deleteAllFiles', function(req, res) {
  fs.readdir('./uploads', function(err, items) {
    items.forEach(function(file) {
        fs.unlink('./uploads/' + file);
        console.log('Deleted ' + file);
    });
    res.status(204).end();
  });
});

如果希望同步删除所有文件，则必须调用同步版本的readdir（readdirSync）和unlink（unlinkSync）

现在要删除所有文件，但最近上载的文件除外。嗯，我已经把所有的文件名都做成了时间戳。所以我会做如下的事情：

var upload = multer({storage: storage});

删除除最近文件（其中最近文件是以最近时间戳作为其文件名的文件）以外的所有文件

我没有在我的示例中添加任何限制，但建议这样做。默认文件大小限制为无穷大，如果您未将其包括在prod环境中，则您将容易受到DoS攻击，如注释中所示

要使上述文件操作正常工作，您需要加载

var fs = require('fs'); 

关于第二点，只需跳过limits属性，默认限制为无穷大

出于演示目的，我已在一个正常工作的nodejs应用程序中设置了上述内容，请参见以下内容：

app.js

var express = require('express');
var multer = require('multer');
var bodyParser = require('body-parser');
var path = require('path');
var fs = require('fs');

var app = new express();
app.use(bodyParser.json());

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

var storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/')
  },
  filename: function (req, file, cb) {
    /* if you need to retain the original filename, then use filename and append to it date
     * if you don't need original filename but, just extension, then append extension at the
     * end of current timestamp. If you don't need extenion then just use Date.now() which
     */
    var filename = file.originalname;
    var fileExtension = filename.split(".")[1];

    cb(null, Date.now() + "." + fileExtension);
  }
})

var upload = multer({storage: storage});

//get upload form
app.get('/upload', function(req, res){
  res.render('upload');
});

//process upload
app.post('/upload', upload.single('file'),  function(req,res){
  res.status(204).end();
});

//lists all files in the uploads directory.
app.get('/listAllFiles', function(req, res) {
  var files = fs.readdirSync('./uploads');
  res.json(files);
});

//delete all files in the upload direcotry asynchronously
app.get('/deleteAllFiles', function(req, res) {
  fs.readdir('./uploads', function(err, items) {
    items.forEach(function(file) {
        fs.unlink('./uploads/' + file);
        console.log('Deleted ' + file);
    });
    res.status(204).end();
  });
});

//delets all file asynchronously except the most recent in which case the file
//with name being the latest timestamp is skipped.
app.get('/deleteAllExceptMostRecent', function(req, res) {
  console.log('/deleteAllFilesExceptMostRecent');
  fs.readdir('./uploads', function(err, items) {
    items.reverse();
    var flag = true;

    items.forEach(function(file) {
      if(flag) {
        flag = false;
      } else {
        fs.unlink('./uploads/' + file);
        console.log('Deleted ' + file);
      }
    });
  });
  res.status(204).end();
});

//delete all files of a direcotry in synchronous way
app.get('/deleteAllSync', function(req, res) {
  var filenames = fs.readdirSync('./uploads');

  filenames.forEach(function(file) {
    fs.unlinkSync('./uploads/' + file);
  });
});

//delete all files except most recent in synchronous way
app.get('/deleteAllSyncExceptMostRecent', function(req, res) {
  var filenames = fs.readdirSync('./uploads');
  filenames.reverse();
  var flag = true;
  filenames.forEach(function(file) {
    if(flag) 
      flag = false;
    else
      fs.unlinkSync('./uploads/' + file);
  });
});

var port = 3000;
app.listen( port, function(){ console.log('listening on port '+port); } );

查看/上传。jade

html
  head
    title
  body
    form(method="post",enctype="multipart/form-data",action="/upload")
      p
        input(type="file",name="file")
      p
        input(type="submit")

Que 1）您可以决定文件夹的生命周期

若你们想在服务器上存储文件，并在任何时候不受文件大小限制地将其恢复，你们需要更大的存储空间
如果您使用第三方（如Amazon S3进行存储，那么本地存储毫无意义，只要将其上传到服务器，您就可以从本地存储中删除。
您可以在发送响应时使用

app.use(function (req, res, next) {
function afterResponse() {
    res.removeListener('finish', afterRequest);
    res.removeListener('close', afterRequest);

    // Delete files from multer 
    // you can delete older one from upload folder as you see new one came here.
}

res.on('finish', afterResponse);
res.on('close', afterResponse);

// action before request
// eventually calling `next()`
 });


Que 2）默认值是无限的。
您能用更好的方式解释第一个问题吗？我以前使用过Multer。不限制文件大小是个坏主意；你基本上是在请求DoS攻击。谢谢，但是你能建议在保存了几个文件后如何删除这个文件夹吗，也许保留新的请求并删除旧的…或者最好在我对文件大小进行了一些限制后开始这样做…你的意思是你想在c之后删除
/uploads/
中的旧文件吗