Façon la plus simple de télécharger et décompressez les fichiers dans Node.js croix-plate-forme?

C'est 2017 (le 26 octobre, pour être exact).

Pour une ancienne et où la technologie est omniprésente comme décompressez-je en droit d'attendre, il existe une assez populaire, mature node.js décompressez bibliothèque qui est de "stagnation" et "non-maintenu parce qu'il est" complet".

Cependant, la plupart des bibliothèques l'impression d'être complètement terribles ou d'avoir commet récemment que il ya seulement quelques mois. C'est tout à fait relatif... donc je suis passé par plusieurs décompressez les bibliothèques, lire leurs docs, et j'ai essayé de leur des exemples pour essayer de comprendre WTF. Par exemple, j'ai essayé ces:

• thejoshwolfe/yauzl
• antelle/node-stream-zip
• ZJONSSON/node-unzipper
• EvanOxfeld/node-décompressez
• Stuk/jszip
• kriskowal/zip

Première Recommandation: yauzl

Fonctionne très bien pour tout fichier téléchargé. Pas aussi grand pour le streaming.

Bien documenté. Fonctionne bien. Du sens.

2e Choix: node-stream-zip

antelle de node-stream-zip semble être la meilleure

Installer:

npm install --save node-stream-zip

Utilisation:

