Node.js File System (fs)

The fs (File System) module is a built-in Node.js API used to perform file and directory operations on the server.

Import fs

const fs = require("fs");

A synchronous, or blocking, operation waits for one task to finish before moving to the next task.

• Follows a step-by-step execution flow.
• Pauses program flow while the operation runs.
• Prevents other work from progressing through that flow.
• Subsequent tasks start only after completion.
• Long-running operations may affect responsiveness.

Example: readFileSync()

const fs = require("fs");

// Synchronous read
const data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());

Output: Synchronous read: Geeks: A computer science portal

Use cases: lightweight tasks that finish quickly and situations where simplicity is more important than avoiding blocking.

An asynchronous, or non-blocking, operation starts a task without waiting for it to finish. The program can continue and handle the result later.

• Execution continues without waiting for completion.
• The operation works in the background from the application's point of view.
• The result is handled when it is ready.
• Useful for performance and responsiveness.

Example: readFile()

const fs = require("fs");

// Asynchronous read
fs.readFile("input.txt", function (err, data) {
  if (err) {
    return console.error(err);
  }

  console.log("Asynchronous read: " + data.toString());
});

Output: Asynchronous read: Geeks: A computer science portal

Use cases: heavy or time-consuming tasks and applications where responsiveness matters.

fs.open() opens a file and returns a file descriptor, which can be used for further file operations.

fs.open(path, flags, mode, callback)

const fs = require("fs");

console.log("opening file!");
fs.open("input.txt", "r+", function (err, fd) {
  if (err) return console.error(err);
  console.log("File open successfully");
});

Output: opening file! → File open successfully

fs.read() reads data from an already-open file into memory using its file descriptor.

fs.read(fd, buffer, offset, length, position, callback)

Example

const fs = require("fs");
const buf = Buffer.alloc(1024);

console.log("opening an existing file");
fs.open("input.txt", "r+", function (err, fd) {
  if (err) return console.error(err);

  console.log("File opened successfully!");
  console.log("reading the file");

  fs.read(fd, buf, 0, buf.length, 0, function (err, bytes) {
    if (err) console.log(err);

    console.log(bytes + " bytes read");
    if (bytes > 0) {
      console.log(buf.slice(0, bytes).toString());
    }
  });
});

Output: opening an existing file → File opened successfully! → reading the file → 40 bytes read → Geeks: A computer science portal

fs.writeFile() asynchronously writes data to a file. If the file already exists, the operation overwrites its existing content.

fs.writeFile(path, data, options, callback)

• path: file location or file descriptor.
• data: content to write, such as a string or buffer.
• options: controls encoding, mode and flag.
• callback: runs when writing completes.

const fs = require("fs");

console.log("writing into existing file");
fs.writeFile("input.txt", "Geeks", function (err) {
  if (err) return console.error(err);

  console.log("Data written successfully!");
  console.log("Let's read newly written data");

  fs.readFile("input.txt", function (err, data) {
    if (err) return console.error(err);
    console.log("Asynchronous read: " + data.toString());
  });
});

Output: writing into existing file → Data written successfully! → Let's read newly written data → Asynchronous read: Geeks

Appending means adding new data to the end of an existing file without overwriting its current content.

Asynchronous example

const fs = require("fs");
let data = "\nLearn Node.js";

fs.appendFile("input.txt", data, "utf8", function (err) {
  if (err) throw err;
  console.log("Data is appended to file successfully.");
});

Synchronous example

const fs = require("fs");
const data = "\nLearn Node.js";

fs.appendFileSync("input.txt", data, "utf8");
console.log("Data is appended to file successfully.");

fs.close() asynchronously closes an open file descriptor and releases the associated system resources.

fs.close(fd, callback)

• fd: integer representing the file descriptor.
• callback: runs after closing completes.
• err: indicates a failure, if one occurs.
• Do not close a descriptor while an active file operation is using it.

// Close the opened file.
fs.close(fd, function (err) {
  if (err) {
    console.log(err);
  }
  console.log("File closed successfully.");
});

Output: File closed successfully.

fs.unlink() deletes a file or symbolic link from the file system.

fs.unlink(path, callback)

const fs = require("fs");

console.log("deleting an existing file");
fs.unlink("input.txt", function (err) {
  if (err) return console.error(err);
  console.log("File deleted successfully!");
});

Output: deleting an existing file → File deleted successfully!

Self-check