La risposta a questa domanda è cambiata nel corso degli anni. La risposta attuale è qui in alto, seguita dalle varie risposte nel corso degli anni in ordine cronologico:
Risposta attuale
Puoi usare fs.existsSync():
const fs = require("fs"); // Or `import fs from "fs";` with ESM
if (fs.existsSync(path)) {
// Do something
}
È stato deprecato per diversi anni, ma non lo è più. Dai documenti:
Si noti che fs.exists()è deprecato, ma fs.existsSync()non lo è. (Il parametro callback per fs.exists()accettare parametri incoerenti con altri callback Node.js. fs.existsSync()Non utilizza un callback.)
Hai richiesto specificamente un controllo sincrono , ma se invece puoi utilizzare un controllo asincrono (di solito meglio con I / O), usa fs.promises.accessse stai usando asyncfunzioni o fs.access(dato che existsè deprecato ) in caso contrario:
In una asyncfunzione:
try {
await fs.promises.access("somefile");
// The check succeeded
} catch (error) {
// The check failed
}
O con un callback:
fs.access("somefile", error => {
if (!error) {
// The check succeeded
} else {
// The check failed
}
});
Risposte storiche
Ecco le risposte storiche in ordine cronologico:
- Risposta originale del 2010
( stat/ statSynco lstat/ lstatSync)
- Aggiornamento settembre 2012
( exists/ existsSync)
- Aggiornamento febbraio 2015
(rilevando l'imminente deprezzamento di exists/ existsSync, quindi probabilmente torniamo a stat/ statSynco lstat/ lstatSync)
- Aggiornamento dicembre 2015
(c'è anche fs.access(path, fs.F_OK, function(){})/ fs.accessSync(path, fs.F_OK), ma nota che se il file / directory non esiste, è un errore; documenti da fs.statutilizzare fs.accessse è necessario verificare l'esistenza senza aprirla)
- L'aggiornamento di dicembre 2016
fs.exists() è ancora obsoleto ma fs.existsSync()non è più obsoleto. Quindi puoi usarlo tranquillamente ora.
Risposta originale del 2010:
Puoi usare statSynco lstatSync( link docs ), che ti dà un fs.Statsoggetto . In generale, se è disponibile una versione sincrona di una funzione, avrà lo stesso nome della versione asincrona con Syncalla fine. Così statSyncè la versione sincrona di stat; lstatSyncè la versione sincrona di lstat, ecc.
lstatSync ti dice se esiste qualcosa e, in tal caso, se si tratta di un file o di una directory (o in alcuni file system, un collegamento simbolico, un dispositivo a blocchi, un dispositivo a caratteri, ecc.), ad esempio se devi sapere se esiste e lo è una directory:
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 similmente, se è un file, c'è isFile; se è un dispositivo a blocchi, c'è isBlockDevice, ecc. ecc. Nota il try/catch; genera un errore se la voce non esiste affatto.
Se non vi interessa ciò che la voce è solo vuole sapere se esiste, è possibile utilizzare path.existsSync(o con l'ultima, fs.existsSync), come notato da user618408 :
var path = require('path');
if (path.existsSync("/the/path")) { // or fs.existsSync
// ...
}
Non richiede un try/catchma non ti dà informazioni su cosa sia, solo che è lì. path.existsSyncè stato deprecato molto tempo fa.
Nota a margine: hai chiesto espressamente come verificare in modo sincrono , quindi ho usato le xyzSyncversioni delle funzioni sopra. Ma dove possibile, con l'I / O, è davvero meglio evitare chiamate sincrone. Le chiamate nel sottosistema I / O richiedono molto tempo dal punto di vista della CPU. Nota quanto è facile chiamare lstatpiuttosto che lstatSync:
// Is it a directory?
lstat('/the/path', function(err, stats) {
if (!err && stats.isDirectory()) {
// Yes it is
}
});
Ma se hai bisogno della versione sincrona, è lì.
Aggiornamento settembre 2012
La risposta di seguito di un paio di anni fa è ora un po 'obsoleta. Il modo attuale è quello di usare fs.existsSyncun controllo sincrono per l'esistenza di file / directory (o ovviamente fs.existsper un controllo asincrono), piuttosto che le pathversioni sottostanti.
Esempio:
var fs = require('fs');
if (fs.existsSync(path)) {
// Do something
}
// Or
fs.exists(path, function(exists) {
if (exists) {
// Do something
}
});
Aggiornamento febbraio 2015
Ed eccoci nel 2015 e i documenti di Node ora dicono che fs.existsSync(e fs.exists) "saranno deprecati". (Perché la gente del Nodo pensa che sia stupido controllare se esiste qualcosa prima di aprirlo, ma non è l'unica ragione per verificare se esiste qualcosa!)
Quindi probabilmente torniamo ai vari statmetodi ... Fino a / a meno che questo non cambi ancora, naturalmente.
Aggiornamento dicembre 2015
Non so da quanto tempo è lì, ma c'è anche fs.access(path, fs.F_OK, ...)/fs.accessSync(path, fs.F_OK) . E almeno a partire da ottobre 2016, la fs.statdocumentazione consiglia di utilizzare fs.accessper eseguire controlli di esistenza ( "Per verificare se esiste un file senza manipolarlo in seguito, fs.access()si consiglia." ). Ma tieni presente che l'accesso non disponibile è considerato un errore , quindi questo sarebbe probabilmente il migliore se ti aspetti che il file sia accessibile:
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
}
});
Aggiornamento dicembre 2016
Puoi usare fs.existsSync():
if (fs.existsSync(path)) {
// Do something
}
È stato deprecato per diversi anni, ma non lo è più. Dai documenti:
Si noti che fs.exists()è deprecato, ma fs.existsSync()non lo è. (Il parametro callback per fs.exists()accettare parametri incoerenti con altri callback Node.js. fs.existsSync()Non utilizza un callback.)