busboy vs formidable vs multer vs express-fileupload vs connect-multiparty vs connect-busboy | "Datei-Upload-Handling in Node.js" npm-Pakete Vergleich

Paket	Downloads	Stars	Größe	Issues	Veröffentlichung	Lizenz

busboy	15,532,914	2,903	124 kB	35	-	-
formidable	10,812,491	7,102	203 kB	50	vor 4 Monaten	MIT
multer	6,374,393	11,709	27.6 kB	269	-	MIT
express-fileupload	375,012	1,541	116 kB	23	vor 7 Monaten	MIT
connect-multiparty	78,786	349	-	0	vor 6 Jahren	MIT
connect-busboy	43,751	155	4.57 kB	0	-	-

Paket

Downloads

Stars

Größe

Issues

Veröffentlichung

Lizenz

busboy

15,532,914

2,903

124 kB

formidable

10,812,491

7,102

203 kB

vor 4 Monaten

MIT

multer

6,374,393

11,709

27.6 kB

269

MIT

express-fileupload

375,012

1,541

116 kB

vor 7 Monaten

MIT

connect-multiparty

78,786

349

vor 6 Jahren

MIT

connect-busboy

43,751

155

4.57 kB

Streaming vs. Buffering

busboy:
busboy verarbeitet Datei-Uploads als Streams, was bedeutet, dass es Dateien in kleinen Teilen (Chunks) verarbeitet, während sie hochgeladen werden. Dies führt zu einer geringen Speichernutzung, da die gesamte Datei nicht im Speicher gehalten werden muss.
formidable:
formidable unterstützt sowohl Streaming- als auch Pufferverarbeitungsmodi. Es kann Dateien im Streaming-Modus verarbeiten, um die Speichernutzung zu minimieren, oder im Puffer-Modus, um die gesamte Datei im Speicher zu halten, was je nach Anwendungsfall nützlich sein kann.
multer:
multer puffert die hochgeladenen Dateien, bevor sie gespeichert werden. Es ermöglicht die Speicherung von Dateien im Speicher (RAM) oder im Dateisystem, je nach Konfiguration, was Flexibilität bei der Handhabung von Datei-Uploads bietet.
express-fileupload:
express-fileupload puffert die hochgeladenen Dateien im Speicher, bevor sie verarbeitet werden. Es ermöglicht den Zugriff auf die Dateien über das req.files-Objekt, was die Handhabung von Datei-Uploads einfach und intuitiv macht.
connect-multiparty:
connect-multiparty puffert die hochgeladenen Dateien standardmäßig, bevor sie verarbeitet werden. Dies kann zu höherem Speicherverbrauch führen, insbesondere bei großen Dateien, bietet jedoch eine einfache API für den Zugriff auf die Dateien und Formulardaten.
connect-busboy:
connect-busboy nutzt die Streaming-Architektur von busboy, um Dateien effizient zu verarbeiten. Es bietet eine Middleware-Schicht, die das Streaming von Datei-Uploads in eine Connect- oder Express-Anwendung integriert.

Multiple File Uploads

busboy:
busboy unterstützt mehrere Datei-Uploads, erfordert jedoch eine manuelle Implementierung der Logik zum Verarbeiten mehrerer Dateien. Es bietet Ereignisse, um jede Datei während des Uploads zu behandeln, was Entwicklern die Kontrolle über den Prozess gibt.
formidable:
formidable unterstützt mehrere Datei-Uploads und ermöglicht das gleichzeitige Hochladen von Dateien in verschiedenen Formulardateifeldern. Es bietet eine flexible API zum Zugriff auf alle hochgeladenen Dateien und deren Metadaten.
multer:
multer unterstützt mehrere Datei-Uploads und ermöglicht die Verarbeitung von Dateien in einem einzigen Feld oder in mehreren Feldern. Es bietet eine einfache Möglichkeit, mehrere Dateien gleichzeitig hochzuladen und zu verarbeiten.
express-fileupload:
express-fileupload unterstützt mehrere Datei-Uploads, indem es das multiple-Attribut in HTML-Formularen verwendet. Es ermöglicht den Zugriff auf mehrere Dateien über das req.files-Objekt, was die Handhabung von Mehrfach-Uploads einfach macht.
connect-multiparty:
connect-multiparty unterstützt mehrere Datei-Uploads von Haus aus und bietet eine einfache API zum Zugriff auf alle hochgeladenen Dateien. Es ist besonders nützlich für Formulare, die mehrere Dateien in verschiedenen Feldern hochladen.
connect-busboy:
connect-busboy unterstützt mehrere Datei-Uploads, indem es die Funktionen von busboy nutzt. Es ermöglicht die Verarbeitung mehrerer Dateien innerhalb einer Middleware, was die Handhabung von Mehrfach-Uploads in Express-Anwendungen erleichtert.

