Analyzing the list of paths that are passed to the function

Question

Analyzing the list of paths that are passed to the function

I am looking for assistance in creating an asynchronous "getTypes" function that can analyze a list of paths and return an array describing the type of content in each path. The function should handle all cases efficiently and in case of any errors during the operation, it should return "null" for that specific path. I have attempted to write a function myself but encountered issues.

const getTypes = (arr) => {
  const prom = arr.reduce((acc, path) => (
    acc.then((data) => {
       return fs.stat(path).isFile() ? 'file' : 'directory';
     })
    .catch(() => null)
  ), Promise.resolve());
  return prom;
}

This is how it should operate:

getTypes(['/etc', '/etc/hosts', '/undefined']).then(console.log);
// ['directory', 'file', null]

I am struggling with this implementation, seeking help from someone who can assist. Thank you!

javascript asynchronous es6-promise

Answer 1

Answer №1

Strategy 1

async function fetchFileTypes(array) { // Indicate the function as async
   return Promise.all(array.map(async (path) => { // Promise.all will wait for all mapped calls to be resolved
      try {
          const fileInfo = await fs.stat(path) // fs.stat is async
      } catch(e) {
          return null
      }
      return fileInfo.isFile() ? 'file' : 'directory';
   }));
}

Strategy 2: (Adjustments to original code)

const getFileTypes = array => {
  const promise = array.reduce((acc, path) => {
    acc
      .then(data => {
        return Promise.all([fs.stat(path), Promise.resolve(data)]);
      })
      .then(([fileInfo, data]) =>
        fileInfo.isFile()
          ? [Promise.resolve(data.push("file")), false]
          : [Promise.resolve(data.push("directory")), false]
      )
      .catch(() => Promise.resolve([data, true])) // so the next `then` can have access to data
      .then([data, failed] => failed === true ? Promise.resolve(data.push(null)) : Promsie.resolve(data)
  }, Promise.resolve([]));
  return promise;
};

Strategy 3: (Not resilient to faults. Promise.all will fail if an error occurs in any of the async calls):

function determineFileTypes(array) {
  const promises = array.map(fs.stat);
  return Promise.all(promises).then(stats =>
    stats.map(fileInfo => (fileInfo.isFile() ? "file" : "directory"))
  );
}

Strategy 4: (Making #3 slightly fault-tolerant)

const getFileType = fileInfo => fileInfo.isFile() ? 'file' : 'directory'
const fetchFileStat = path => fs.stat(path).then(getFileType).catch(() => null)
const determineFileTypes = paths => Promise.all(paths.map(fetchFileStat))

Answer 2

Strategy 1

async function fetchFileTypes(array) { // Indicate the function as async
   return Promise.all(array.map(async (path) => { // Promise.all will wait for all mapped calls to be resolved
      try {
          const fileInfo = await fs.stat(path) // fs.stat is async
      } catch(e) {
          return null
      }
      return fileInfo.isFile() ? 'file' : 'directory';
   }));
}

Strategy 2: (Adjustments to original code)

const getFileTypes = array => {
  const promise = array.reduce((acc, path) => {
    acc
      .then(data => {
        return Promise.all([fs.stat(path), Promise.resolve(data)]);
      })
      .then(([fileInfo, data]) =>
        fileInfo.isFile()
          ? [Promise.resolve(data.push("file")), false]
          : [Promise.resolve(data.push("directory")), false]
      )
      .catch(() => Promise.resolve([data, true])) // so the next `then` can have access to data
      .then([data, failed] => failed === true ? Promise.resolve(data.push(null)) : Promsie.resolve(data)
  }, Promise.resolve([]));
  return promise;
};

Strategy 3: (Not resilient to faults. Promise.all will fail if an error occurs in any of the async calls):

function determineFileTypes(array) {
  const promises = array.map(fs.stat);
  return Promise.all(promises).then(stats =>
    stats.map(fileInfo => (fileInfo.isFile() ? "file" : "directory"))
  );
}

Strategy 4: (Making #3 slightly fault-tolerant)

const getFileType = fileInfo => fileInfo.isFile() ? 'file' : 'directory'
const fetchFileStat = path => fs.stat(path).then(getFileType).catch(() => null)
const determineFileTypes = paths => Promise.all(paths.map(fetchFileStat))

Analyzing the list of paths that are passed to the function

Answer №1

Similar questions

Prevent the hiding of a select element with jQuery Chosen Select

Combining two react functions in a synchronized manner

Unable to locate any division element by using document.getElementById

Update the directive automatically whenever a change occurs in the root scope property

Storing input field values in JavaScript using the onchange event handler.Would you like a different revision

Swap out ASP.NET AJAX with jQuery for making ASHX requests

Challenges in Implementing Shadows with Animations in ThreeJS MeshDepthMaterial

The capacity to rotate div containers, adjust their dimensions, and engage with the content within

How can you proactively rebuild or update a particular page before the scheduled ISR time interval in Next.js?

How to dynamically change the position of an input field within a form using JavaScript and jQuery

An issue arose upon scanning the QR code for whatsapp-web.js, indicating a potential

Utilizing Jquery in the Customer Portal feature within the Salesforce platform

Is there a specific method for organizing cached buffer conversions in Node.js for optimal efficiency?

Switch up the position of an element every time the page is refreshed

Performing addition and subtraction calculations with HTML and Javascript

Having trouble persisting my login status in Selenium using Python

retrieving data from a php file using ajax for a post request

Tips for preventing repetition of code in multiple entry points in Rollup

How can I turn off autocomplete in MUI textfields?

Create queries for relays in a dynamic manner