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 truncate files with the truncate family of functions and remove files and symbolic links with the unlink family of functions.
Truncate Files with the fs.truncate Family of Functions
We can truncate files with the Node.js truncate family of functions. Truncating a file is to shrink the file to a specified size. To truncate a file asynchronously we can use the truncate function. The function takes 3 arguments. The first argument is the path object, which can be a string, a Buffer object or an URL object. When a file descriptor is passed into the first argument instead of the path, it will automatically call ftruncate to truncate the file with the given file descriptor. Passing in a file descriptor is deprecated and may thrown an error in the future. The second argument is the length of the file in bytes that you want to truncate it to. The default value is 0. Any extra data bigger than the size specified is lost when the size is smaller than the original size. The third argument is a callback function that is run when the truncate operation ends. It takes an err parameter which is null when the truncate operation succeeds and has an object with the error information otherwise.
To truncate a file with the truncate function, we can write the following code:
const fs = require("fs");
const truncateFile = "./files/truncateFile.txt";
fs.truncate(truncateFile, 1, err => {
if (err) throw err;
console.log("File truncated");
});
If we run the code above, there should be a single byte of content left in the file you’re truncating.
The synchronous version of the truncate function is the truncateSync function. The function takes 2 arguments. The first argument is the path object, which can be a string, a Buffer object or an URL object. When a file descriptor is passed into the first argument instead of the path, it will automatically call ftruncateSync to truncate the file with the given file descriptor. Passing in a file descriptor is deprecated and may thrown an error in the future .The second argument is the length of the file in bytes that you want to truncate it to. The default value is 0. Any extra data bigger than the size specified is lost when the size is smaller than the original size. It returns undefined .
We can use the truncateSync function like in the following code:
const fs = require("fs");
const truncateFile = "./files/truncateFile.txt";
try {
fs.truncateSync(truncateFile, 1);
console.log("File truncated");
} catch (error) {
console.error(error);
}
If we run the code above, there should be a single byte of content left in the file you’re truncating.
There’s also a promise version of the truncate function. The function takes 2 arguments. The first argument is the path object, which can be a string, a Buffer object or an URL object.The second argument is the length of the file in bytes that you want to truncate it to. The default value is 0. Any extra data bigger than the size specified is lost when the size is smaller than the original size. It returns a promise that is resolved with no arguments when the operation is successful.
To truncate a file with the promise version of the truncate function, we can write the following code:
const fsPromises = require("fs").promises;
const truncateFile = "./files/truncateFile.txt";
(async () => {
try {
await fsPromises.truncate(truncateFile, 1);
console.log("File truncated");
} catch (error) {
console.error(error);
}
})();
If we run the code above, again there should be a single byte of content left in the file you’re truncating.
Remove Files and Symbolic Links with the fs.unlink Family of Functions
We can remove a file or a symbolic link with the unlink function. The function takes 2 arguments. The first argument is the path object, which can be a string, a Buffer object or an URL object.The second argument is a callback function that takes an err object, which is null when the file or symbolic link removal operation succeeds, and has the error data if the operation failed. The unlink function doesn’t work on directories in any state. To remove directories, we should use the rmdir function.
To use the unlink function to remove a file, we can something like the code below:
const fs = require("fs");
const fileToDelete = "./files/deleteFile.txt";
fs.unlink(fileToDelete, err => {
if (err) {
throw err;
}
console.log("Removal complete!");
});
If we run the code above, the file that’s to be deleted should be gone.
The synchronous version of the unlink function is the unlinkSync function. The function takes one argument. The only argument is the path object, which can be a string, a Buffer object or an URL object. It returns undefined .
We can use it like in the following code:
const fs = require("fs");
const fileToDelete = "./files/deleteFile.txt";
try {
fs.unlinkSync(fileToDelete);
console.log("Removal complete!");
} catch (error) {
console.error(error);
}
There’s also a promise version of the unlink function. The function takes one argument. The only argument is the path object, which can be a string, a Buffer object or an URL object. It returns a promise that’s resolved with no argument when the operation is successful.
If we run the code above, the file that’s to be deleted should be gone.
We can use it like in the following code:
const fsPromises = require("fs").promises;
const fileToDelete = "./files/deleteFile.txt";
(async () => {
try {
await fsPromises.unlink(fileToDelete);
console.log("Removal complete!");
} catch (error) {
console.error(error);
}
})();
If we run the code above, the file that’s to be deleted should be gone.
The promise version of the unlink function is a much better choice than the unlinkSync function when you want to do multiple things sequentially that includes a call to the unlink function since it doesn’t tie up the whole program waiting for the file or symbolic link deletion operation to complete before continuing to program other parts of the program.
In this article, we truncate files with the truncate family of functions and remove files and symbolic links with the unlink family of functions. The truncate family of functions let us specify the number of bytes to keep while truncating the rest of the file. The unlink family of functions remove files and symbolic links. If we want to do these operations sequentially with other operations, the promise versions of these functions. Even though the API is still experimental, it is much better than the synchronous versions of these functions since it allows for sequential and asynchronous operations with promises. Also, it helps avoid callback hell where we nest promises in too many levels.
