Why file system access matters in Node.js - See It in Action

Why file system access matters

📖 Scenario: You are building a simple Node.js app that reads and writes text files on your computer. This helps you understand why file system access is important for many real-world apps like note-taking, data logging, or configuration management.

🎯 Goal: Create a Node.js script that reads a text file, counts the number of words, and writes the count to a new file.

📋 What You'll Learn

Use the built-in fs module to read and write files

Read the contents of a file named input.txt

Count the number of words in the file content

Write the word count to a file named output.txt

💡 Why This Matters

🌍 Real World

Many apps need to read and save data on your computer, like text editors, loggers, or configuration tools. Understanding file system access lets you build these apps.

💼 Career

Node.js developers often work with files for data processing, automation, and backend services. Knowing how to use the file system module is a key skill.

1

Set up the file system module and read the file

Write import fs from 'fs/promises' to import the file system promises API. Then create an async function called countWords that reads the file input.txt using await fs.readFile('input.txt', 'utf-8') and stores the content in a variable called text.

Node.js

import fs from 'fs/promises'

async function countWords() {
  // Your code here
}

Hint

Use import fs from 'fs/promises' to get the modern promise-based file system API. Use await fs.readFile inside an async function to read the file content as text.

2

Add a variable to count words

Inside the countWords function, create a variable called words that splits the text by spaces using text.split(' '). Then create a variable called wordCount that stores the length of the words array.

Node.js

import fs from 'fs/promises'

async function countWords() {
  const text = await fs.readFile('input.txt', 'utf-8')
  // Your code here
}

Hint

Use text.split(' ') to break the text into words. Then use words.length to count how many words there are.

3

Write the word count to a new file

Still inside the countWords function, use await fs.writeFile('output.txt', `Word count: ${wordCount}`) to write the word count to a file named output.txt.

Node.js

import fs from 'fs/promises'

async function countWords() {
  const text = await fs.readFile('input.txt', 'utf-8')
  const words = text.split(' ')
  const wordCount = words.length
  // Your code here
}

Hint

Use await fs.writeFile to save the word count string to output.txt.

4

Call the function to run the script

After the countWords function, add a line to call countWords() so the script runs when executed.

Node.js

import fs from 'fs/promises'

async function countWords() {
  const text = await fs.readFile('input.txt', 'utf-8')
  const words = text.split(' ')
  const wordCount = words.length
  await fs.writeFile('output.txt', `Word count: ${wordCount}`)
}

// Your code here

Hint

Simply call countWords() after the function to run the code.

Practice

1. Why is file system access important in a Node.js application?

easy

A. It prevents the app from using the internet.

B. It makes the app run faster by using more CPU cores.

C. It automatically fixes bugs in the code.

D. It allows the app to save and load data outside the program.

Solution

1. Step 1: Understand file system role

   File system access lets an app save and retrieve data from files on the computer.

2. Step 2: Identify correct purpose

   Only 'It allows the app to save and load data outside the program.' correctly describes this purpose; others are unrelated to file system access.

3. Final Answer:

   It allows the app to save and load data outside the program. -> Option D

4. Quick Check:

   File system access = save/load data [OK]

Hint: File system means saving or reading files outside code [OK]

Common Mistakes:

• Confusing file system access with CPU or internet features
• Thinking file system fixes bugs automatically
• Assuming file system access speeds up CPU usage

2. Which of the following is the correct way to import the Node.js file system module?

easy

A. require fs from 'fs';

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

C. const fs = import('fs');

D. import fs from 'fs';

Solution

1. Step 1: Recall Node.js import syntax

   Node.js commonly uses const fs = require('fs'); to import modules in CommonJS style.

2. Step 2: Check options for syntax correctness

   'require fs from 'fs';' is invalid syntax; 'import fs from 'fs';' is ES module style but requires extra config; 'const fs = import('fs');' uses dynamic import returning a Promise; 'const fs = require('fs');' matches correct syntax.

3. Final Answer:

   const fs = require('fs'); -> Option B

4. Quick Check:

   CommonJS import = require('fs') [OK]

Hint: Use require('fs') to import file system in Node.js [OK]

Common Mistakes:

• Using ES module import without config
• Writing invalid syntax like 'require fs from'
• Confusing import() function with require()

3. What will the following Node.js code output?

const fs = require('fs');
fs.writeFileSync('test.txt', 'Hello');
const data = fs.readFileSync('test.txt', 'utf8');
console.log(data);

medium

A. Error: File not found

B. undefined

C. Hello

D. null

Solution

1. Step 1: Write data to file synchronously

   The code writes 'Hello' to 'test.txt' using writeFileSync, which blocks until done.

2. Step 2: Read file content synchronously

   Then it reads the file content as UTF-8 text and stores it in data.

3. Step 3: Output the read content

   console.log prints the string 'Hello' read from the file.

4. Final Answer:

   Hello -> Option C

5. Quick Check:

   Write then read file = 'Hello' output [OK]

Hint: WriteFileSync then ReadFileSync outputs written text [OK]

Common Mistakes:

• Assuming async functions without callbacks
• Expecting undefined or null instead of file content
• Thinking file read fails without prior write

4. Identify the error in this Node.js code snippet:

const fs = require('fs');
fs.readFile('data.txt', (err, data) => {
  if (err) throw err;
  console.log(data);
});

medium

A. Missing encoding, so data is a Buffer, not string.

B. Callback function is missing the error parameter.

C. readFile is a synchronous method, cannot use callback.

D. fs module is not imported correctly.

Solution

1. Step 1: Check readFile usage

   fs.readFile without encoding returns a Buffer object, not a string.

2. Step 2: Understand console.log output

   Logging Buffer prints raw bytes, not readable text. To get string, encoding like 'utf8' is needed.

3. Final Answer:

   Missing encoding, so data is a Buffer, not string. -> Option A

4. Quick Check:

   readFile without encoding = Buffer data [OK]

Hint: Add 'utf8' encoding to readFile for string data [OK]

Common Mistakes:

• Ignoring that data is a Buffer without encoding
• Thinking readFile is synchronous
• Assuming callback lacks error parameter

5. You want to read multiple files asynchronously and process their contents only after all are read. Which approach best uses Node.js file system access to achieve this?

hard

A. Use fs.readFile with callbacks and count completed reads before processing.

B. Use fs.readFileSync for each file in a loop to block until done.

C. Use fs.writeFile to write all files first, then read one file.

D. Use fs.unlink to delete files before reading them.

Solution

1. Step 1: Understand asynchronous reading need

   Reading files asynchronously avoids blocking the app and keeps it responsive.

2. Step 2: Choose method to track multiple async reads

   Using fs.readFile with callbacks and counting completions lets you know when all files are read before processing.

3. Step 3: Eliminate incorrect options

   Using fs.readFileSync for each file in a loop blocks until done and is inefficient; using fs.writeFile writes files unnecessarily; using fs.unlink deletes files, which is wrong.

4. Final Answer:

   Use fs.readFile with callbacks and count completed reads before processing. -> Option A

5. Quick Check:

   Async read with callbacks + count = best approach [OK]

Hint: Use async readFile with callback counting to wait all done [OK]

Common Mistakes:

• Using synchronous reads blocking the app
• Confusing writeFile with reading files
• Deleting files before reading them