'use strict';
var StreamZip = require('node-stream-zip');
var zip = new StreamZip({
file: './example.zip'
, storeEntries: true
});
zip.on('error', function (err) { console.error('[ERROR]', err); });
zip.on('ready', function () {
console.log('All entries read: ' + zip.entriesCount);
//console.log(zip.entries());
});
zip.on('entry', function (entry) {
var pathname = path.resolve('./temp', entry.name);
if (/\.\./.test(path.relative('./temp', pathname))) {
console.warn("[zip warn]: ignoring maliciously crafted paths in zip file:", entry.name);
return;
}
if ('/' === entry.name[entry.name.length - 1]) {
console.log('[DIR]', entry.name);
return;
}
console.log('[FILE]', entry.name);
zip.stream(entry.name, function (err, stream) {
if (err) { console.error('Error:', err.toString()); return; }
stream.on('error', function (err) { console.log('[ERROR]', err); return; });
//example: print contents to screen
//stream.pipe(process.stdout);
//example: save contents to file
mkdirp(path.dirname(pathname, function (err) {
stream.pipe(fs.createWriteStream(pathname));
});
});
});

Avertissement De Sécurité:

Ne sais pas si cela vérifie entry.name pour malveillante chemins qui permettrait de résoudre de manière incorrecte (comme ../../../foo ou /etc/passwd).

Vous pouvez facilement vérifier cela par vous-même en comparant /\.\./.test(path.relative('./to/dir', path.resolve('./to/dir', entry.name))).

Pros: (Pourquoi dois-je pense que c'est le meilleur?)

• peut décompresser les fichiers normaux (peut-être pas certains fous avec bizarre extensions)
• pouvez diffuser
• semble de ne pas avoir à charger la totalité du zip pour lire les entrées
• a des exemples en JavaScript normale (non compilé)
• ne comprend pas l'évier de la cuisine (c'est à dire l'url de chargement, S3, ou db couches)
• utilise le code existant à partir d'une bibliothèque populaire
• n'a pas trop absurde hipster ou ninja-foo dans le code

Contre:

• Avale les erreurs comme un hungry hippo
• Jette des chaînes au lieu d'erreurs (pas de traces de pile)
• zip.extract() ne semble pas fonctionner (j'ai donc utilisé zip.stream() dans mon exemple)

Finaliste: nœud-unzipper

Installer:

npm install --save unzipper

Utilisation:

'use strict';
var fs = require('fs');
var unzipper = require('unzipper');
fs.createReadStream('./example.zip')
.pipe(unzipper.Parse())
.on('entry', function (entry) {
var fileName = entry.path;
var type = entry.type; //'Directory' or 'File'
console.log();
if (/\/$/.test(fileName)) {
console.log('[DIR]', fileName, type);
return;
}
console.log('[FILE]', fileName, type);
//TODO: probably also needs the security check
entry.pipe(process.stdout/*fs.createWriteStream('output/path')*/);
//NOTE: To ignore use entry.autodrain() instead of entry.pipe()
});

Pros:

• Semble fonctionner d'une manière similaire à node-stream-zip, mais moins de contrôle
• Plus fonctionnelle et la fourche de unzip
• Semble fonctionner en série plutôt qu'en parallèle

Contre:

• Évier de cuisine beaucoup? Comprend juste une tonne de trucs qui sont pas liés à la décompression
• Lit tout le fichier (par morceau, ce qui est bien), non seulement aléatoire cherche

yauzl est une bibliothèque robuste pour la décompression. Principes de conception:

• Suivre la spécification. Ne pas scanner locales pour les en-têtes de fichier. Lire le répertoire central pour les métadonnées du fichier.
• Ne pas bloquer le JavaScript fil. Utiliser et fournir des Api asynchrones.
• Garder l'utilisation de la mémoire sous contrôle. N'essayez pas de tampon ensemble de fichiers dans la mémoire RAM à la fois.
• Jamais de crash (si utilisé correctement). Ne laissez pas la malformation de fichiers zip ramener client les applications qui tentent d'intercepter les erreurs.
• Attraper dangereux les noms de fichiers d'entrées. Un fichier zip d'entrée déclenche une erreur si son nom de fichier commence par "/" ou " /[A-Za-z]://ou si elle contient des ".." chemin d'accès de segments ou "\" (par la spec).

A actuellement 97% de couverture de test.

J'ai été impatient un long moment, ne trouvant pas de travail simple exemple, mais sur la base de ces réponses, j'ai créé le downloadAndUnzip() fonction.

L'utilisation est assez simple:

downloadAndUnzip('http://your-domain.com/archive.zip', 'yourfile.xml')
.then(function (data) {
console.log(data); //unzipped content of yourfile.xml in root of archive.zip
})
.catch(function (err) {
console.error(err);
});

Et voici la déclaration:

var AdmZip = require('adm-zip');
var request = require('request');
var downloadAndUnzip = function (url, fileName) {
/**
* Download a file
* 
* @param url
*/
var download = function (url) {
return new Promise(function (resolve, reject) {
request({
url: url,
method: 'GET',
encoding: null
}, function (err, response, body) {
if (err) {
return reject(err);
}
resolve(body);
});
});
};
/**
* Unzip a Buffer
* 
* @param buffer
* @returns {Promise}
*/
var unzip = function (buffer) {
return new Promise(function (resolve, reject) {
var resolved = false;
var zip = new AdmZip(buffer);
var zipEntries = zip.getEntries(); //an array of ZipEntry records
zipEntries.forEach(function (zipEntry) {
if (zipEntry.entryName == fileName) {
resolved = true;
resolve(zipEntry.getData().toString('utf8'));
}
});
if (!resolved) {
reject(new Error('No file found in archive: ' + fileName));
}
});
};
return download(url)
.then(unzip);
};

Un autre exemple de travail:

var zlib = require('zlib');
var tar = require('tar');
var ftp = require('ftp');
var files = [];
var conn = new ftp();
conn.on('connect', function(e) 
{
conn.auth(function(e) 
{
if (e)
{
throw e;
}
conn.get('/tz/tzdata-latest.tar.gz', function(e, stream) 
{
stream.on('success', function() 
{
conn.end();
console.log("Processing files ...");
for (var name in files)
{
var file = files[name];
console.log("filename: " + name);
console.log(file);
}
console.log("OK")
});
stream.on('error', function(e) 
{
console.log('ERROR during get(): ' + e);
conn.end();
});
console.log("Reading ...");
stream
.pipe(zlib.createGunzip())
.pipe(tar.Parse())
.on("entry", function (e) 
{    
var filename = e.props["path"];
console.log("filename:" + filename);
if( files[filename] == null )
{
files[filename] = "";
}
e.on("data", function (c) 
{
files[filename] += c.toString();
})    
});
});
});
})
.connect(21, "ftp.iana.org");