Writing files in Node.js

Introduction

Writing files lets your program save information on the computer. This helps keep data even after the program stops.

Saving user settings or preferences

Logging events or errors for later review

Creating reports or exporting data

Storing temporary data between program runs

Syntax

Node.js

import { writeFile } from 'node:fs/promises';

await writeFile('filename.txt', 'Your content here');

Use the 'fs/promises' module for easy async file writing with await.

The first argument is the file path, the second is the content to write.

Examples

Writes 'Hello, world!' to a file named hello.txt.

Node.js

import { writeFile } from 'node:fs/promises';

await writeFile('hello.txt', 'Hello, world!');

Saves a JSON string to data.json file.

Node.js

import { writeFile } from 'node:fs/promises';

await writeFile('data.json', JSON.stringify({ name: 'Alice', age: 30 }));

Writes multiple lines to notes.txt using newline characters.

Node.js

import { writeFile } from 'node:fs/promises';

await writeFile('notes.txt', 'Line 1\nLine 2\nLine 3');

Sample Program

This program writes a simple message to 'message.txt' and then prints a confirmation.

Node.js

import { writeFile } from 'node:fs/promises';

async function saveMessage() {
  const message = 'This is a saved message.';
  await writeFile('message.txt', message);
  console.log('File saved successfully!');
}

saveMessage();

Important Notes

Always handle errors in real programs to catch issues like permission problems.

Writing files is asynchronous; use async/await or promises to wait for completion.

File paths can be relative or absolute. Relative paths are from where you run the program.

Summary

Writing files saves data permanently on your computer.

Use the 'fs/promises' module with async/await for simple, clean code.

Remember to handle errors and choose correct file paths.

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