The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Reading and Writing Files

Next ►
►

In this section, we will explore how to read from and write to files using Node.js. This is a fundamental skill for many Node.js applications, as it allows you to handle data storage and retrieval efficiently.

Key Concepts

  1. File System Module (fs): Node.js provides a built-in module called fs (File System) to interact with the file system.
  2. Synchronous vs. Asynchronous Methods: The fs module offers both synchronous and asynchronous methods for file operations.
  3. Reading Files: Learn how to read the contents of a file.
  4. Writing Files: Learn how to write data to a file.
  5. Appending to Files: Learn how to add data to the end of a file.
  6. Deleting Files: Learn how to remove files from the file system.

Setting Up

Before we start, ensure you have Node.js installed on your machine. You can check this by running:

node -v

If Node.js is not installed, download and install it from the official website.

File System Module (fs)

To use the fs module, you need to require it in your Node.js script:

const fs = require('fs');

Reading Files

Asynchronous Reading

The asynchronous method fs.readFile() reads the contents of a file without blocking the event loop.

const fs = require('fs');

fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
    return;
  }
  console.log('File contents:', data);
});
  • Parameters:
    • example.txt: The file to read.
    • utf8: The encoding format.
    • Callback function: Handles the result or error.

Synchronous Reading

The synchronous method fs.readFileSync() reads the contents of a file and blocks the event loop until the operation is complete.

const fs = require('fs');

try {
  const data = fs.readFileSync('example.txt', 'utf8');
  console.log('File contents:', data);
} catch (err) {
  console.error('Error reading file:', err);
}

Writing Files

Asynchronous Writing

The asynchronous method fs.writeFile() writes data to a file without blocking the event loop.

const fs = require('fs');

const content = 'Hello, World!';

fs.writeFile('example.txt', content, 'utf8', (err) => {
  if (err) {
    console.error('Error writing file:', err);
    return;
  }
  console.log('File written successfully');
});

Synchronous Writing

The synchronous method fs.writeFileSync() writes data to a file and blocks the event loop until the operation is complete.

const fs = require('fs');

const content = 'Hello, World!';

try {
  fs.writeFileSync('example.txt', content, 'utf8');
  console.log('File written successfully');
} catch (err) {
  console.error('Error writing file:', err);
}

Appending to Files

Asynchronous Appending

The asynchronous method fs.appendFile() adds data to the end of a file without blocking the event loop.

const fs = require('fs');

const additionalContent = '\nAppended content';

fs.appendFile('example.txt', additionalContent, 'utf8', (err) => {
  if (err) {
    console.error('Error appending to file:', err);
    return;
  }
  console.log('Content appended successfully');
});

Synchronous Appending

The synchronous method fs.appendFileSync() adds data to the end of a file and blocks the event loop until the operation is complete.

const fs = require('fs');

const additionalContent = '\nAppended content';

try {
  fs.appendFileSync('example.txt', additionalContent, 'utf8');
  console.log('Content appended successfully');
} catch (err) {
  console.error('Error appending to file:', err);
}

Deleting Files

Asynchronous Deletion

The asynchronous method fs.unlink() deletes a file without blocking the event loop.

const fs = require('fs');

fs.unlink('example.txt', (err) => {
  if (err) {
    console.error('Error deleting file:', err);
    return;
  }
  console.log('File deleted successfully');
});

Synchronous Deletion

The synchronous method fs.unlinkSync() deletes a file and blocks the event loop until the operation is complete.

const fs = require('fs');

try {
  fs.unlinkSync('example.txt');
  console.log('File deleted successfully');
} catch (err) {
  console.error('Error deleting file:', err);
}

Practical Exercises

Exercise 1: Reading a File

  1. Create a file named sample.txt and add some text to it.
  2. Write a Node.js script to read the contents of sample.txt asynchronously and log it to the console.

Solution:

const fs = require('fs');

fs.readFile('sample.txt', 'utf8', (err, data) => {
  if (err) {
    console.error('Error reading file:', err);
    return;
  }
  console.log('File contents:', data);
});

Exercise 2: Writing to a File

  1. Write a Node.js script to create a new file named output.txt and write the text "Node.js is awesome!" to it asynchronously.

Solution:

const fs = require('fs');

const content = 'Node.js is awesome!';

fs.writeFile('output.txt', content, 'utf8', (err) => {
  if (err) {
    console.error('Error writing file:', err);
    return;
  }
  console.log('File written successfully');
});

Exercise 3: Appending to a File

  1. Write a Node.js script to append the text "Let's learn more!" to output.txt asynchronously.

Solution:

const fs = require('fs');

const additionalContent = '\nLet\'s learn more!';

fs.appendFile('output.txt', additionalContent, 'utf8', (err) => {
  if (err) {
    console.error('Error appending to file:', err);
    return;
  }
  console.log('Content appended successfully');
});

Exercise 4: Deleting a File

  1. Write a Node.js script to delete the file output.txt asynchronously.

Solution:

const fs = require('fs');

fs.unlink('output.txt', (err) => {
  if (err) {
    console.error('Error deleting file:', err);
    return;
  }
  console.log('File deleted successfully');
});

Common Mistakes and Tips

  • Encoding Issues: Always specify the encoding (e.g., utf8) when reading or writing text files to avoid unexpected behavior.
  • Error Handling: Always handle errors in callbacks to prevent your application from crashing.
  • Blocking the Event Loop: Prefer asynchronous methods over synchronous ones to keep your application responsive.

Conclusion

In this section, you learned how to read from and write to files using Node.js. You explored both asynchronous and synchronous methods for file operations, and you practiced these concepts through practical exercises. Understanding file I/O is crucial for many Node.js applications, and mastering these skills will help you build more robust and efficient applications.

◄ Previous
◄
Next ►
►

Node.js Course

Module 1: Introduction to Node.js

Module 2: Core Concepts

Module 3: File System and I/O

Module 4: HTTP and Web Servers

Module 5: NPM and Package Management

Module 6: Express.js Framework

Module 7: Databases and ORMs

Module 8: Authentication and Authorization

Module 9: Testing and Debugging

Module 10: Advanced Topics

Module 11: Deployment and DevOps

Module 12: Real-World Projects

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved