Reading files with promises (fs.promises) in Node.js - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is fs.promises in Node.js?

fs.promises is a part of Node.js that provides file system methods which return promises. This lets you use async/await or .then() for easier asynchronous file operations.

beginner

How do you read a file using fs.promises with async/await?

You use await fs.promises.readFile(path, options) inside an async function. It returns the file content as a buffer or string if encoding is set.

intermediate

Why is using promises better than callbacks for reading files?

Promises make code easier to read and write by avoiding nested callbacks. They allow chaining and use of async/await, which looks like normal synchronous code but runs asynchronously.

intermediate

What happens if the file does not exist when using fs.promises.readFile?

The promise is rejected with an error. You can catch this error using try/catch with async/await or .catch() when using promises.

beginner

Show a simple example of reading a text file with fs.promises and logging its content.

<pre>import { promises as fs } from 'fs';

async function readText() {
  try {
    const data = await fs.readFile('file.txt', 'utf8');
    console.log(data);
  } catch (err) {
    console.error('Error reading file:', err);
  }
}

readText();</pre>

Which method from fs.promises reads a file asynchronously?

A readFile

B readFileSync

C open

D writeFile

readFile is the asynchronous method that returns a promise to read file contents.

What does fs.promises.readFile return when successful?

A A callback function

B File descriptor number

C Undefined

D A promise that resolves to file content

It returns a promise that resolves with the file content as a buffer or string.

How do you handle errors when using async/await with fs.promises.readFile?

A Using if/else

B Using try/catch block

C Using switch statement

D No error handling needed

Errors from promises can be caught using try/catch when using async/await.

Which import syntax correctly imports fs.promises in ES modules?

A import fs from 'fs/promises';

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

C import { promises as fs } from 'fs';

D import fs from 'fs';

In ES modules, import { promises as fs } from 'fs'; imports the promises API.

What encoding option should you pass to readFile to get a string instead of a buffer?

A 'utf8'

B 'ascii'

C 'base64'

D No option needed

Passing 'utf8' returns the file content as a string.

Explain how to read a file asynchronously using fs.promises and handle errors.

Think about using async/await and try/catch blocks.

Describe the benefits of using promises over callbacks when reading files in Node.js.

Focus on code readability and error management.

Practice

1. What does fs.promises.readFile return when reading a file in Node.js?

easy

A. The file content directly as a string

B. A promise that resolves with the file content

C. A callback function to handle the file content

D. An event emitter for file reading progress

Solution

1. Step 1: Understand fs.promises.readFile behavior

   This method returns a promise that will resolve when the file is read successfully.

2. Step 2: Identify the return type

   Since it returns a promise, you can use await or .then() to get the file content asynchronously.

3. Final Answer:

   A promise that resolves with the file content -> Option B

4. Quick Check:

   fs.promises.readFile returns a promise [OK]

Hint: Remember: fs.promises methods always return promises [OK]

Common Mistakes:

• Thinking it returns file content directly
• Confusing with callback-based fs.readFile
• Expecting an event emitter

2. Which of the following is the correct syntax to read a file using fs.promises.readFile with async/await?

easy

A. const data = await fs.promises.readFile('file.txt');

B. const data = fs.promises.readFile('file.txt');

C. fs.promises.readFile('file.txt', (err, data) => {});

D. await fs.readFile('file.txt', 'utf8');

Solution

1. Step 1: Use async/await with promises

   To get the file content, you must await the promise returned by fs.promises.readFile.

2. Step 2: Check syntax correctness

   const data = await fs.promises.readFile('file.txt'); correctly uses await with fs.promises.readFile. const data = fs.promises.readFile('file.txt'); misses await, C uses callback style which is incorrect here, and D uses wrong module method.

3. Final Answer:

   const data = await fs.promises.readFile('file.txt'); -> Option A

4. Quick Check:

   Use await with fs.promises.readFile [OK]

Hint: Always await promises to get their resolved value [OK]

Common Mistakes:

• Omitting await and expecting immediate data
• Using callback style with promises API
• Mixing fs and fs.promises methods

3. What will be logged by this code snippet?

import { promises as fs } from 'fs';

async function read() {
  const content = await fs.readFile('example.txt', 'utf8');
  console.log(typeof content);
}

read();

medium

A. 'undefined'

B. 'object'

C. 'string'

D. Throws an error

Solution

1. Step 1: Understand readFile with encoding

   When you pass 'utf8' as the second argument, the promise resolves with a string containing the file content.

2. Step 2: Check the logged type

   The typeof operator on a string returns 'string', so the console logs 'string'.

3. Final Answer:

   'string' -> Option C

4. Quick Check:

   readFile with 'utf8' returns string [OK]

Hint: Add 'utf8' to get string, else Buffer is returned [OK]

Common Mistakes:

• Forgetting encoding returns Buffer, not string
• Expecting 'object' type for file content
• Not awaiting the promise before logging

4. Identify the error in this code snippet:

import { promises as fs } from 'fs';

async function readFile() {
  const data = fs.readFile('data.txt', 'utf8');
  console.log(data);
}

readFile();

medium

A. Missing await before fs.readFile call

B. Wrong import syntax for fs.promises

C. readFile does not exist in fs.promises

D. Encoding 'utf8' is invalid here

Solution

1. Step 1: Check asynchronous call handling

   The fs.readFile returns a promise, so to get the file content, you must await it.

2. Step 2: Identify the missing await

   Without await, data is a promise object, so logging it shows a promise, not file content.

3. Final Answer:

   Missing await before fs.readFile call -> Option A

4. Quick Check:

   Always await promises to get resolved value [OK]

Hint: Await promises before using their results [OK]

Common Mistakes:

• Logging promise instead of awaited result
• Confusing import syntax for fs.promises
• Passing wrong encoding string

5. You want to read multiple files ['a.txt', 'b.txt', 'c.txt'] concurrently using fs.promises.readFile and get their contents as strings. Which code snippet correctly does this?

hard

A. const contents = await fs.readFile(files, 'utf8');

B. const contents = files.map(f => await fs.readFile(f, 'utf8'));

C. const contents = files.forEach(async f => await fs.readFile(f, 'utf8'));

D. const contents = await Promise.all(files.map(f => fs.readFile(f, 'utf8')));

Solution

1. Step 1: Understand concurrent reading with Promise.all

   To read multiple files concurrently, map each filename to a promise and use Promise.all to await all results.

2. Step 2: Analyze each option

   const contents = await Promise.all(files.map(f => fs.readFile(f, 'utf8'))); correctly maps files to promises and awaits them all. const contents = files.map(f => await fs.readFile(f, 'utf8')); uses await inside map callback which is invalid syntax. const contents = files.forEach(async f => await fs.readFile(f, 'utf8')); uses forEach which returns undefined. const contents = await fs.readFile(files, 'utf8'); tries to read multiple files at once, which is invalid.

3. Final Answer:

   const contents = await Promise.all(files.map(f => fs.readFile(f, 'utf8'))); -> Option D

4. Quick Check:

   Use Promise.all with map for concurrent reads [OK]

Hint: Use Promise.all with map to await multiple promises [OK]

Common Mistakes:

• Using await inside map callback directly
• Using forEach which returns undefined
• Trying to read multiple files in one readFile call