Como capturar nenhum arquivo para fs.readFileSync ()?

No node.js, readFile () mostra como capturar um erro, no entanto, não há comentários para a função readFileSync () em relação à manipulação de erros. Sendo assim, se eu tentar usar o readFileSync () quando não houver arquivo, recebo o erro Error: ENOENT, no such file or directory.

Como capturar a exceção que está sendo lançada? O documento não declara quais exceções são lançadas, então não sei quais exceções preciso capturar. Devo observar que não gosto do estilo genérico de 'pegar todas as exceções possíveis' das instruções try / catch. Nesse caso, desejo capturar a exceção específica que ocorre quando o arquivo não existe e tento executar o readFileSync.

Observe que eu estou executando funções de sincronização apenas na inicialização antes de servir as tentativas de conexão, portanto, comentários que eu não deveria estar usando funções de sincronização não são necessários :-)

Basicamente, fs.readFileSyncgera um erro quando um arquivo não é encontrado. Este erro é do Errorprotótipo e lançado usando throw, portanto, a única maneira de capturar é com um try / catchbloco:

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
}

Infelizmente, você não pode detectar qual erro foi lançado apenas observando sua cadeia de protótipos:

if (err instanceof Error)

é o melhor que você pode fazer, e isso será verdade para a maioria (se não todos) dos erros. Por isso, sugiro que você vá com a codepropriedade e verifique seu valor:

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

Dessa forma, você lida apenas com esse erro específico e lança novamente todos os outros erros.

Como alternativa, você também pode acessar a messagepropriedade do erro para verificar a mensagem de erro detalhada, que neste caso é:

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

Espero que isto ajude.

Eu prefiro essa maneira de lidar com isso. Você pode verificar se o arquivo existe de forma síncrona:

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');
}

Nota: se o seu programa também excluir arquivos, isso terá uma condição de corrida, conforme observado nos comentários. Se, no entanto, você apenas escreve ou sobrescreve arquivos, sem excluí-los, isso é ótimo.

Você precisa capturar o erro e depois verificar que tipo de erro é esse.

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
}

Eu uso um lambda chamado imediatamente para estes cenários:

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

async versão:

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

Tente usar o Async para evitar o bloqueio do único thread que você possui com o NodeJS. Veja este exemplo:

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;
}

Mais tarde, pode usar esta função assíncrona com try / catch de qualquer outra função:

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
  }
}

Feliz codificação!

O mecanismo try… catch do JavaScript não pode ser usado para interceptar erros gerados por APIs assíncronas. Um erro comum para iniciantes é tentar usar throw dentro de um retorno de chamada com erro:

// 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);
}

Isso não funcionará porque a função de retorno de chamada passada para fs.readFile () é chamada de forma assíncrona. Quando o retorno de chamada foi chamado, o código circundante, incluindo o bloco try ... catch, já havia saído. Lançar um erro dentro do retorno de chamada pode travar o processo Node.js. na maioria dos casos. Se os domínios estiverem ativados ou um manipulador tiver sido registrado com process.on ('uncaughtException'), esses erros poderão ser interceptados.

referência: https://nodejs.org/api/errors.html