Comment capturer aucun fichier pour fs.readFileSync ()?

Dans node.js readFile () montre comment capturer une erreur, cependant il n'y a pas de commentaire pour la fonction readFileSync () concernant la gestion des erreurs. En tant que tel, si j'essaye d'utiliser readFileSync () quand il n'y a pas de fichier, j'obtiens l'erreur Error: ENOENT, no such file or directory.

Comment capturer l'exception levée? Le doco n'indique pas quelles exceptions sont levées, donc je ne sais pas quelles exceptions je dois attraper. Je dois noter que je n'aime pas le style générique «attraper toutes les exceptions possibles» des instructions try / catch. Dans ce cas, je souhaite attraper l'exception spécifique qui se produit lorsque le fichier n'existe pas et que j'essaye d'effectuer le readFileSync.

Veuillez noter que j'effectue des fonctions de synchronisation uniquement au démarrage avant de servir les tentatives de connexion, donc les commentaires indiquant que je ne devrais pas utiliser les fonctions de synchronisation ne sont pas obligatoires :-)

Fondamentalement, fs.readFileSyncgénère une erreur lorsqu'un fichier n'est pas trouvé. Cette erreur provient du Errorprototype et est lancée à l'aide throw, par conséquent, le seul moyen d'attraper est avec un try / catchbloc:

var fileContents;
try {
  fileContents = fs.readFileSync('foo.bar');
} catch (err) {
  // Here you get the error when the file was not found,
  // but you also get any other error
}

Malheureusement, vous ne pouvez pas détecter quelle erreur a été générée simplement en regardant sa chaîne de prototypes:

if (err instanceof Error)

est le mieux que vous puissiez faire, et ce sera vrai pour la plupart (sinon toutes) des erreurs. Par conséquent, je vous suggère d'aller avec la codepropriété et de vérifier sa valeur:

if (err.code === 'ENOENT') {
  console.log('File not found!');
} else {
  throw err;
}

De cette façon, vous traitez uniquement cette erreur spécifique et relancez toutes les autres erreurs.

Vous pouvez également accéder à la messagepropriété de l'erreur pour vérifier le message d'erreur détaillé, qui dans ce cas est:

ENOENT, no such file or directory 'foo.bar'

J'espère que cela t'aides.

Je préfère cette façon de gérer cela. Vous pouvez vérifier si le fichier existe de manière synchrone:

var file = 'info.json';
var content = '';

// Check that the file exists locally
if(!fs.existsSync(file)) {
  console.log("File not found");
}

// The file *does* exist
else {
  // Read the file and do anything you want
  content = fs.readFileSync(file, 'utf-8');
}

Remarque: si votre programme supprime également des fichiers, cela a une condition de concurrence comme indiqué dans les commentaires. Si toutefois vous n'écrivez ou écrasez que des fichiers, sans les supprimer, alors c'est très bien.

Vous devez attraper l'erreur, puis vérifier de quel type d'erreur il s'agit.

try {
  var data = fs.readFileSync(...)
} catch (err) {
  // If the type is not what you want, then just throw the error again.
  if (err.code !== 'ENOENT') throw err;

  // Handle a file-not-found error
}

J'utilise un lambda immédiatement appelé pour ces scénarios:

const config = (() => {
  try {
    return JSON.parse(fs.readFileSync('config.json'));
  } catch (error) {
    return {};
  }
})();

async version:

const config = await (async () => {
  try {
    return JSON.parse(await fs.readFileAsync('config.json'));
  } catch (error) {
    return {};
  }
})();

Essayez plutôt d' utiliser Async pour éviter de bloquer le seul thread que vous avez avec NodeJS. Vérifiez cet exemple:

const util = require('util');
const fs = require('fs');
const path = require('path');
const readFileAsync = util.promisify(fs.readFile);

const readContentFile = async (filePath) => {
  // Eureka, you are using good code practices here!
  const content = await readFileAsync(path.join(__dirname, filePath), {
    encoding: 'utf8'
  })
  return content;
}

Plus tard, vous pouvez utiliser cette fonction asynchrone avec try / catch depuis n'importe quelle autre fonction:

const anyOtherFun = async () => {
  try {
    const fileContent = await readContentFile('my-file.txt');
  } catch (err) {
    // Here you get the error when the file was not found,
    // but you also get any other error
  }
}

Bon codage!

Le mécanisme JavaScript try… catch ne peut pas être utilisé pour intercepter les erreurs générées par les API asynchrones. Une erreur courante pour les débutants est d'essayer d'utiliser throw dans un rappel d'erreur en premier:

// THIS WILL NOT WORK:
const fs = require('fs');

try {
  fs.readFile('/some/file/that/does-not-exist', (err, data) => {
    // Mistaken assumption: throwing here...
    if (err) {
      throw err;
    }
  });
} catch (err) {
  // This will not catch the throw!
  console.error(err);
}

Cela ne fonctionnera pas car la fonction de rappel passée à fs.readFile () est appelée de manière asynchrone. Au moment où le rappel a été appelé, le code environnant, y compris le bloc try… catch, sera déjà sorti. Lancer une erreur dans le rappel peut faire planter le processus Node.js dans la plupart des cas. Si les domaines sont activés ou si un gestionnaire a été enregistré avec process.on ('uncaughtException'), ces erreurs peuvent être interceptées.

référence: https://nodejs.org/api/errors.html