Node.js kullanarak tüm dizini ZIP haline getirmeniz gerekiyor

Node.js kullanarak tüm dizini sıkıştırmam gerekiyor. Şu anda node-zip kullanıyorum ve işlem her çalıştığında geçersiz bir ZIP dosyası oluşturuyor ( bu Github sorunundan da görebileceğiniz gibi ).

Bir dizini ZIP açmama izin verecek başka, daha iyi bir Node.js seçeneği var mı?

DÜZENLEME: Arşivleyiciyi kullanmayı bıraktım

writeZip = function(dir,name) {
var zip = new JSZip(),
    code = zip.folder(dir),
    output = zip.generate(),
    filename = ['jsd-',name,'.zip'].join('');

fs.writeFileSync(baseDir + filename, output);
console.log('creating ' + filename);
};

parametreler için örnek değer:

dir = /tmp/jsd-<randomstring>/
name = <randomstring>

GÜNCELLEME: Kullandığım uygulama hakkında soru soranlar için, indiricime bir bağlantı :

Archiver lib'yi kullanmaya başladım . Harika çalışıyor.

Misal

var file_system = require('fs');
var archiver = require('archiver');

var output = file_system.createWriteStream('target.zip');
var archive = archiver('zip');

output.on('close', function () {
    console.log(archive.pointer() + ' total bytes');
    console.log('archiver has been finalized and the output file descriptor has closed.');
});

archive.on('error', function(err){
    throw err;
});

archive.pipe(output);

// append files from a sub-directory, putting its contents at the root of archive
archive.directory(source_dir, false);

// append files from a sub-directory and naming it `new-subdir` within the archive
archive.directory('subdir/', 'new-subdir');

archive.finalize();

Yeni bir şey gösteriyormuş gibi yapmıyorum, sadece kodlarında Promise işlevlerini kullanmaktan hoşlananlar için (benim gibi) çözümleri yukarıda özetlemek istiyorum.

const archiver = require('archiver');

/**
 * @param {String} source
 * @param {String} out
 * @returns {Promise}
 */
function zipDirectory(source, out) {
  const archive = archiver('zip', { zlib: { level: 9 }});
  const stream = fs.createWriteStream(out);

  return new Promise((resolve, reject) => {
    archive
      .directory(source, false)
      .on('error', err => reject(err))
      .pipe(stream)
    ;

    stream.on('close', () => resolve());
    archive.finalize();
  });
}

Umarım birine yardımcı olur;)

child_processBunu gerçekleştirmek için Düğümün yerel API'sini kullanın.

Üçüncü şahıs kitaplarına gerek yok. İki satır kod.

const child_process = require("child_process");
child_process.execSync(`zip -r DESIRED_NAME_OF_ZIP_FILE_HERE *`, {
  cwd: PATH_TO_FOLDER_YOU_WANT_ZIPPED_HERE
});

Eşzamanlı API kullanıyorum. child_process.exec(path, options, callback)Eşzamansız ihtiyacınız varsa kullanabilirsiniz . İsteklerinizi daha iyi ayarlamak için CWD'yi belirtmekten çok daha fazla seçenek vardır. Exec / execSync belgelerine bakın .

