La respuesta a esta pregunta ha cambiado con los años. La respuesta actual está aquí en la parte superior, seguida de varias respuestas a lo largo de los años en orden cronológico:
Respuesta actual
Puedes usar fs.existsSync():
const fs = require("fs"); // Or `import fs from "fs";` with ESM
if (fs.existsSync(path)) {
// Do something
}
Fue en desuso durante varios años, pero ya no lo es. De los documentos:
Tenga en cuenta que fs.exists()está en desuso, pero fs.existsSync()no lo está. (El parámetro de devolución de llamada para fs.exists()aceptar parámetros que son inconsistentes con otras devoluciones de llamada de Node.js. fs.existsSync()No utiliza una devolución de llamada).
Ha solicitado específicamente una verificación sincrónica , pero si puede usar una verificación asincrónica en su lugar (generalmente mejor con E / S), use fs.promises.accesssi está utilizando asyncfunciones o fs.access(dado que existsestá en desuso ) si no:
En una asyncfunción:
try {
await fs.promises.access("somefile");
// The check succeeded
} catch (error) {
// The check failed
}
O con una devolución de llamada:
fs.access("somefile", error => {
if (!error) {
// The check succeeded
} else {
// The check failed
}
});
Respuestas Históricas
Aquí están las respuestas históricas en orden cronológico:
- Respuesta original de 2010
( stat/ statSynco lstat/ lstatSync)
- Actualización de septiembre de 2012
( exists/ existsSync)
- Actualización de febrero de 2015
(teniendo en cuenta la inminente desaprobación de exists/ existsSync, por lo que probablemente volvamos a stat/ statSynco lstat/ lstatSync)
- Actualización de diciembre de 2015
(También hay fs.access(path, fs.F_OK, function(){})/ fs.accessSync(path, fs.F_OK), pero tenga en cuenta que si el archivo / directorio no existe, es un error; documentos para fs.statrecomendar usar fs.accesssi necesita verificar la existencia sin abrir)
- La actualización de diciembre de 2016
fs.exists() todavía está en desuso, pero fs.existsSync()ya no está en desuso. Para que pueda usarlo con seguridad ahora.
Respuesta original de 2010:
Puedes usar statSynco lstatSync( docs link ), que te da un fs.Statsobjeto . En general, si una versión síncrona de una función está disponible, tendrá el mismo nombre que la versión asíncrona con Syncal final. Así statSynces la versión sincrónica de stat; lstatSynces la versión sincrónica de lstat, etc.
lstatSync le informa a ambos si algo existe y, de ser así, si se trata de un archivo o un directorio (o en algunos sistemas de archivos, un enlace simbólico, un dispositivo de bloque, un dispositivo de caracteres, etc.), por ejemplo, si necesita saber si existe y si existe un directorio:
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) {
// ...
}
... y de manera similar, si es un archivo, hay isFile; si es un dispositivo de bloque, hay isBlockDevice, etc., etc. Tenga en cuenta que try/catch; arroja un error si la entrada no existe en absoluto.
Si no le importa lo que la entrada es y sólo quiere saber si es que existe, puede utilizar path.existsSync(o con la última, fs.existsSync) como se ha señalado por user618408 :
var path = require('path');
if (path.existsSync("/the/path")) { // or fs.existsSync
// ...
}
No requiere un try/catchpero no le da información sobre qué es la cosa, solo que está allí. path.existsSyncfue en desuso hace mucho tiempo.
Nota al margen: Usted ha preguntado expresamente cómo verificar sincrónicamente , por lo que he usado las xyzSyncversiones de las funciones anteriores. Pero siempre que sea posible, con E / S, lo mejor es evitar las llamadas sincrónicas. Las llamadas al subsistema de E / S toman un tiempo considerable desde el punto de vista de una CPU. Tenga en cuenta lo fácil que es llamar en lstatlugar de lstatSync:
// Is it a directory?
lstat('/the/path', function(err, stats) {
if (!err && stats.isDirectory()) {
// Yes it is
}
});
Pero si necesita la versión sincrónica, está ahí.
Actualización de septiembre de 2012
La siguiente respuesta de hace un par de años ahora está un poco desactualizada. La forma actual es usar fs.existsSyncpara hacer una verificación sincrónica de la existencia de un archivo / directorio (o, por supuesto, fs.existspara una verificación asincrónica), en lugar de las pathversiones a continuación.
Ejemplo:
var fs = require('fs');
if (fs.existsSync(path)) {
// Do something
}
// Or
fs.exists(path, function(exists) {
if (exists) {
// Do something
}
});
Actualización febrero 2015
Y aquí estamos en 2015 y los documentos del Nodo ahora dicen que fs.existsSync(y fs.exists) "quedarán en desuso". (Debido a que la gente del Nodo piensa que es tonto verificar si algo existe antes de abrirlo, lo cual es; ¡pero esa no es la única razón para verificar si algo existe!)
Así que probablemente volvamos a los diversos statmétodos ... Hasta / a menos que esto cambie una vez más, por supuesto.
Actualización de diciembre de 2015
No sé cuánto tiempo lleva allí, pero también hay fs.access(path, fs.F_OK, ...)/fs.accessSync(path, fs.F_OK) . Y al menos a partir de octubre de 2016, la fs.statdocumentación recomienda usar fs.accesspara hacer verificaciones de existencia ( " fs.access()Se recomienda verificar si un archivo existe sin manipularlo después " ). Pero tenga en cuenta que el acceso que no está disponible se considera un error , por lo que probablemente sea mejor si espera que el archivo sea accesible:
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
}
});
Actualización de diciembre de 2016
Puedes usar fs.existsSync():
if (fs.existsSync(path)) {
// Do something
}
Fue en desuso durante varios años, pero ya no lo es. De los documentos:
Tenga en cuenta que fs.exists()está en desuso, pero fs.existsSync()no lo está. (El parámetro de devolución de llamada para fs.exists()aceptar parámetros que son inconsistentes con otras devoluciones de llamada de Node.js. fs.existsSync()No utiliza una devolución de llamada).