Node JS fs.readFileSync() Method

Last Updated : 10 Aug, 2026

The fs.readFileSync() method in Node.js reads files synchronously, meaning execution pauses until the file is fully read. It belongs to the built-in fs module and is typically used in simple scripts or during initialization where blocking is acceptable.

  • It reads a file in a synchronous, blocking manner.
  • It requires the file path and can include optional encoding or flags.
  • It throws an error if the file cannot be accessed.

Syntax:

fs.readFileSync(path[, options])

Where:

  • path: Specifies the file location to be read.
  • options: Optional parameter to control reading behavior.
  • encoding: Defines the format of the returned data (e.g., 'utf8').
  • flag: Sets the file system flag for reading (default is 'r').

Return Value: Returns file content as a Buffer or string (if encoding is specified), or throws an error.

fs.readFileSync() Working

When you call fs.readFileSync(), NodeJS reads the file from the disk and blocks the rest of the program from executing until the file has been completely read. This ensures that the file's data is available immediately after the method call, which can be beneficial in certain situations but may affect performance if used improperly.​

Example:

Suppose you have a file named input.txt with the following content:

This is some text data stored in input.txt.

You can read this file synchronously as follows:

javascript 
// Include the fs module
const fs = require('fs');

// Read the file synchronously
const data = fs.readFileSync('./input.txt', { encoding: 'utf8', flag: 'r' });

// Display the file content
console.log(data);

Output: 

This is some text data stored in input.txt.

fs.readFileSync() vs. fs.readFile()

Understanding the difference between fs.readFileSync() and fs.readFile() is important for effective file handling in NodeJS:​

  • fs.readFileSync(): Reads the file synchronously, blocking the event loop until the operation is complete. This is suitable when you need the file's content immediately and can afford to pause the program's execution.​
  • fs.readFile(): Reads the file asynchronously, allowing other operations to continue while the file is being read. This is preferable in performance-critical applications where non-blocking behavior is desired.

Example:

javascript 
// Include the fs module
const fs = require('fs');

// Asynchronously read 'input1.txt'
fs.readFile('./input1.txt', { encoding: 'utf8', flag: 'r' }, (err, data1) => {
  if (err) {
    console.error('Error reading input1.txt:', err);
  } else {
    console.log('input1.txt content:', data1);
  }
});

// Synchronously read 'input2.txt'
try {
  const data2 = fs.readFileSync('./input2.txt', { encoding: 'utf8', flag: 'r' });
  console.log('input2.txt content:', data2);
} catch (err) {
  console.error('Error reading input2.txt:', err);
}

Output:

input1.txt content: (Content of input1.txt)
input2.txt content: (Content of input2.txt)

Observation:

  • fs.readFile() initiates an asynchronous read and uses a callback to handle the data once it's available. The program continues executing other code without waiting for the file read to complete.​
  • fs.readFileSync() blocks the execution until the file is fully read, ensuring that the data is available immediately after the call.

When to Use fs.readFileSync() and fs.readFile()

Use fs.readFileSync() :

  • Working with small files, such as configuration or initialization files, where blocking the execution has minimal impact.​
  • Ensuring that the file's content is available immediately before proceeding with other operations.

Use fs.readFile() :

  • Handling large files or performing operations where non-blocking I/O is essential to maintain application responsiveness.​
  • Developing applications that require high performance and cannot afford to block the event loop, such as web servers handling multiple requests.

When to Avoid fs.readFileSync()

1. Performance Concerns:

  • fs.readFileSync() blocks the program until it finishes reading a file, it can slow things down when reading large files or when multiple tasks need to be handled at the same time. For better performance, use fs.readFile() (asynchronous) or promises.

2. Non-Blocking Operations in Web Servers:

  • If you're building a web server with NodeJS (like using Express), fs.readFileSync() can make your server slower. Each request might get blocked while waiting for the file to be read, slowing down the server's response time.
Comment

Explore