Writing files in Node.js - Step-by-Step Execution

Concept Flow - Writing files

Start

↓

Import fs module

↓

Call fs.writeFile with filename, data, callback

↓

Node.js writes data to file

↓

Callback runs

↓

If error: handle error

↓

If no error: confirm success

↓

End

This flow shows how Node.js writes data to a file asynchronously using fs.writeFile and handles success or error in a callback.

Execution Sample

Node.js

import { writeFile } from 'node:fs';

writeFile('hello.txt', 'Hello, world!', (err) => {
  if (err) throw err;
  console.log('File saved!');
});

This code writes 'Hello, world!' to 'hello.txt' and logs success or throws error.

Execution Table

Step	Action	Evaluation	Result
1	Import writeFile from fs module	Module imported	writeFile function ready
2	Call writeFile('hello.txt', 'Hello, world!', callback)	Start async write	Writing started
3	Node.js writes data to 'hello.txt'	File system operation	Data written to file
4	Callback triggered with err = null	Check error	No error found
5	Execute console.log('File saved!')	Print message	Message shown in console

💡 Callback completes with no error, writing process ends successfully

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
err	undefined	undefined	null	null

Key Moments - 2 Insights

Why do we need a callback function in writeFile?

Because writeFile works asynchronously, the callback runs after writing finishes to handle success or error, as shown in step 4 of the execution_table.

What happens if there is an error during writing?

If an error occurs, the callback receives an error object (err not null), and the code can handle it, for example by throwing it. This is implied in step 4 where err is checked.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'err' when the callback runs?

A undefined

B An error object

C null

D A string

💡 Hint

Check the 'err' variable in variable_tracker after Step 4

At which step does Node.js actually write data to the file?

A Step 2

B Step 3

C Step 4

D Step 5

💡 Hint

Look at the 'Action' and 'Result' columns in execution_table for Step 3

If the callback throws an error, what happens to the program flow?

A The program stops with an error

B The file is not written

C The program logs 'File saved!'

D The callback runs again

💡 Hint

Refer to Step 4 where error handling is done with 'if (err) throw err;'

Concept Snapshot

Node.js writes files asynchronously using fs.writeFile.
You provide filename, data, and a callback.
Callback runs after writing finishes.
Check error in callback to handle failures.
Success can be confirmed inside callback.
This avoids blocking the program while writing.

Full Transcript

This visual execution shows how Node.js writes files using the fs.writeFile function. First, the writeFile function is imported from the fs module. Then, writeFile is called with the filename 'hello.txt', the string data 'Hello, world!', and a callback function. Node.js starts writing the data asynchronously to the file system. When writing finishes, the callback runs with an error parameter. If there is no error (err is null), the program logs 'File saved!' to the console. If there was an error, it would be thrown to stop the program. This approach lets Node.js write files without stopping other code from running while waiting.

Practice

1. What is the main purpose of using the fs/promises module in Node.js when writing files?

easy

A. To write files using promises and async/await for cleaner code

B. To read files synchronously

C. To create HTTP servers

D. To manage environment variables

Solution

1. Step 1: Understand the role of fs/promises

   The fs/promises module provides promise-based versions of file system functions, allowing use of async/await.

2. Step 2: Identify the purpose related to writing files

   It is mainly used to write files asynchronously with cleaner syntax compared to callbacks.

3. Final Answer:

   To write files using promises and async/await for cleaner code -> Option A

4. Quick Check:

   fs/promises = async file writing [OK]

Hint: Remember fs/promises is for async file operations [OK]

Common Mistakes:

• Confusing fs/promises with synchronous fs methods
• Thinking fs/promises is for reading environment variables
• Assuming fs/promises creates servers

2. Which of the following is the correct syntax to write 'Hello World' to a file named 'greet.txt' using fs/promises in Node.js?

easy

A. fs.writeFileSync('greet.txt', 'Hello World');

B. fs.promises.write('greet.txt', 'Hello World');

C. await fs.writeFile('greet.txt', 'Hello World');

D. await fs.write('greet.txt', 'Hello World');

Solution

1. Step 1: Recall the correct method name in fs/promises

   The method to write files is writeFile, used with await for promises.

2. Step 2: Check syntax correctness

   await fs.writeFile('greet.txt', 'Hello World'); uses await fs.writeFile('greet.txt', 'Hello World'); which is correct syntax for async write.

3. Final Answer:

   await fs.writeFile('greet.txt', 'Hello World'); -> Option C

4. Quick Check:

   writeFile + await = correct syntax [OK]

Hint: Use await with fs.writeFile for async writing [OK]

Common Mistakes:

• Using writeFileSync without await in async code
• Calling non-existent fs.promises.write method
• Omitting await with promise-based methods

3. What will be the output of the following code snippet?

import { writeFile } from 'fs/promises';

async function save() {
  await writeFile('data.txt', 'Node.js Rocks!');
  console.log('File saved');
}
save();

medium

A. No output

B. File saved

C. File saved\nNode.js Rocks!

D. SyntaxError

Solution

1. Step 1: Analyze the async function behavior

   The function writes 'Node.js Rocks!' to 'data.txt' asynchronously, then logs 'File saved'.

2. Step 2: Determine console output

   Since writeFile completes before console.log, the output is 'File saved' printed once.

3. Final Answer:

   File saved -> Option B

4. Quick Check:

   Async write then log = 'File saved' [OK]

Hint: Async writeFile logs after completion [OK]

Common Mistakes:

• Expecting file content to print to console
• Confusing syntax error with valid import
• Thinking no output occurs without explicit return

4. Identify the error in the following code that attempts to write to a file:

import fs from 'fs/promises';

async function writeData() {
  fs.writeFile('output.txt', 'Test data');
  console.log('Done');
}
writeData();

medium

A. writeFile method does not exist in fs/promises

B. Incorrect import statement for fs/promises

C. File path 'output.txt' is invalid

D. Missing await before fs.writeFile causing unhandled promise

Solution

1. Step 1: Check async function usage

   The function calls fs.writeFile but does not await it, so the promise is not handled properly.

2. Step 2: Understand consequences of missing await

   Without await, the write operation may not complete before 'Done' logs, and errors won't be caught.

3. Final Answer:

   Missing await before fs.writeFile causing unhandled promise -> Option D

4. Quick Check:

   Always await async fs methods [OK]

Hint: Always await async file writes to avoid errors [OK]

Common Mistakes:

• Forgetting await with async fs methods
• Assuming import syntax is wrong when it is correct
• Blaming file path without checking code first

5. You want to write multiple lines to a file 'log.txt' asynchronously, appending each new line without overwriting. Which approach correctly achieves this using fs/promises?

hard

A. Use await fs.appendFile('log.txt', 'New line\n'); inside an async function

B. Use await fs.writeFile('log.txt', 'New line\n'); repeatedly

C. Use fs.writeFileSync('log.txt', 'New line\n'); inside async function

D. Use fs.appendFileSync('log.txt', 'New line\n'); without async

Solution

1. Step 1: Understand file appending vs overwriting

   To add lines without erasing existing content, appending is needed, not writeFile which overwrites.

2. Step 2: Choose correct async method

   fs.appendFile from fs/promises appends asynchronously and works with await.

3. Final Answer:

   Use await fs.appendFile('log.txt', 'New line\n'); inside an async function -> Option A

4. Quick Check:

   appendFile + await = append lines safely [OK]

Hint: Use appendFile to add lines without erasing [OK]

Common Mistakes:

• Using writeFile which overwrites file content
• Using synchronous methods in async code
• Not adding newline characters when appending