How do I delete a file with node.js?
http://nodejs.org/api/fs.html#fs_fs_rename_oldpath_newpath_callback
I don't see a remove command?
This question is related to
node.js
Here the code where you can delete file/image from folder.
var fs = require('fs');
Gallery.findById({ _id: req.params.id},function(err,data){
if (err) throw err;
fs.unlink('public/gallery/'+data.image_name);
});
Here below my code which works fine.
const fs = require('fs');
fs.unlink(__dirname+ '/test.txt', function (err) {
if (err) {
console.error(err);
}
console.log('File has been Deleted');
});
fs.unlinkSync()
if you want to remove files synchronously andfs.unlink()
if you want to remove it asynchronously.Here you can find a good article.
fs-extra
provides a remove method:
const fs = require('fs-extra')
fs.remove('/tmp/myfile')
.then(() => {
console.log('success!')
})
.catch(err => {
console.error(err)
})
https://github.com/jprichardson/node-fs-extra/blob/master/docs/remove.md
It's very easy with fs.
var fs = require('fs');
try{
var sourceUrls = "/sampleFolder/sampleFile.txt";
fs.unlinkSync(sourceUrls);
}catch(err){
console.log(err);
}
I don't think you have to check if file exists or not, fs.unlink
will check it for you.
fs.unlink('fileToBeRemoved', function(err) {
if(err && err.code == 'ENOENT') {
// file doens't exist
console.info("File doesn't exist, won't remove it.");
} else if (err) {
// other errors, e.g. maybe we don't have enough permission
console.error("Error occurred while trying to remove file");
} else {
console.info(`removed`);
}
});
you can use del module to remove one or more files in the current directory. what's nice about it is that protects you against deleting the current working directory and above.
const del = require('del');
del(['<your pathere here>/*']).then( (paths: any) => {
console.log('Deleted files and folders:\n', paths.join('\n'));
});
2020 Answer
With the release of node v14.14.0
you can now do.
fs.rmSync("path/to/file", {
force: true,
});
Use NPM module fs-extra, which gives you everything in fs, plus everything is Promisified. As a bonus, there's a fs.remove() method available.
Remove files from the directory that matched regexp for filename. Used only fs.unlink - to remove file, fs.readdir - to get all files from a directory
var fs = require('fs');
const path = '/path_to_files/filename.anyextension';
const removeFile = (fileName) => {
fs.unlink(`${path}${fileName}`, function(error) {
if (error) {
throw error;
}
console.log('Deleted filename', fileName);
})
}
const reg = /^[a-zA-Z]+_[0-9]+(\s[2-4])+\./
fs.readdir(path, function(err, items) {
for (var i=0; i<items.length; i++) {
console.log(items[i], ' ', reg.test(items[i]))
if (reg.test(items[i])) {
console.log(items[i])
removeFile(items[i])
}
}
});
If you want to check file before delete whether it exist or not. So, use fs.stat or fs.statSync (Synchronous) instead of fs.exists
. Because according to the latest node.js documentation, fs.exists
now deprecated.
For example:-
fs.stat('./server/upload/my.csv', function (err, stats) {
console.log(stats);//here we got all information of file in stats variable
if (err) {
return console.error(err);
}
fs.unlink('./server/upload/my.csv',function(err){
if(err) return console.log(err);
console.log('file deleted successfully');
});
});
You can call fs.unlink(path, callback)
for Asynchronous unlink(2) or fs.unlinkSync(path)
for Synchronous unlink(2).
Where path
is file-path which you want to remove.
For example we want to remove discovery.docx
file from c:/book
directory. So my file-path is c:/book/discovery.docx
. So code for removing that file will be,
var fs = require('fs');
var filePath = 'c:/book/discovery.docx';
fs.unlinkSync(filePath);
You may use fs.unlink(path, callback) function. Here is an example of the function wrapper with "error-back" pattern:
// Dependencies._x000D_
const fs = require('fs');_x000D_
_x000D_
// Delete a file._x000D_
const deleteFile = (filePath, callback) => {_x000D_
// Unlink the file._x000D_
fs.unlink(filePath, (error) => {_x000D_
if (!error) {_x000D_
callback(false);_x000D_
} else {_x000D_
callback('Error deleting the file');_x000D_
}_x000D_
})_x000D_
};
_x000D_
Simple and sync
if (fs.existsSync(pathToFile)) {
fs.unlinkSync(pathToFile)
}
As the accepted answer, use fs.unlink
to delete files.
But according to Node.js documentation
Using
fs.stat()
to check for the existence of a file before callingfs.open()
,fs.readFile()
orfs.writeFile()
is not recommended. Instead, user code should open/read/write the file directly and handle the error raised if the file is not available.To check if a file exists without manipulating it afterwards,
fs.access()
is recommended.
to check files can be deleted or not, Use fs.access
instead
fs.access('/etc/passwd', fs.constants.R_OK | fs.constants.W_OK, (err) => {
console.log(err ? 'no access!' : 'can read/write');
});
2019 and Node 10+ is here. Below the version using sweet async/await way.
Now no need to wrap fs.unlink
into Promises nor to use additional packages (like fs-extra
) anymore.
Just use native fs Promises API.
const fs = require('fs').promises;
(async () => {
try {
await fs.unlink('~/any/file');
} catch (e) {
// file doesn't exist, no permissions, etc..
// full list of possible errors is here
// http://man7.org/linux/man-pages/man2/unlink.2.html#ERRORS
console.log(e);
}
})();
Here is fsPromises.unlink
spec from Node docs.
Also please note that fs.promises API marked as experimental in Node 10.x.x (but works totally fine, though), and no longer experimental since 11.14.0
.
rm -rf
itrequire("fs").rmSync(file_or_directory_path_existing_or_not, {recursive: true, force: true});
// Added in Node.js 14.14.0.
with require("fs").rmSync
or require("fs").rm
.
Here is a small snippet of I made for this purpose,
var fs = require('fs');
var gutil = require('gulp-util');
fs.exists('./www/index.html', function(exists) {
if(exists) {
//Show in green
console.log(gutil.colors.green('File exists. Deleting now ...'));
fs.unlink('./www/index.html');
} else {
//Show in red
console.log(gutil.colors.red('File not found, so not deleting.'));
}
});
Source: Stackoverflow.com