Pregunta Verifique sincrónicamente si el archivo / directorio existe en Node.js


¿Cómo puedo verificar sincrónicamente, usando node.js, si existe un archivo o directorio?


825
2017-12-19 11:19


origen


Respuestas:


La respuesta a esta pregunta ha cambiado a lo largo de los años. los corriente la respuesta está aquí en la parte superior, seguida de las diversas respuestas a lo largo de los años en orden cronológico:

Respuesta actual

Puedes usar fs.existsSync():

var fs = require('fs');
if (fs.existsSync(path)) {
    // Do something
}

Fue desaprobado 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 es. (Los   parámetro de devolución de llamada a fs.exists() acepta parámetros que son   inconsistente con otras devoluciones de llamada de Node.js. fs.existsSync() no   usa una devolución de llamada).

Has pedido específicamente un sincrónico verificar, pero si puedes usar un asincrónico verifique en su lugar (usualmente mejor con E / S), use fs.access (ya que exists es obsoleto).


Respuestas históricas

Aquí están las respuestas históricas en orden cronológico:

  • Respuesta original de 2010
    (stat/statSync o lstat/lstatSync)
  • Actualización de septiembre de 2012
    (exists/existsSync)
  • Actualización febrero de 2015
    (Observando la desaprobación inminente de exists/existsSync, entonces probablemente volvamos a stat/statSync o lstat/lstatSync)
  • Actualización 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.stat recomendar el uso fs.access si necesita verificar la existencia sin abrir)
  • Actualización diciembre de 2016
    fs.exists() todavía está en desuso, pero fs.existsSync() ya no está en desuso. Entonces puedes usarlo ahora con seguridad.

Respuesta original de 2010:

Puedes usar statSync o lstatSync (enlace a documentos), que te dan un fs.Stats objeto. En general, si una versión síncrona de una función está disponible, tendrá el mismo nombre que la versión asincrónica con Sync al final. Asi que statSync es la versión síncrona de stat; lstatSync es la versión síncrona de lstat, etc.

lstatSync les dice a ambos si existe algo, y si es así, si es un archivo o un directorio (o en algunos sistemas de archivos, un enlace simbólico, dispositivo de bloque, dispositivo de caracteres, etc.), p. si necesita saber si existe y es 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 del mismo modo si es un archivo, hay isFile; si es un dispositivo de bloque, hay isBlockDevice, etc., etc. Tenga en cuenta try/catch; arroja un error si la entrada no existe.

Si no te importa cuál es la entrada es y solo quiero saber si existe, puedes usar path.existsSync (o con lo último, fs.existsSync) como observado por user618408:

var path = require('path');
if (path.existsSync("/the/path")) { // or fs.existsSync
    // ...
}

No requiere una try/catch, pero no le da información sobre lo que es, solo que está allí.


1613
2017-12-19 11:26



Mirando la fuente, hay una versión sincrónica de path.exists - path.existsSync. Parece que se perdió en los documentos.

Actualizar:

path.exists y path.existsSync son ahora obsoleto. Por favor use fs.exists y fs.existsSync.

Actualización 2016:

fs.exists y fs.existsSync también tienen estado en desuso. Utilizar fs.stat () o fs.access ()en lugar.


114
2018-02-15 19:05



Usando las API actualmente recomendadas (a partir de 2015) (según los documentos del nodo), esto es lo que hago:

var fs = require('fs');

function fileExists(filePath)
{
    try
    {
        return fs.statSync(filePath).isFile();
    }
    catch (err)
    {
        return false;
    }
}

En respuesta al problema de EPERM planteado por @broadband en los comentarios, esto trae a colación un buen punto. fileExists () probablemente no sea una buena manera de pensar sobre esto en muchos casos, porque fileExists () realmente no puede prometer un retorno booleano. Es posible que pueda determinar definitivamente si el archivo existe o no existe, pero también puede obtener un error de permisos. El error de permisos no implica necesariamente que el archivo exista, ya que podría carecer de permiso para el directorio que contiene el archivo que está verificando. Y, por supuesto, existe la posibilidad de que pueda encontrar algún otro error al verificar la existencia del archivo.

Así que mi código anterior es realmente doesFileExistAndDoIHaveAccessToIt (), pero tu pregunta podría ser doesFileNotExistAndCouldICreateIt (), que sería una lógica completamente diferente (que necesitaría explicar un error de EPERM, entre otras cosas).

Si bien la respuesta fs.existsSync responde directamente a la pregunta que se hace aquí, a menudo no va a ser lo que desea (no solo quiere saber si existe "algo" en un camino, probablemente le importe si el "objeto" que existe es un archivo o un directorio).

