How to operate callback-based fs.opendir() method with promises in Node.js ?

Last Updated : 24 Nov, 2021

The fs.opendir() method is defined in the File System module of Node.js. The File System module is basically to interact with the hard disk of the user’s computer. The method used to asynchronously open a directory.
The fs.opendir() method is based on callback. Using callback methods leads to a great chance of callback nesting or callback hell problems. Thus to avoid it we almost always like to work with a promise-based method. Using some extra node.js methods we can operate a callback-based method in promise way. The promise is resolved with ‘fs.Dir’ object, the object itself contains other functions for accessing and closing the directory. In case if the promise is rejected it will be rejected with an error object.
Syntax:

fs.opendir(path, options)

Note : Callback not required since we operate the method with promises.
Parameters: Accepts two parameter path and options as mentioned above. The options is an optional parameter.

path: It is an String, Buffer or Url that specifies the path to the directory that has to be open.
options: It is an optional parameter which affects the output in someway accordingly provide it to the function call or not.
- encoding: It specifies the encoding technique, default is ‘UTF8’
- bufferSize: It is a number that specifies the number of directory entries that are buffered internally when reading from the directory. High value of bufferSize, ensures good performance but leads to more memory usages.

Returns: If method operates with promises it returns a promise resolved with 'fs.Dir' object, the object itself contains other functions for accessing and closing the directory. In case if the promise is rejected it will be rejected with an error object.
'dir' object methods:

dir.close(): It asynchronously close the resources of the directory and hence Subsequent attempt to read will result in errors. A Promise is returned that will be resolved after the resource has been closed.
dir.closeSync(): It synchronously close the resources of the directory and hence Subsequent attempt to read will result in errors.
dir.path: Returns the path to the directory.
dir.read(): It asynchronously read the next directory entry. After the read is completed, a Promise is returned that will be resolved with an fs.Dirent, or null if there are no more directory read.

Approach: fs.opendir() method based on callback. To operate it with promises, first, we use promisify() method defined in the utilities module to convert it into a promise based method.
Example 1: Filename: index.js

javascript

// Importing File System and Utilities module
const fs = require('fs')
const util = require('util')

// Convert callback based methods
// to promise based methods
const openDir = util.promisify(fs.opendir)

openDir('./testDirectory')
    .then(dir => {
        console.log('Directory is opened')

        // Path to the directory
        console.log(`Path to the directory: 
                            ${dir.path}`)

        // Closing directory
        return dir.close()
    })

    .then(() => {
        console.log('Directory closed')

        console.log('\nFurther attempt to'
            + ' read sub-directories:\n')

        // Further attempt to access the
        // directory results in error
        return dir.read()
    })

    .then(dirent => {

        // Does not execute since directory
        // is closed catch block runs instead
        console.log(dirent)
    })
    .catch(err => {
        console.log('Error, Something went wrong!')
    })

Implementing the same functionality using async-await.

javascript

// Importing File System and 
// Utilities module
const fs = require('fs')
const util = require('util')

// Convert callback based methods
// to promise based methods
const openDir = util.promisify(fs.opendir)

const fetchDirectory = async (path) => {

    // Opeaning directory
    const dir = await openDir(path)
    console.log('Directory is opened')

    // Path to the directory
    console.log(`Path to the directory: ${dir.path}`)

    // Closing directory
    await dir.close()
    console.log('Directory closed')

    console.log('\nFurther attempt to '
        + 'read sub-directories:\n')
    
    // Further attempt to access the directory
    // results in error does not execute since
    // directory is closed catch block runs
    // instead
    const subDir = await dir.read()
    console.log(subDir)
}

fetchDirectoey('./testDirectory')
    .catch(err => {
        console.log('Error, Something went wrong!')
    })

Run index.js file using the following command:

node index.js

Output:

  Directory is opened
  Path to the directory: testDirectory
  Directory closed

  Further attempt to read sub-directories:

  Error, Something went wrong!

Example 2: Filename index.js

javascript

// Importing File System and Utilities module
const fs = require('fs')
const util = require('util')

// Convert callback based methods to
// promise based methods
const openDir = util.promisify(fs.opendir)

openDir('./testDirectory')
    .then(dir => {
        console.log('Directory is opened')

        // Path to the directory
        console.log(`Path to the directory: ${dir.path}`)

        // Reading sub-directories or files

        console.log('\nReading sub-directories:\n')
        return dir.read()
    })

    .then(dirent => {
        console.log(`Sub-Directory : ${dirent.name}`)

        // Reading further sub directories
        return dir.read()
    })

    .then(dirent => {
        console.log(`Sub-Directory : ${dirent.name}`)
        return dir.read()
    })

    .then(dirent => {
        console.log(`Sub-Directory : ${dirent.name}`)
        return dir.read()
    })
    .then(dirent => {
        console.log(`Sub-Directory : ${dirent.name}`)
        return dir.read()
    })
    .then(dirent => {
        console.log(`Sub-Directory : ${dirent.name}`)
        return dir.read()
    })
    .catch(err => {
        console.log('Error, Something went wrong!')
    })

Implementing the same functionality using async-await.

javascript

// Importing File System and Utilities module
const fs = require('fs')
const util = require('util')

// Convert callback based methods
// to promise based methods
const openDir = util.promisify(fs.opendir)

const fetchDirectory = async (path) => {

    // Opeaning directory
    const dir = await openDir(path)
    console.log('Directory is opened')

    // Path to the directory
    console.log(`Path to the directory: ${dir.path}`)

    // Reading sub-directories or files
    console.log('\nReading sub-directories:\n')

    const subDir1 = await dir.read()
    const subDir2 = await dir.read()
    const subDir3 = await dir.read()
    const subDir4 = await dir.read()
    const subDir5 = await dir.read()

    // Printing
    console.log(`Sub-Directory : ${subDir1.name}`)
    console.log(`Sub-Directory : ${subDir2.name}`)
    console.log(`Sub-Directory : ${subDir3.name}`)
    console.log(`Sub-Directory : ${subDir4.name}`)
    console.log(`Sub-Directory : ${subDir5.name}`)
}

fetchDirectory('./testDirectory')
    .catch(err => {
        console.log('Error, Something went wrong!')
    })

Run index.js file using the following command:

node index.js

Output:

  Directory is opened
  Path to the directory: testDirectory

  Reading sub-directories:

  Sub-Directory : testFile1.txt
  Sub-Directory : testFile2.txt
  Sub-Directory : teasrFile3.txt
  Sub-Directory : testFile4.txt
  Sub-Directory : null

How to operate callback-based fs.readdir() method with promises in Node.js ?

hunter__js

Improve

Article Tags :

How to operate callback-based fs.opendir() method with promises in Node.js ?

Similar Reads

Thank You!

What kind of Experience do you want to share?