Checking file existence and stats in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the Node.js file system module.

Node.js

const fs = require([1]);

Drag options to blanks, or click blank then click option'

A"os"

B"fs"

C"http"

D"path"

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'path' or 'http' instead of 'fs' in require.

Forgetting to put quotes around the module name.

The fs module is used to work with the file system in Node.js. You import it by requiring the string "fs".

2fill in blank

medium

Complete the code to check if a file exists synchronously.

Node.js

const exists = fs.[1]Sync('example.txt');

Drag options to blanks, or click blank then click option'

AexistsSync

Bexists

CreadFile

Dstat

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'exists' which is deprecated.

Using 'readFile' which reads file content instead of checking existence.

The existsSync method checks if a file exists synchronously and returns true or false.

3fill in blank

hard

Fix the error in the code to get file stats asynchronously.

Node.js

fs.stat('file.txt', ([1], stats) => {
  if (err) {
    console.error(err);
    return;
  }
  console.log(stats.size);
});

Drag options to blanks, or click blank then click option'

AerrorObj

Berror

Cerr

De

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different parameter name than the one checked inside the callback.

Forgetting the error parameter entirely.

The callback function receives an error object as the first argument, commonly named err. The code checks if (err) so the parameter must be named err to match.

4fill in blank

hard

Fill both blanks to create a synchronous check for file stats and print if it is a file.

Node.js

try {
  const stats = fs.[1]('data.json');
  if (stats.[2]()) {
    console.log('It is a file');
  }
} catch (err) {
  console.error('Error:', err);
}

Drag options to blanks, or click blank then click option'

AstatSync

BisFile

CisDirectory

Dstat

Attempts:

3 left

💡 Hint

Common Mistakes

Using asynchronous stat method without callback.

Using isDirectory() instead of isFile() when checking for a file.

statSync gets file stats synchronously. The isFile() method checks if the path is a file.

5fill in blank

hard

Fill all three blanks to read a file asynchronously and log its size in bytes.

Node.js

fs.[1]('log.txt', ([2], data) => {
  if ([3]) {
    console.error([3]);
    return;
  }
  console.log('File size:', data.length);
});

Drag options to blanks, or click blank then click option'

AreadFile

Berr

Dstat

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'stat' instead of 'readFile' to read file content.

Using different names for error parameter inconsistently.

readFile reads the file asynchronously. The first callback parameter is the error, commonly named err. The code checks and logs err if it exists.

Practice

1. Which Node.js method is best to check if a file exists without throwing an error?

easy

A. fs.writeFile

B. fs.readFile

C. fs.open

D. fs.access

Solution

1. Step 1: Understand file existence check methods

   fs.access is designed to check file accessibility without opening or reading it.

2. Step 2: Compare with other methods

   fs.readFile reads content, fs.open opens file descriptor, fs.writeFile writes data. These are not meant for existence check.

3. Final Answer:

   fs.access -> Option D

4. Quick Check:

   Check file existence = fs.access [OK]

Hint: Use fs.access to check file existence safely [OK]

Common Mistakes:

• Using fs.readFile which throws error if file missing
• Trying fs.writeFile which creates or overwrites file
• Using fs.open without error handling

2. Which of the following is the correct syntax to get file stats synchronously in Node.js?

easy

A. fs.statSync('file.txt')

B. fs.stat('file.txt')

C. fs.getStatsSync('file.txt')

D. fs.fileStats('file.txt')

Solution

1. Step 1: Identify synchronous stat method

   fs.statSync is the synchronous method to get file stats.

2. Step 2: Check other options

   fs.stat is asynchronous, others are invalid method names.

3. Final Answer:

   fs.statSync('file.txt') -> Option A

4. Quick Check:

   Synchronous file stats = fs.statSync [OK]

Hint: Sync methods end with Sync, like fs.statSync [OK]

Common Mistakes:

• Confusing async fs.stat with sync fs.statSync
• Using non-existent methods like fs.getStatsSync
• Missing parentheses for function call

3. What will the following code output if 'example.txt' exists and is a file of size 1024 bytes?

const fs = require('fs');
fs.stat('example.txt', (err, stats) => {
  if (err) return console.error('Error');
  console.log(stats.isFile(), stats.size);
});

medium

A. true 1024

B. false 1024

C. true undefined

D. Error

Solution

1. Step 1: Understand fs.stat callback

   If file exists, err is null and stats object contains file info.

2. Step 2: Check stats properties

   stats.isFile() returns true if it is a file, stats.size returns file size in bytes.

3. Final Answer:

   true 1024 -> Option A

4. Quick Check:

   File exists and is file = true and size = 1024 [OK]

Hint: stats.isFile() true means file exists, size shows bytes [OK]

Common Mistakes:

• Assuming stats.size is undefined
• Confusing isFile() with isDirectory()
• Not handling error callback properly

4. Identify the error in this code snippet that checks if a file exists:

const fs = require('fs');
try {
  fs.access('data.txt');
  console.log('File exists');
} catch (err) {
  console.log('File does not exist');
}

medium

A. fs.access does not check file existence

B. fs.access is asynchronous and needs a callback or promise

C. Try/catch cannot catch errors in Node.js

D. console.log syntax is incorrect

Solution

1. Step 1: Check fs.access usage

   fs.access is asynchronous and requires a callback or promise to handle errors.

2. Step 2: Understand try/catch with async

   Try/catch does not catch errors from async calls without await or callback handling.

3. Final Answer:

   fs.access is asynchronous and needs a callback or promise -> Option B

4. Quick Check:

   Async fs.access needs callback/promise [OK]

Hint: Async functions need callbacks or await, not try/catch alone [OK]

Common Mistakes:

• Assuming try/catch works with async without await
• Ignoring callback parameter in fs.access
• Thinking fs.access does not check existence

5. You want to write a function that returns true if a given path is a directory and exists, false otherwise. Which code snippet correctly implements this using Node.js synchronous methods?

hard

A. function isDirectory(path) {
if (fs.statSync(path).isDirectory()) return true;
else return false;
}

B. function isDirectory(path) {
return fs.accessSync(path) && fs.statSync(path).isDirectory();
}

C. function isDirectory(path) {
try {
return fs.statSync(path).isDirectory();
} catch {
return false;
}
}

D. function isDirectory(path) {
try {
return fs.existsSync(path) && fs.statSync(path).isFile();
} catch {
return false;
}
}

Solution

1. Step 1: Check for existence and directory type safely

   Using fs.statSync inside try/catch handles missing path errors and checks if it's a directory.

2. Step 2: Analyze other options

   function isDirectory(path) { return fs.accessSync(path) && fs.statSync(path).isDirectory(); } misuses fs.accessSync without error handling; function isDirectory(path) { try { return fs.existsSync(path) && fs.statSync(path).isFile(); } catch { return false; } } checks isFile() instead of isDirectory(); function isDirectory(path) { if (fs.statSync(path).isDirectory()) return true; else return false; } lacks error handling for missing path.

3. Final Answer:

   function isDirectory(path) { try { return fs.statSync(path).isDirectory(); } catch { return false; } } -> Option C

4. Quick Check:

   Try/catch with statSync and isDirectory() = correct [OK]

Hint: Use try/catch with fs.statSync and isDirectory() to check safely [OK]

Common Mistakes:

• Not handling errors for missing paths
• Checking isFile() instead of isDirectory()
• Using fs.accessSync without try/catch