Node.js comment attendre un appel asynchrone (readdir et stat)

Le moyen le plus simple et le plus propre serait d'utiliser await / async , de cette façon vous pouvez utiliser les promesses et le code ressemblera presque à du code synchrone.

Vous avez donc besoin d'une version promis de readdir et stat qui peut être créée par le promisify de la bibliothèque principale utils .

const { promisify } = require('util')

const readdir = promisify(require('fs').readdir)
const stat = promisify(require('fs').stat)

async function getPathContent(newPath) {
  // move pathContent otherwise can have conflicts with concurrent requests
  const pathContent = [];

  let files = await readdir(newPath)

  let pathName = newPath;
  // pathContent.length = 0;  // not needed anymore because pathContent is new for each request

  const absPath = path.resolve(pathName);

  // iterate each file

  // replace forEach with (for ... of) because this makes it easier 
  // to work with "async" 
  // otherwise you would need to use files.map and Promise.all
  for (let file of files) {
    // get file info and store in pathContent
    try {
      let stats = await stat(absPath + '/' + file)
      if (stats.isFile()) {
        pathContent.push({
          path: pathName,
          name: file.substring(0, file.lastIndexOf('.')),
          type: file.substring(file.lastIndexOf('.') + 1).concat(' File'),
        })
      } else if (stats.isDirectory()) {
        pathContent.push({
          path: pathName,
          name: file,
          type: 'Directory',
        });
      }
    } catch (err) {
      console.log(`${err}`);
    }
  }

  return pathContent;
}

app.post('/api/files', (req, res, next) => {
  const newPath = req.body.path;
  getPathContent(newPath).then((pathContent) => {
    res.json(pathContent);
  }, (err) => {
    res.status(422).json({
      message: `${err}`
    });
  })
})

Et vous ne devez pas concaténer les chemins en utilisant + ( absPath + '/' + file ), utilisez path.join (absPath, file) ou path.resolve (absPath, file) à la place.

Et vous ne devriez jamais écrire votre code d'une manière qui le code exécuté pour la requête, relais sur des variables globales comme var pathName = ''; et const pathContent = []; . Cela peut fonctionner dans votre environnement de test, mais entraînera certainement des problèmes en production. Où deux requêtes travaillent sur la variable en "même temps"

Voici quelques options:

• Utilisez les méthodes de fichiers synchrones (consultez la documentation, mais elles se terminent généralement par Sync ). Plus lent, mais un changement de code assez simple et très facile à comprendre.
• Utilisez des promesses (ou util.promisify ) pour créer une promesse pour chaque statistique, et Promise.all pour attendre que toutes les statistiques soient terminées. Après cela, vous pouvez utiliser les fonctions asynchrones et attendre également pour un code plus facile à lire et une gestion des erreurs plus simple. (Probablement le changement de code le plus important, mais il rendra le code asynchrone plus facile à suivre)
• Gardez un compteur du nombre de statistiques que vous avez effectuées, et si ce nombre est de la taille que vous attendez, appelez le formulaire res.json dans le rappel de statistiques (plus petit changement de code, mais très erreur enclin)

Il existe différentes manières de procéder:

1. Vous pouvez d'abord promettre la fonction en utilisant new Promise () puis ensuite, utiliser async / await ou .then ()
2. Vous pouvez utiliser la fonction ProsifyAll () du package Bluebird ( https: //www.npmjs. com / package / bluebird )
3. Vous pouvez utiliser la version synchrone des fonctions fs
   • https://nodejs.org/api/fs.html#fs_fs_readdirsync_path_options
   • https://nodejs.org/api/fs.html#fs_fs_statsync_path_options

Sur la base du commentaire initial que j'ai reçu et de la référence, j'ai utilisé readdirSync et statSync à la place et j'ai pu le faire fonctionner. J'examinerai également d'autres réponses et j'apprendrai d'autres façons de mettre en œuvre cela.

Merci à tous pour vos aimables contributions.

Voici ma solution.

const express = require('express');
const bodyParser = require('body-parser');
const fs = require('fs');
const path = require('path');

var pathName = '';
const pathContent = [];

app.post('/api/files', (req, res) => {
    const newPath = req.body.path;

    // validate path
    let files;
    try {
        files = fs.readdirSync(newPath);
    } catch (err) {
        res.status(422).json({ message: `${err}` });
        return;
    }

    // set the pathName and empty pathContent
    pathName = newPath;
    pathContent.length = 0;

    // iterate each file
    let absPath = path.resolve(pathName);
    files.forEach(file => {
        // get file info and store in pathContent
        let fileStat = fs.statSync(absPath + '/' + file);
        if (fileStat.isFile()) {
            pathContent.push({
                path: pathName,
                name: file.substring(0, file.lastIndexOf('.')),
                type: file.substring(file.lastIndexOf('.') + 1).concat(' File'),
            })
        } else if (fileStat.isDirectory()) {
            pathContent.push({
                path: pathName,
                name: file,
                type: 'Directory',
            });
        }
    });
    res.json(pathContent);
});