Below you can find several functions that will help you to manage your files in more advanced way:
1. Synchronously create directory even if its parent directories don’t exist : createPathSync(‘a/b/c/d/e’);
2. Synchronously copy file: copyFileSync( source, target );
3. Synchronously copy directory with its content: copyFolderRecursiveSync( source, target );
4. Synchronously delete directory with its content: deleteFolderRecursiveSync(target);
5. Asynchronously zip folder: makeZip(source, target, zipName, callback);
first of all lets define dependencies:
archiver you only need to use zip functionality.
var fs = require('fs');
var path = require('path');
var archiver = require('archiver'); //npm install archiver
1. Synchronously create directory even if its parent directories don’t exist : createPathSync(‘a/b/c/d/e’);
function createPathSync(dirPath, mode, fullPath) { //usage: createPathSync('a/b/c/d', [mode]);
if (typeof fullPath == 'undefined') fullPath = dirPath; //initialization
try {
//try to make dir
fs.mkdirSync(dirPath, mode);
//if succeeded go recursive or finish
if (!fs.existsSync(fullPath)) createPathSync(fullPath, mode, fullPath);
} catch (err) {
createPathSync(path.dirname(dirPath), mode, fullPath);
}
}
2. Synchronously copy file: copyFileSync( source, target );
function copyFileSync(source, target) {
var targetFile = target;
if (fs.existsSync(target)) {
if (fs.lstatSync(target).isDirectory()) {
targetFile = path.join(target, path.basename(source));
}
}
fs.createReadStream(source).pipe(fs.createWriteStream(targetFile));
}
3. Synchronously copy directory with its content: copyFolderRecursiveSync( source, target );
function copyFolderRecursiveSync(source, target) {
var files = [];
if (!fs.existsSync(target)) { //assure that target path exists
createPathSync(target);
}
if (fs.lstatSync(source).isDirectory()) {
files = fs.readdirSync(source);
files.forEach(function (file, index) {
var curSource = path.join(source, file);
var curTarget = path.join(target, file);
if (fs.lstatSync(curSource).isDirectory()) {
copyFolderRecursiveSync(curSource, curTarget);
} else {
//console.log(curSource+' '+ curTarget);
copyFileSync(curSource, curTarget);
}
});
}
}
4. Synchronously delete directory with its content: deleteFolderRecursiveSync(target);
function deleteFolderRecursiveSync(path) {
if (fs.existsSync(path)) {
fs.readdirSync(path).forEach(function (file, index) {
var curPath = path + "/" + file;
if (fs.lstatSync(curPath).isDirectory()) { // recurse
deleteFolderRecursiveSync(curPath);
} else { // delete file
fs.unlinkSync(curPath);
}
});
fs.rmdirSync(path);
}
};
5. Asynchronously zip folder: makeZip(source, target, zipName, callback);
function makeZip(from, to, zipName, callback) {
var zipArchive = archiver('zip');
var zipOutput = fs.createWriteStream(to + '/' + zipName);
zipOutput.on('close', function () {
console.log('zipping done: ', to + '/' + zipName);
callback();
});
zipArchive.pipe(zipOutput);
zipArchive.bulk([{ src: ['**/*'], cwd: from, expand: true }]);
zipArchive.finalize(function (err, bytes) {
if (err) throw err;
console.log('done:', base, bytes);
});
}
