HomeBlogWeb DevelopmentWrite to Files in Node.js: How to Guide with Examples
Node. js is a framework for developing efficient and scalable network approaches based on Chrome's JavaScript engine. Due to its lightweight, high effectiveness, and non-blocking I/O mechanisms, Node.JS has become a perfect choice for real-world information applications.
Out of the different stand-out functionalities and offerings, the ability to read and write files is excellent. It is a robust feature offered by NodeJS and extremely simple to implement. A file can be read or written synchronously or asynchronously from your computer. For more information, check out Full Stack learning course.
This guide will introduce you to node.js and its modules covered in the node js program. With the help of an example, we will read, write and append JS files, which will help us understand node.js better. Also, troubleshooting tips and tricks will also be discussed at the end of this tutorial.
The built-in fs module allows node js to write files programmatically. The module's name (fs) is an abbreviation for "file system," and it contains all of the functions required to read, write, and delete files on the local machine. Because of this distinguishing feature of nodejs write JSON to file, JavaScript is a functional language for back-end and CLI tool programming.
We can encode any JavaScript string with the node fs writefile. UTF-8 is a popular encoding for web pages and other documents. The character set used for the file's contents is called file encoding. Encodings that are commonly used include 'utf8', 'ASCII', 'binary', 'hex', 'base64', and 'utf16le'.
Most significantly, the nodejs write to file and read on the local file system is excellent. Leverage these capabilities for logging, exporting and importing data from JSON and XML files, transferring data from one location to another, etc.
‘fs’ Module is inbuilt provided by Node.js to perform different actions. The ‘fs’ Module is a file system module that helps you work with files, like read files, write files, append files, and many more. It operates both, synchronously and asynchronously. Let's look at an example of how to use the fs module.
const fs = require('fs') Instead of var we will use const which is ES6 feature. This will need the built-in module from Node.Js, and it will be ready to use.
Some functionalities of the fs module include
The ‘fs’ module provides both asynchronous and synchronous options.
Are you interested to explore more node.js modules? Check out the java full stack developer course from Knowledgehut and step forward with your learning journey.
There are two methods to read a file in node.js. We will see both of them.
Another perk of using node.js is the option for js write to a json file. Reading a file asynchronously is the simplest way to read the file using fs.readFile() function. It is non-blocking because it doesn’t block the rest of the code while executing.
As you know, basic JavaScript functions and this asynchronous function are features of JavaScript. This readFile() function takes two arguments, one argument will define our file path and the second argument is a callback function.
const fs = require('fs');
fs.readFile('file.txt', (err, data) => {
if(err) {
throw err;
}
console.log(data.toString());
}); Callback Function will be called with two arguments, one is error and another is data; where data is the file content and the err object contains information of runtime errors.
The second way of reading a file is using the synchronous version of fs.readFile() which is known as fs.readFileSync(). It also takes the two arguments, the first one is the path of the file and the other is character encoding. If character encoding is not used then the output will be shown as a buffer.
You can also omit printing buffer in the terminal by specifying the file encoding as the second parameter after the file path:
const fs = require('fs');
try{
const data = fs.readFileSync(file.txt);
console.log(data.toString());
} catch (err) {
console.error(err);
} Before calling the callback function both the functions fs.readFIle() and fs.writeFile() read the full contents of the file in memory. As a result, it may affect memory usage and application execution whenever you read a huge file.
Use the handy writeFile method inside the standard library's fs module to save strenuous efforts and time.
Let’s understand each term in detail:
Like we have two methods for reading to Node.js Files, we also have two methods for writing to Node.Js Files.
1. Writing file Asynchronously
For writing a file asynchronously, we need to use the fs.writeFile() function. It will follow the same process that we followed in the reading file asynchronously. Instead of read we will use fs.writeFile(). It is the easiest way to write data files in Node.Js. This function takes three arguments - the file name, the data to write, and a callback function. The callback() function only accepts one argument for error handling in this case.
const fs = require('fs');
const data = "This is the new content of the file.";
fs.writeFile('file.txt', data, (err) => {
if(err) {
throw err;
console.log("Data has been written to file successfully.");
}); Our file has been successfully created using the text that we specified previously. This is how you can use NodeJS to read and write files asynchronously.
2. Writing file Synchronously
For writing a file synchronously we need to use the function fs.writeFileSync() function. It will follow the same process that we followed in the reading file synchronously. Instead of read, we will use fs.writeFileSync().
const fs = require('fs');
const data = "This is the new content of the file.";
try {
fs.writeFileSync('file.txt', data);
console.log("File has been saved.");
} catch (error) {
console.error(err);
} If the file already exists, these methods override its contents by default. You should give a flag as the third option if you want to append data to the file:
const fs = require('fs');
const data = "Append this data at the end of the file.";
fs.writeFile('file.txt', data, {flag: 'a+'}, (err) => {
if (err) {
throw err;
}
console.log("File is updated.");
}); Some of the flag options are as follows:
| Flags | Description |
| r | Opens file for reading.
|
| r+ | Open file for reading and writing.
|
| rs | This flag opens the file for reading in synchronous mode. |
openw | Open file for writing.
|
| wx | Similar to the ‘w’ flag, but it will fail if the path exists. |
| w+ | Open file for reading and writing.
|
| w++ | It iss similar to ‘w+’ but it will fail if the path exists. |
Both of these approaches continue writing to the file until the full contents have been written. If a lot of data is to be written, it could slow down your application. So in that scenario, using a stream for writing to huge files would be a preferable option.
To append data the fs.appendFile() method is used to a file asynchronously (and fs.appendFileSync() for synchorus). If the file does not exist, it is created. To change the behaviour of the operations the options parameter can be used. To kick-start your career in web design, enroll in Best Courses for Web Design by KnowledgeHut.
Syntax for appending to files is:
fs.appendFile(path, data[,options], callback)
This method accepts four parameters as mentioned above, they are described below:
For every developer error handling is important and very essential. It takes a lot of skill to locate and debug a mistake. While working on the above reading and writing files, we noticed an err argument, but we didn’t address it. Let’s have a look at a quick rundown of how to use it:
While reading or writing a file if there is a runtime error then the callback method is called with an Error object as the first argument. Throwing runtime errors as Node.js exceptions, as we did previously, is the simplest approach to handle them. However, because this can cause the application to crash, it is not recommended unless you have no other choice:
const fs = require('fs');
fs.readFile('404.txt', 'utf-8', (err, data) => {
if (err) {
console.error(err);
// log the error here
}
console.log(data);
}); There are two approaches to take when dealing with operational errors, such as specifying an inaccessible path. One option is to pass the error to a callback function. You then include some error-handling logic in the callback, such as logging it. You can also include try/catch blocks around the code that calls the section of the program where errors can occur.
Looking to master Python? Dive into our comprehensive Python full course! Unlock the power of this versatile language and unleash your coding potential. Start your journey today!
Like reading files, Node.js has the capability to write files in a precise and sophisticated manner. Reading, writing, and appending files in Node.js are a few of the basic activities that developers must understand when working with Node.JS.
We have discussed everything about how to read and write a file in Node.Js both in a Synchronous and Asynchronous way. Use the concepts discussed in this blog and create your customized files in Node.js to take your learning journey a step forward.
If you are planning to learn node.js from scratch, get started with knowledgeHut’s node js program. With easy to understand learning material and hands-on sessions we have all the setup ready to help you upskill and grow.
Ans: For writing a file asynchronously we need to use the fs.writeFile() function. For writing a file synchronously we need to use the function fs.writeFileSync() function.
Ans: The fs.readFile() is used to read file asynchronously file and fs.readFileSync() is used to read file synchronously.
Ans: To open a NODE file, you'll need software like Node.js. If you're having trouble opening your NODE file, try right-clicking or long-pressing it. After that, select the "Open with" drop-down menu.
Ans: ‘fs’ Module is an inbuilt module provided by Node.js to perform different actions. The ‘fs’ Module is a file system module that helps you to work with files, like read file, write file, append file, and many more
Ans: We utilise the writeFileSync method in the fs module to write the file in synchronous mode (). The first parameter is the file name, followed by the whole path to the file where the content will be written, and the second parameter is the data that will be written in the file.
| Name | Date | Fee | Know more |
|---|
