JavaScript Journal: Reading Local Files in Node.js (Part 1).

Prerequisite Knowledge:

• JavaScript Fundamentals.

• Programming Modules.

Unlike Python and Java, JavaScript lacks a simple read() method that helps the program read content from a local file. Its approach to this problem is a set of less simpler steps compared to the direct and concise way in some other languages.

Node.js, a runtime environment for traditional JavaScript, is also characterized by this feature. This is partly because JavaScript was initially created as a light-weight language to add dynamism to static webpages(Concepts of Programming Languages by Robert W Sebasta). As it evolved to a well-structured dialect with support, it was necessary to ensure its implementation remained efficient and Non-blocking.

• When a program operation is Blocking, other executions are suspended until the operation completes. The program cannot do anything else while it is waiting for the blocking operation to finish.

However, Node.js contains a set of tools embedded in the File System(fs) module, which, when imported into the program, can be used to read local files. These are:

1. The fs.readFileSync() method.

2. The fs.readFile() method.

1. fs.readFileSync()

This approach, though a blocking approach, otherwise known as Synchronous Programming, is a less complex way of reading files into the program. When imported from the fs module;

1. It halts the rest of the program,

2. reads the content in the local file, and

3. copies it into a program variable, then.

4. continues to execute other parts of the program.

Here is a simple code snippet to show its implementation.

1. //The next line imports the file system(fs) module

2. const fs = require(“fs”);

3. /*The next line uses the readFileSync() method from the imported module to read the file, taking file name and file encoding as inputs.*/

4. • const myFile = fs.readFileSync(“localfile.txt”, “utf8”);

5. //finally, the last line prints the contents of the file on the console

6. • console.log(myFile);

2. fs.readFile()

The fs.readFile() method, on the other hand, executes this same task differently. While it doesn’t interrupt the rest of the program, it reads the contents of the file in the background and returns the file’s content when it’s ready. This form of program execution is also called asynchronous programming. The operation:

1. Imports the fs module into the program

2. Runs the fs.readFile() operation with file path, file encoding, and a callback function as parameters.

3. Returns the contents of the file using the callback function.

Here is another code snippet for the program’s implementation.

1. //the next line imports the file system(fs) module

2. const fs = require('fs');

3. /*The next block of code contains the readFile() operation and the callback function. The fs.readFile() method takes the file path, file encoding and callback function as parameters, while the callback function takes a variable to store the contents of the file and an err message— incase, the file is not found- as parameters*/

4. fs.readFile('myfile.txt', 'utf8', (err, data) => {

5. • if (err) {
6. • • console.error('Error reading the file:', err.message);
7. • • return;
8. • }
9. • // Output the content to the console
10. • console.log(data);

11. });

Though the fs.readFile() method is a more efficient algorithm for reading files, the contents of the files can only be used within the function scope. To bypass this roadblock, Node.js provides numerous methods to enable the utilization of file contents in other parts of the program. These are:

• Use a Callback Function

• Use Promises with .then()

• Use async/await

To further understand how these methods work, do check out the second part of this article that explores Asynchronous Programming and the fs.readFile() method.