Datei-Speicheroptionen

busboy:
busboy bietet keine integrierten Speicheroptionen, da es sich auf das Streaming von Datei-Uploads konzentriert. Entwickler müssen ihre eigene Logik implementieren, um die Dateien zu speichern, während sie verarbeitet werden.
formidable:
formidable ermöglicht es Entwicklern, den Speicherort der hochgeladenen Dateien zu konfigurieren. Es speichert die Dateien standardmäßig im temporären Verzeichnis, bietet jedoch die Flexibilität, den Speicherort während des Upload-Prozesses zu ändern.
multer:
multer bietet flexible Speicheroptionen, einschließlich der Möglichkeit, Dateien im Speicher (RAM) oder im Dateisystem zu speichern. Es ermöglicht Entwicklern, benutzerdefinierte Speicher-Engines zu implementieren, um die Datei-Speicherung nach ihren Bedürfnissen zu gestalten.
express-fileupload:
express-fileupload speichert die hochgeladenen Dateien im temporären Speicher des Servers, bevor sie verarbeitet werden. Es ermöglicht Entwicklern, den Speicherort der Dateien zu konfigurieren, bietet jedoch keine integrierte Unterstützung für das Speichern von Dateien an einem bestimmten Ort.
connect-multiparty:
connect-multiparty speichert die hochgeladenen Dateien temporär auf dem Server, bietet jedoch keine Konfigurierbarkeit für den Speicherort. Die Dateien werden im temporären Verzeichnis des Servers gespeichert, bis sie verarbeitet werden.
connect-busboy:
connect-busboy bietet keine integrierten Speicheroptionen, da es die Speicherlogik von busboy nicht verändert. Entwickler müssen die Datei-Speicherung selbst implementieren, während sie die Middleware verwenden.

Einfache Integration in Express

busboy:
busboy ist eine leichtgewichtige Bibliothek, die keine spezielle Integration in Express erfordert. Entwickler müssen die Middleware manuell einrichten und die Datei-Upload-Logik implementieren.
formidable:
formidable kann in Express-Anwendungen integriert werden, erfordert jedoch etwas mehr Konfiguration als andere Middleware. Entwickler müssen die Middleware manuell einrichten und die Datei-Upload-Logik implementieren.
multer:
multer ist eine beliebte Middleware für Express, die eine einfache Integration bietet. Sie ist einfach zu konfigurieren und wird häufig in Express-Anwendungen für Datei-Uploads verwendet.
express-fileupload:
express-fileupload ist eine benutzerfreundliche Middleware für Express, die eine einfache Integration ermöglicht. Sie erfordert nur wenige Zeilen Code, um Datei-Uploads in einer Express-Anwendung zu aktivieren.
connect-multiparty:
connect-multiparty ist eine vollständige Middleware-Lösung für Express, die eine einfache Integration bietet. Es erfordert minimale Konfiguration und ist sofort einsatzbereit für die Verarbeitung von Multipart-Formulardaten.
connect-busboy:
connect-busboy ist speziell für die Integration in Connect- und Express-Anwendungen entwickelt. Es bietet eine einfache Middleware-Schnittstelle, die die Verwendung von busboy in Express-Anwendungen erleichtert.

Beispielcode für Datei-Uploads

busboy:

busboy Beispielcode

const Busboy = require('busboy');
const express = require('express');
const fs = require('fs');
const path = require('path');

const app = express();

