Manipulating files and directories are basic operations for any program. Since Node.js is a server side platform and can interact with the computer that it’s running on directly, being able to manipulate files is a basic feature. Fortunately, Node.js has a fs module built into its library. It has many functions that can help with manipulating files and folders. File and directory operation that are supported include basic ones like manipulating and opening files in directories. Likewise, it can do the same for files. It can do this both synchronously and asynchronously. It has an asynchronous API that have functions that support promises. Also it can show statistics for a file. Almost all the file operations that we can think of can be done with the built in fs module. In this article, we will rename items stored on disk with the rename family of functions and remove directories with the rmdir family of functions.
Renaming Items with fs.rename and fs.renameSync
To rename items stored on disk in a Node.js program, we can call the rename function asynchronously. It takes 3 arguments. The first argument is the old path of the file. which can be a string, a Buffer object, or an URL object.
The second argument is the new path of the file, which also can be a string, a Buffer object, or an URL object.
The last argument is a callback function that’s called when the item rename operation ends. The callback function takes an err parameter which has the error data if the rename operation ends with an error, otherwise, the err object is null .
The original file must exist before renaming it. If the path of the item you want to rename to already exists, then that item will be overwritten. If the destination path is a directory, then an error will be raised.
For example, we can use it like in the following code:
const fs = require("fs");
const sourceFile = "./files/originalFile.txt";
const destFile = "./files/renamedFile.txt";
fs.rename(sourceFile, destFile, err => {
if (err) throw err;
console.log("Rename complete!");
});
We can do the same for directories:
const fs = require("fs");
const oldDirectory = "./files/oldFolder";
const newDirectory = "./files/newFolder";
fs.rename(oldDirectory, newDirectory, err => {
if (err) throw err;
console.log("Directory rename complete!");
});
The synchronous version of the rename function is the renameSync function. It takes the same arguments as the rename but without the callback. The first argument is the old path of the file. which can be a string, a Buffer object, or an URL object. The second argument is the new path of the file, which also can be a string, a Buffer object, or an URL object. It returns undefined .
For example, we can rename a file with the renameSync function like in the following code:
const fs = require("fs");
const sourceFile = "./files/originalFile.txt";
const destFile = "./files/renamedFile.txt";
try {
fs.renameSync(sourceFile, destFile);
console.log("Rename complete!");
} catch (error) {
console.log(error);
}
There’s also a promise version of the rename function, which also does the rename operation asynchronously. It takes 2 arguments.
The first argument is the old path of the file. which can be a string, a Buffer object, or an URL object.
The second argument is the new path of the file, which also can be a string, a Buffer object, or an URL object. The promise version of the rename function returns a promise that resolves without argument with the rename operation is successful. For example, we can use it like in the following code:
const fsPromises = require("fs").promises;
const sourceFile = "./files/originalFile.txt";
const destFile = "./files/renamedFile.txt";
(async () => {
try {
await fsPromises.rename(sourceFile, destFile);
console.log("Rename complete!");
} catch (error) {
console.log(error);
}
})();
This is a better choice than renameSync for running sequential operations because asynchronous operations like promises won’t holding the program’s execution when it’s running, which means that other parts of the program can run if the operation isn’t finished.
Removing Directories with fs.rmdir and fs.rmdirSync
To remove directories asynchronously we can use the rmdir function. It takes 3 arguments.
The first is the path of the directory, which can be a string, a Buffer object or an URL object.
The second argument is an object that takes a few option properties. The emFileWait property is an integer that let our program retry if an EMFILE error is encountered.
It is the maximum number of milliseconds that we wait to try deleting the directory again. The rmdir function will retry every 1ms until the emFileWait value is reached.
Default value is 1000. The maxBusyTries is an integer is the number of retries when the EBUSY , ENOTEMPTY or EPERM error is encountered. It will retry every 100 milliseconds up to the maxBusyTries value. The recursive property is a boolean property.
If it’s set to true , then it will recursively delete data inside the directory along with the directory itself. In recursive mode, errors aren’t reported if path doesn’t exist and operations are retried on failure. The default value is false .
Recursive mode is an experimental feature. The last argument is a callback function which has an err parameter. It’s called when the removal operation ends. It’s null if the directory removal operation succeeds.
Otherwise, it returns an object with the error information. Using the regular asynchronous version of the rmdir function with files results in the promise being rejected with the ENOENT error on Windows and an ENOTDIR error on POSIX operating systems.
For example, we can use it like in the following code:
const fs = require("fs");
const dirToDelete = "./files/deleteFolder";
fs.rmdir(
dirToDelete,
{
emfileWait: 2000,
maxBusyTries: 5,
recursive: false
},
err => {
if (err) {
throw err;
}
console.log("Removal complete!");
}
);
The directory with the given path should be gone when the code above is ran if it exists and it’s not being used by other programs.
The synchronous version of the rmdir function is the rmdirSync function. It takes similar arguments as the rmdir function. The first argument is the path to the directory, which can be a string, a Buffer object or an URL object.
The second argument is an object that takes one option property. The recursive property is a boolean property. If it’s set to true , then it will recursively delete data inside the directory along with the directory itself. In recursive mode, errors aren’t reported if path doesn’t exist and operations are retried on failure. The default value is false .
Recursive mode is an experimental feature. It returns undefined .
We can use the rmdirSync function like in the following code:
const fs = require("fs");
const dirToDelete = "./files/deleteFolder";
fs.rmdirSync(dirToDelete, {
recursive: false
});
console.log("Removal complete!");
The directory with the given path should be gone when the code above is ran if it exists and it’s not being used by other programs.
The promise version of the rmdir function does the same thing as the regular rmdir function. It takes 2 arguments. The first is the path of the directory, which can be a string, a Buffer object or an URL object. The second argument is the an object that takes a few option properties.
The emFileWait property is an integer that let our program retry if an EMFILE error is encountered. It is the maximum number of milliseconds that we wait to try deleting the directory again. The rmdir function will retry every 1ms until the emFileWait value is reached. Default value is 1000.
The maxBusyTries is an integer is the number of retries when the EBUSY , ENOTEMPTY or EPERM error is encountered. It will retry every 100 milliseconds up to the maxBusyTries value.
The recursive property is a boolean property. If it’s set to true , then it will recursively delete data inside the directory along with the directory itself. In recursive mode, errors aren’t reported if path doesn’t exist and operations are retried on failure. The default value is false .
Recursive mode is an experimental feature. It returns a promise which resolves with no argument when the directory removal operation succeeds. Using the promise version of the rmdir function with files results in the promise being rejected with the ENOENT error on Windows and an ENOTDIR error on POSIX operating systems.
We can use it like in the following code:
const fsPromises = require("fs").promises;
const dirToDelete = "./files/deleteFolder";
(async () => {
try {
await fsPromises.rmdir(dirToDelete, {
emfileWait: 2000,
maxBusyTries: 5,
recursive: false
});
console.log("Removal complete!");
} catch (error) {
console.error(error);
}
})();
The directory with the given path should be gone when the code above is run if it exists and it’s not being used by other programs. We used the try...catch block to catch errors with the async and await syntax with the promise version of the rmdir .
This is a better choice than rmdirSync for running sequential operations because asynchronous operations like promises won’t hold up the program’s execution when it’s running, which means that other parts of the program can run if the operation isn’t finished.
We renamed items stored on disk with the rename family of functions and remove directories with the rmdir family of functions.
With the rename family of functions, we just pass in the original path and the path that we want to rename to and then anything that’s passed in will be renamed if it’s valid.
The rmdir family let us remove directories by specifying the path. The asynchronous versions of the rmdir functions, which include the regular and the promise version let us specify how it will retry when an error occurs. This is very handy for handling errors gracefully.
