A resposta a esta pergunta mudou ao longo dos anos. A resposta atual está aqui no topo, seguida pelas várias respostas ao longo dos anos em ordem cronológica:
Resposta Atual
Você pode usar fs.existsSync():
const fs = require("fs"); // Or `import fs from "fs";` with ESM
if (fs.existsSync(path)) {
// Do something
}
Foi preterido por vários anos, mas não é mais. Dos documentos:
Observe que fs.exists()está obsoleto, mas fs.existsSync()não está. (O parâmetro de retorno de chamada para fs.exists()aceita parâmetros inconsistentes com outros retornos de chamada do Node.js. fs.existsSync()não usa um retorno de chamada.)
Você solicitou especificamente uma verificação síncrona , mas se você pode usar uma verificação assíncrona (geralmente melhor com E / S), use fs.promises.accessse estiver usando asyncfunções ou fs.access(já que existsfoi preterido ) se não:
Em uma asyncfunção:
try {
await fs.promises.access("somefile");
// The check succeeded
} catch (error) {
// The check failed
}
Ou com um retorno de chamada:
fs.access("somefile", error => {
if (!error) {
// The check succeeded
} else {
// The check failed
}
});
Respostas Históricas
Aqui estão as respostas históricas em ordem cronológica:
- Resposta original de 2010
( stat/ statSyncou lstat/ lstatSync)
- Atualização de setembro de 2012
( exists/ existsSync)
- Atualização em fevereiro de 2015
(observando a obsolescência iminente de exists/ existsSync, portanto, provavelmente estamos de volta a stat/ statSyncou lstat/ lstatSync)
- Atualização em dezembro de 2015
(também há fs.access(path, fs.F_OK, function(){})/ fs.accessSync(path, fs.F_OK), mas observe que, se o arquivo / diretório não existir, será um erro; documentos para fs.statrecomendar o uso fs.accessse você precisar verificar a existência sem abrir)
- A atualização de dezembro de 2016
fs.exists() ainda está obsoleta, mas fs.existsSync()não está mais obsoleta. Então você pode usá-lo com segurança agora.
Resposta original de 2010:
Você pode usar statSyncor lstatSync( link do docs ), que fornece um fs.Statsobjeto . Em geral, se uma versão síncrona de uma função estiver disponível, ela terá o mesmo nome da versão assíncrona Syncno final. Assim statSyncé a versão síncrona de stat; lstatSyncé a versão síncrona de lstatetc.
lstatSync informa se existe algo e, em caso afirmativo, se é um arquivo ou um diretório (ou em alguns sistemas de arquivos, um link simbólico, um dispositivo de bloco, um dispositivo de caracteres etc.), por exemplo, se você precisa saber se existe ou não um diretório:
var fs = require('fs');
try {
// Query the entry
stats = fs.lstatSync('/the/path');
// Is it a directory?
if (stats.isDirectory()) {
// Yes it is
}
}
catch (e) {
// ...
}
... e da mesma forma, se é um arquivo, existe isFile; se é um dispositivo de bloco, há isBlockDevice, etc., etc. Observe o try/catch; gera um erro se a entrada não existir.
Se você não se importa que a entrada é e só quero saber se ele existe, você pode usar path.existsSync(ou com o mais recente, fs.existsSync) como observado por user618408 :
var path = require('path');
if (path.existsSync("/the/path")) { // or fs.existsSync
// ...
}
Não requer um, try/catchmas não fornece informações sobre o que é a coisa, apenas que está lá. path.existsSyncfoi preterido há muito tempo.
Nota lateral: Você perguntou expressamente como verificar de forma síncrona ; portanto, usei as xyzSyncversões das funções acima. Mas sempre que possível, com E / S, é realmente melhor evitar chamadas síncronas. As chamadas para o subsistema de E / S levam um tempo significativo do ponto de vista da CPU. Observe como é fácil ligar em lstatvez de lstatSync:
// Is it a directory?
lstat('/the/path', function(err, stats) {
if (!err && stats.isDirectory()) {
// Yes it is
}
});
Mas se você precisar da versão síncrona, ela estará lá.
Atualização setembro de 2012
A resposta abaixo de alguns anos atrás agora está um pouco desatualizada. A maneira atual é usar fs.existsSyncpara fazer uma verificação síncrona da existência de arquivo / diretório (ou, é claro, fs.existsde uma verificação assíncrona), em vez das pathversões abaixo.
Exemplo:
var fs = require('fs');
if (fs.existsSync(path)) {
// Do something
}
// Or
fs.exists(path, function(exists) {
if (exists) {
// Do something
}
});
Atualização de fevereiro de 2015
E aqui estamos em 2015 e os documentos do Node agora dizem que fs.existsSync(e fs.exists) "será preterido". (Como o pessoal do Nó acha que é estúpido verificar se existe algo antes de abri-lo, qual é; mas esse não é o único motivo para verificar se existe algo!)
Então, provavelmente estamos de volta aos vários statmétodos ... Até / a menos que isso mude novamente, é claro.
Atualização dezembro de 2015
Não sei há quanto tempo está lá, mas também há fs.access(path, fs.F_OK, ...)/fs.accessSync(path, fs.F_OK) . E, pelo menos a partir de outubro de 2016, a fs.statdocumentação recomenda o uso fs.accessde verificações de existência ( "Para verificar se existe um arquivo sem manipulá-lo posteriormente, fs.access()é recomendável." ). Mas observe que o acesso não disponível é considerado um erro ; portanto, provavelmente seria melhor se você espera que o arquivo seja acessível:
var fs = require('fs');
try {
fs.accessSync(path, fs.F_OK);
// Do something
} catch (e) {
// It isn't accessible
}
// Or
fs.access(path, fs.F_OK, function(err) {
if (!err) {
// Do something
} else {
// It isn't accessible
}
});
Atualização dezembro de 2016
Você pode usar fs.existsSync():
if (fs.existsSync(path)) {
// Do something
}
Foi preterido por vários anos, mas não é mais. Dos documentos:
Observe que fs.exists()está obsoleto, mas fs.existsSync()não está. (O parâmetro de retorno de chamada para fs.exists()aceita parâmetros inconsistentes com outros retornos de chamada do Node.js. fs.existsSync()não usa um retorno de chamada.)