app.post('/upload', (req, res) => {
  const busboy = new Busboy({ headers: req.headers });
  busboy.on('file', (fieldname, file, filename, encoding, mimetype) => {
    const filePath = path.join(__dirname, 'uploads', filename);
    const writeStream = fs.createWriteStream(filePath);
    file.pipe(writeStream);
    writeStream.on('finish', () => {
      console.log(`Datei hochgeladen: ${filename}`);
    });
  });
  busboy.on('finish', () => {
    res.send('Datei erfolgreich hochgeladen!');
  });
  req.pipe(busboy);
});

app.listen(3000, () => {
  console.log('Server läuft auf http://localhost:3000');
});

formidable:

formidable Beispielcode

const express = require('express');
const formidable = require('formidable');
const fs = require('fs');
const path = require('path');

const app = express();

app.post('/upload', (req, res) => {
  const form = new formidable.IncomingForm();
  form.uploadDir = path.join(__dirname, 'uploads');
  form.keepExtensions = true;

  form.on('file', (field, file) => {
    const newPath = path.join(form.uploadDir, file.name);
    fs.renameSync(file.path, newPath);
    console.log(`Datei hochgeladen: ${file.name}`);
  });

  form.on('end', () => {
    res.send('Datei erfolgreich hochgeladen!');
  });

  form.parse(req);
});

app.listen(3000, () => {
  console.log('Server läuft auf http://localhost:3000');
});

multer:

multer Beispielcode

const express = require('express');
const multer = require('multer');
const fs = require('fs');
const path = require('path');

const app = express();
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.array('files', 10), (req, res) => {
  req.files.forEach(file => {
    console.log(`Datei hochgeladen: ${file.originalname}`);
  });
  res.send('Datei(en) erfolgreich hochgeladen!');
});

app.listen(3000, () => {
  console.log('Server läuft auf http://localhost:3000');
});

express-fileupload:

express-fileupload Beispielcode

const express = require('express');
const fileUpload = require('express-fileupload');
const fs = require('fs');
const path = require('path');

const app = express();
app.use(fileUpload());

app.post('/upload', (req, res) => {
  const { files } = req;
  Object.keys(files).forEach(field => {
    const file = files[field];
    const uploadPath = path.join(__dirname, 'uploads', file.name);
    file.mv(uploadPath, err => {
      if (err) return res.status(500).send(err);
      console.log(`Datei hochgeladen: ${file.name}`);
    });
  });
  res.send('Datei(en) erfolgreich hochgeladen!');
});

app.listen(3000, () => {
  console.log('Server läuft auf http://localhost:3000');
});

connect-multiparty:

connect-multiparty Beispielcode

const express = require('express');
const multiparty = require('connect-multiparty');
const fs = require('fs');
const path = require('path');

const app = express();
const multipartyMiddleware = multiparty();

app.post('/upload', multipartyMiddleware, (req, res) => {
  const { files } = req;
  Object.keys(files).forEach(field => {
    const file = files[field];
    const filePath = path.join(__dirname, 'uploads', file.originalFilename);
    fs.renameSync(file.path, filePath);
    console.log(`Datei hochgeladen: ${file.originalFilename}`);
  });
  res.send('Datei(en) erfolgreich hochgeladen!');
});

app.listen(3000, () => {
  console.log('Server läuft auf http://localhost:3000');
});

connect-busboy:

connect-busboy Beispielcode

const express = require('express');
const connectBusboy = require('connect-busboy');
const fs = require('fs');
const path = require('path');

const app = express();
app.use(connectBusboy());

app.post('/upload', (req, res) => {
  req.busboy.on('file', (fieldname, file, filename) => {
    const filePath = path.join(__dirname, 'uploads', filename);
    const writeStream = fs.createWriteStream(filePath);
    file.pipe(writeStream);
    writeStream.on('finish', () => {
      console.log(`Datei hochgeladen: ${filename}`);
    });
  });
  req.busboy.on('finish', () => {
    res.send('Datei erfolgreich hochgeladen!');
  });
});

app.listen(3000, () => {
  console.log('Server läuft auf http://localhost:3000');
});