File handling in Node.js

The most important functionalities provided by programming languages are Reading and Writing files from computers. Node.js provides the functionality to read and write files from the computer. Reading and Writing the file in Node.js is done by using one of the coolest Node.js modules called fs module, it is one of the most well-known built-in Node.js modules out there.

The file can be read and written in node.js in both Synchronous and Asynchronous ways. A Synchronous method is a code-blocking method which means the given method will block the execution of code until its execution is finished (i.e. Complete file is read or written). On the other hand, an Asynchronous method has a callback function that is executed on completion of the execution of the given method and thus allows code to run during the completion of its execution. Or according to modern JavaScript, asynchronous methods return a Promise which implies the eventual completion of the ongoing asynchronous method, the Promise will either be resolved or rejected. Thus, it is non-blocking.

Synchronous method to read the file: To read the file in the synchronous mode we use a method in the fs module which is readFileSync(). It takes two parameters first is the file name with a complete path and the second parameter is the character encoding which is generally 'utf-8'.

Example:

// Require the given module
const fs = require('fs');

// Use readFileSync() method

// Store the result (return value) of this
// method in a variable named readMe

// Keep the file in the same folder so
// donot need to specify the complete path
const readMe = fs.readFileSync('readMe.txt', 'utf-8');

// log the content of file stored in
// a variable to screen
console.log(readMe);

Output: 

Synchronous method to writing into a file: To write the file in a synchronous mode we use a method in the fs module which is writeFileSync(). It takes two parameters first is the file name with the complete path in which content is to be written and the second parameter is the data to be written in the file.

// Require the given module
const fs = require('fs');

// Use readFileSync() method

// Store the result (return value) of this
// method in a variable named readMe
const readMe = fs.readFileSync('readMe.txt', 'utf-8');

// Store the content and read from
// readMe.txt to a file WriteMe.txt
fs.writeFileSync('writeMe.txt', readMe);

Asynchronous method to read and write from/into a file: To read/write the file in an asynchronous mode in the fs module we use the readFile() and writeFile() methods. The fs.readFile() takes three parameters first is the file name with the complete path, the second parameter takes the character encoding which is generally 'utf-8' and the third parameter is the callback function (which is fired after reading a complete file) with two parameters, one is the error in case error occurred while reading file and second is the data that we retrieve after reading the file and the fs.writeFile() also takes three parameters, file name with its complete path, the second parameter is the data to be written in file and the third is a callback function which fires in case an error occurs while writing the file.
Note: An Asynchronous method first completes the task (reading the file) and then fires the callback function.

// Require the given module
const fs = require('fs');
 
// Use readFile() method
fs.readFile('readMe.txt', 'utf-8', function(err, data) {
 
    // Write the data read from readeMe.txt
    // to a file writeMe.txt
    if( !err )
        fs.writeFile('writeMe.txt', data, (err)=>{
            if( err ) {
                throw err;
            }
        });
    else
        throw err;
});

Output: 

If we talk in terms of Promise the asynchronous file handling method in Node.js, we have to use a promising method that takes a function following the callback approach as an input and returns a version of this function that returns a promise. The code looks like this as shown below (async-await approach has been followed here.) :

const {writeFile,readFile} = require('fs')
const {promisify} = require('util')

const readFileasync = promisify(readFile);
const writeFileasync = promisify(writeFile);

const file_handler = async()=>{
    try {
        const content = await writeFileasync('./writeMe.txt',"hello world");
        try {
            const data = await readFileasync('./writeMe.txt','utf-8');
            console.log('New file has been created .');
            console.log(data);
        } catch (error) {
            throw error;
        }
    } catch (error) {
          throw error;
    }
}

file_handler();

 Let's have a look at the terminal to figure out whether the code worked or not.

So, this is another way to achieve the same result as far as asynchronous file handling in Node.js is concerned.