Lütfen dikkat: Bu örnek, sisteminizde zip yardımcı programının kurulu olduğunu varsayar (en azından OSX ile birlikte gelir). Bazı işletim sistemlerinde yardımcı program kurulu olmayabilir (yani, AWS Lambda çalışma zamanı yoktur). Bu durumda, zip yardımcı programı ikili dosyasını buradan kolayca edinebilir ve uygulama kaynak kodunuzla birlikte paketleyebilirsiniz (AWS Lambda için bunu bir Lambda Katmanında da paketleyebilirsiniz) veya bir üçüncü taraf modülü kullanmanız gerekir (NPM'de bol miktarda var). ZIP yardımcı programı onlarca yıldır denendiği ve test edildiği için eski yaklaşımı tercih ediyorum.

Archive.bulkartık kullanımdan kaldırıldı, bunun için kullanılacak yeni yöntem glob :

var fileName =   'zipOutput.zip'
var fileOutput = fs.createWriteStream(fileName);

fileOutput.on('close', function () {
    console.log(archive.pointer() + ' total bytes');
    console.log('archiver has been finalized and the output file descriptor has closed.');
});

archive.pipe(fileOutput);
archive.glob("../dist/**/*"); //some glob pattern here
archive.glob("../dist/.htaccess"); //another glob pattern
// add as many as you like
archive.on('error', function(err){
    throw err;
});
archive.finalize();

Tüm dosya ve dizinleri dahil etmek için:

archive.bulk([
  {
    expand: true,
    cwd: "temp/freewheel-bvi-120",
    src: ["**/*"],
    dot: true
  }
]);

Altında node-glob ( https://github.com/isaacs/node-glob ) kullanır , böylece onunla uyumlu herhangi bir eşleşen ifade çalışacaktır.

Bu, klasörü tek satırda sıkıştıran başka bir kitaplıktır: zip-local

var zipper = require('zip-local');

zipper.sync.zip("./hello/world/").compress().save("pack.zip");

Sonucu yanıt nesnesine yönlendirmek için (yerel olarak depolamak yerine zip dosyasını indirmenin gerekli olduğu senaryolar)

 archive.pipe(res);

Sam'in dizinin içeriğine erişme ipuçları benim için çalıştı.

src: ["**/*"]

Adm-zip, mevcut bir arşivi https://github.com/cthackers/adm-zip/issues/64 sıkıştırmanın yanı sıra ikili dosyaların sıkıştırılmasında bozulma sorunları yaşıyor .

Ayrıca node-zip https://github.com/daraosn/node-zip/issues/4 ile ilgili sıkıştırma bozulması sorunlarıyla karşılaştım

node-archiver, sıkıştırmak için iyi çalışan tek şeydir, ancak herhangi bir sıkıştırmayı açma işlevi yoktur.

İhtiyacınız olanı içeren bu küçük kütüphaneyi buldum.

npm install zip-a-folder

const zip-a-folder = require('zip-a-folder');
await zip-a-folder.zip('/path/to/the/folder', '/path/to/archive.zip');

https://www.npmjs.com/package/zip-a-folder

Yana archiveruzun süre WebPack yeni sürümü ile uyumlu değildir, ben kullanmanızı öneririz zip-lib .

var zl = require("zip-lib");

zl.archiveFolder("path/to/folder", "path/to/target.zip").then(function () {
    console.log("done");
}, function (err) {
    console.log(err);
});

Basit bir şekilde deneyebilirsiniz:

Kurulum zip-dir:

npm install zip-dir

ve kullan

var zipdir = require('zip-dir');

let foldername =  src_path.split('/').pop() 
    zipdir(<<src_path>>, { saveTo: 'demo.zip' }, function (err, buffer) {

    });

Projem aracılığıyla yeniden düzenleme çok fazla çaba gerektireceğinden, JSZip'i taklit etmek için arşivleyiciyi paketledim. Archiver'ın en iyi seçenek olmayabileceğini anlıyorum, ama işte burası.

// USAGE:
const zip=JSZipStream.to(myFileLocation)
    .onDone(()=>{})
    .onError(()=>{});

zip.file('something.txt','My content');
zip.folder('myfolder').file('something-inFolder.txt','My content');
zip.finalize();

// NodeJS file content:
    var fs = require('fs');
    var path = require('path');
    var archiver = require('archiver');

  function zipper(archive, settings) {
    return {
        output: null,
        streamToFile(dir) {
            const output = fs.createWriteStream(dir);
            this.output = output;
            archive.pipe(output);

            return this;
        },
        file(location, content) {
            if (settings.location) {
                location = path.join(settings.location, location);
            }
            archive.append(content, { name: location });
            return this;
        },
        folder(location) {
            if (settings.location) {
                location = path.join(settings.location, location);
            }
            return zipper(archive, { location: location });
        },
        finalize() {
            archive.finalize();
            return this;
        },
        onDone(method) {
            this.output.on('close', method);
            return this;
        },
        onError(method) {
            this.output.on('error', method);
            return this;
        }
    };
}

exports.JSzipStream = {
    to(destination) {
        console.log('stream to',destination)
        const archive = archiver('zip', {
            zlib: { level: 9 } // Sets the compression level.
        });
        return zipper(archive, {}).streamToFile(destination);
    }
};