La conclusión es que si está comprobando si existe un archivo, probablemente lo haga porque tiene la intención de tomar alguna medida basada en el resultado, y esa lógica (el cheque y / o la acción subsiguiente) debe acomodar la idea que una cosa encontrada en esa ruta puede ser un archivo o un directorio, y que puede encontrarse con EPERM u otros errores en el proceso de comprobación.


50
2017-09-23 21:12



Otra actualización

Necesito una respuesta a esta pregunta yo mismo miré los documentos del nodo, parece que debería no utilice fs.exists, en su lugar use fs.open y use el error generado para detectar si un archivo no existe:

de los documentos:

fs.exists () es un anacronismo y existe solo por razones históricas.   Casi nunca debería haber una razón para usarlo en su propio código.

En particular, verificar si existe un archivo antes de abrirlo es una   anti-patrón que te deja vulnerable a las condiciones de carrera: otro   proceso puede eliminar el archivo entre las llamadas a fs.exists () y   fs.open (). Simplemente abra el archivo y maneje el error cuando no sea   ahí.

http://nodejs.org/api/fs.html#fs_fs_exists_path_callback


19
2018-06-07 04:13



Uso la función de abajo para probar si el archivo existe. Captura también otras excepciones. Entonces, en caso de que haya problemas de derechos, p. chmod ugo-rwx filename o en Windows Right Click -> Properties -> Security -> Advanced -> Permission entries: empty list .. la función devuelve la excepción como debería. El archivo existe pero no tenemos derechos para acceder a él. Sería un error ignorar este tipo de excepciones.

function fileExists(path) {

  try  {
    return fs.statSync(path).isFile();
  }
  catch (e) {

    if (e.code == 'ENOENT') { // no such file or directory. File really does not exist
      console.log("File does not exist.");
      return false;
    }

    console.log("Exception fs.statSync (" + path + "): " + e);
    throw e; // something else went wrong, we don't have rights, ...
  }
}

Salida de excepción documentación de errores nodejs en caso de que el archivo no exista:

{
  [Error: ENOENT: no such file or directory, stat 'X:\\delsdfsdf.txt']
  errno: -4058,
  code: 'ENOENT',
  syscall: 'stat',
  path: 'X:\\delsdfsdf.txt'
}

Excepción en caso de que no tengamos derechos sobre el archivo, pero existe:

{
  [Error: EPERM: operation not permitted, stat 'X:\file.txt']
  errno: -4048,
  code: 'EPERM',
  syscall: 'stat',
  path: 'X:\\file.txt'
}

10
2018-01-26 14:37



fs.exists () está en desuso, no lo uses https://nodejs.org/api/fs.html#fs_fs_exists_path_callback

Usted podría implementar el nodo central usado de esta manera: https://github.com/nodejs/node-v0.x-archive/blob/master/lib/module.js#L86

function statPath(path) {
  try {
    return fs.statSync(path);
  } catch (ex) {}
  return false;
}

esto devolverá el objeto de estadísticas una vez que tengas el objeto de estadísticas que puedas probar

var exist = statPath('/path/to/your/file.js');
if(exist && exist.isFile()) {
  // do something
}

4
2017-07-28 06:53



Algunas respuestas aquí dicen que fs.exists y fs.existsSync Ambos están en desuso. De acuerdo con los documentos esto no es más cierto. Solamente fs.exists se depreció ahora:

Tenga en cuenta que fs.exists () está en desuso, pero fs.existsSync () no lo es. (Los   el parámetro de devolución de llamada a fs.exists () acepta parámetros que son   inconsistente con otras devoluciones de llamada de Node.js. fs.existsSync () no   usa una devolución de llamada).

Para que pueda usar de forma segura fs.existsSync () para verificar sincrónicamente si existe un archivo.


4
2017-12-04 09:02



los path módulo no proporciona una versión síncrona de path.exists entonces tienes que jugar con el fs módulo.

Lo más rápido que puedo imaginar es usar fs.realpathSync que arrojará un error que debe atrapar, por lo que debe crear su propia función de contenedor con un try / catch.


2
2017-12-19 11:32



El uso de las pruebas fileSystem (fs) desencadenará objetos de error, que luego tendría que ajustar en una instrucción try / catch. Ahórrese un poco de esfuerzo y use una función de introducción en la rama 0.4.x.

var path = require('path');

var dirs = ['one', 'two', 'three'];

dirs.map(function(dir) {
  path.exists(dir, function(exists) {
    var message = (exists) ? dir + ': is a directory' : dir + ': is not a directory';
    console.log(message);
  });
});

0
2018-03-26 14:01