start - Archivo de verificación Node.js existente

node js server hosting

Question

¿Cómo verifico la existencia de un archivo ?

En la documentación para el módulo fs hay una descripción del método fs.exists(path, callback) . Pero, según tengo entendido, comprueba la existencia de solo directorios. ¡Y necesito verificar el archivo !

¿Cómo puede hacerse esto?

Answer 1

retrollamada vannilla Nodejs

function fileExists(path, cb){
  return fs.access(path, fs.constants.F_OK,(er, result)=> cb(!err && result)) //F_OK checks if file is visible, is default does no need to be specified.
}

los https://nodejs.org/api/fs.html#fs_fs_exists_path_callback dicen que debes usar access() como reemplazo de obsoletos exists()

Nodejs con build in promise (nodo 7+)

function fileExists(path, cb){
  return new Promise((accept,deny) => 
    fs.access(path, fs.constants.F_OK,(er, result)=> cb(!err && result))
  );
}

Marco de javascript popular

fs-extra

var fs = require(''fs-extra'')
await fs.pathExists(filepath)

Como ves mucho más simple. ¡Y la ventaja sobre promisificar es que tienes typings completos con este paquete (intellisense / mecanografiado completo)! La mayoría de los casos ya habrá incluido esta biblioteca porque (+ -10.000) otras bibliotecas dependen de ella.

Answer 2

¿Por qué no intenta abrir el archivo? fs.open(''YourFile'', ''a'', function (err, fd) { ... }) después de una búsqueda de un minuto, intente esto:

var path = require(''path''); 

path.exists(''foo.txt'', function(exists) { 
  if (exists) { 
    // do something 
  } 
}); 

// or 

if (path.existsSync(''foo.txt'')) { 
  // do something 
} 

Para Node.js v0.12.x y superior

Tanto path.exists como fs.exists han quedado en desuso

Usando fs.stat:

fs.stat(''foo.txt'', function(err, stat) {
    if(err == null) {
        console.log(''File exists'');
    } else if(err.code == ''ENOENT'') {
        // file does not exist
        fs.writeFile(''log.txt'', ''Some log/n'');
    } else {
        console.log(''Some other error: '', err.code);
    }
});

Answer 3

@Fox: ¡excelente respuesta! Aquí hay un poco de una extensión con algunas opciones más. Es lo que he estado usando últimamente como una solución de acceso:

var fs = require(''fs'');

fs.lstat( targetPath, function (err, inodeStatus) {
  if (err) {

    // file does not exist-
    if (err.code === ''ENOENT'' ) {
      console.log(''No file or directory at'',targetPath);
      return;
    }

    // miscellaneous error (e.g. permissions)
    console.error(err);
    return;
  }


  // Check if this is a file or directory
  var isDirectory = inodeStatus.isDirectory();


  // Get file size
  //
  // NOTE: this won''t work recursively for directories-- see:
  // http://.com/a/7550430/486547
  //
  var sizeInBytes = inodeStatus.size;

  console.log(
    (isDirectory ? ''Folder'' : ''File''),
    ''at'',targetPath,
    ''is'',sizeInBytes,''bytes.''
  );


}

PD: revisa fs-extra si aún no lo estás usando, es bastante dulce. https://github.com/jprichardson/node-fs-extra )

Answer 4

Bueno, lo hice de esta manera, como se ve en fs.access(...)

fs.access(''./settings'', fs.constants.F_OK | fs.constants.R_OK | fs.constants.W_OK, function(err){
  console.log(err ? ''no access or dir doesnt exist'' : ''R/W ok'');

  if(err && err.code === ''ENOENT''){
    fs.mkdir(''settings'');
  }
});

hay algun problema con esto?

Answer 5

De la nodejs.org/api/fs.html#fs_fs_stat_path_callback node.js:

No se recomienda usar fs.stat () para verificar la existencia de un archivo antes de llamar a fs.open (), fs.readFile () o fs.writeFile (). En cambio, el código de usuario debe abrir / leer / escribir el archivo directamente y manejar el error que se genera si el archivo no está disponible.

Para verificar si existe un archivo sin manipularlo después, se recomienda fs.access ().

Answer 6

Después de un poco de experimentación, encontré el siguiente ejemplo usando fs.stat como una buena forma de verificar asincrónicamente si existe un archivo. También verifica que su "archivo" sea "realmente-es-un-archivo" (y no un directorio).

Este método utiliza Promises, suponiendo que está trabajando con una base de código asincrónica:

const fileExists = path => {
  return new Promise((resolve, reject) => {
    try {
      fs.stat(path, (error, file) => {
        if (!error && file.isFile()) {
          return resolve(true);
        }

        if (error && error.code === ''ENOENT'') {
          return resolve(false);
        }
      });
    } catch (err) {
      reject(err);
    }
  });
};

Si el archivo no existe, la promesa aún se resuelve, aunque sea false . Si el archivo existe, y es un directorio, entonces se resuelve true . Cualquier error que intente leer el archivo reject la promesa del error en sí.

Answer 7

Hay muchos comentarios inexactos sobre fs.existsSync() desuso; no lo es.

nodejs.org/api/fs.html#fs_fs_existssync_path

Tenga en cuenta que fs.exists () está en desuso, pero fs.existsSync () no lo es.

Answer 8

Puede usar fs.stat para verificar si el objetivo es un archivo o directorio y puede usar fs.access para verificar si puede escribir / leer / ejecutar el archivo. (recuerde utilizar path.resolve para obtener la ruta completa para el destino)

Documentación:

• path.resolve
• nodejs.org/api/fs.html#fs_fs_stat_path_callback
• fs.access(...)

Ejemplo completo (TypeScript)

import * as fs from ''fs'';
import * as path from ''path'';

const targetPath = path.resolve(process.argv[2]);

function statExists(checkPath): Promise<fs.Stats> {
  return new Promise((resolve) => {
    fs.stat(checkPath, (err, result) => {
      if (err) {
        return resolve(undefined);
      }

      return resolve(result);
    });
  });
}

function checkAccess(checkPath: string, mode: number = fs.constants.F_OK): Promise<boolean> {
  return new Promise((resolve) => {
    fs.access(checkPath, mode, (err) => {
      resolve(!err);
    });
  });
}

(async function () {
  const result = await statExists(targetPath);
  const accessResult = await checkAccess(targetPath, fs.constants.F_OK);
  const readResult = await checkAccess(targetPath, fs.constants.R_OK);
  const writeResult = await checkAccess(targetPath, fs.constants.W_OK);
  const executeResult = await checkAccess(targetPath, fs.constants.X_OK);
  const allAccessResult = await checkAccess(targetPath, fs.constants.F_OK | fs.constants.R_OK | fs.constants.W_OK | fs.constants.X_OK);

  if (result) {
    console.group(''stat'');
    console.log(''isFile: '', result.isFile());
    console.log(''isDir: '', result.isDirectory());
    console.groupEnd();
  }
  else {
    console.log(''file/dir does not exist'');
  }

  console.group(''access'');
  console.log(''access:'', accessResult);
  console.log(''read access:'', readResult);
  console.log(''write access:'', writeResult);
  console.log(''execute access:'', executeResult);
  console.log(''all (combined) access:'', allAccessResult);
  console.groupEnd();

  process.exit(0);
}());

Answer 9

Una alternativa para stat podría estar usando el nuevo fs.access(...) :

Función de promesa corta minimizada para verificar:

s => new Promise(r=>fs.access(s, fs.F_OK, e => r(!e)))

Uso de muestra:

let checkFileExists = s => new Promise(r=>fs.access(s, fs.F_OK, e => r(!e)))
checkFileExists("Some File Location")
  .then(bool => console.log(´file exists: ${bool}´))

Promesa ampliada:

// returns a promise which resolves true if file exists:
function checkFileExists(filepath){
  return new Promise((resolve, reject) => {
    fs.access(filepath, fs.F_OK, error => {
      resolve(!error);
    });
  });
}

o si quieres hacerlo sincrónicamente:

function checkFileExistsSync(filepath){
  let flag = true;
  try{
    fs.accessSync(filepath, fs.F_OK);
  }catch(e){
    flag = false;
  }
  return flag;
}

Answer 10

Una forma más fácil de hacer esto sincrónicamente.

if (fs.existsSync(''/etc/file'')) {
    console.log(''Found file'');
}

El documento de API dice cómo funcionaSync:
Compruebe si la ruta de acceso dada existe o no mediante la comprobación con el sistema de archivos.

Answer 11

Versión async/await util.promisify utilizando util.promisify partir del Nodo 8:

const fs = require(''fs'');
const { promisify } = require(''util'');
const stat = promisify(fs.stat);

describe(''async stat'', () => {
  it(''should not throw if file does exist'', async () => {
    try {
      const stats = await stat(path.join(''path'', ''to'', ''existingfile.txt''));
      assert.notEqual(stats, null);
    } catch (err) {
      // shouldn''t happen
    }
  });
});

describe(''async stat'', () => {
  it(''should throw if file does not exist'', async () => {
    try {
      const stats = await stat(path.join(''path'', ''to'', ''not'', ''existingfile.txt''));
    } catch (err) {
      assert.notEqual(err, null);
    }
  });
});

Answer 12

Versión anterior a V6: https://nodejs.org/api/fs.html#fs_fs_exists_path_callback

  const fs = require(''fs'');    
  fs.exists(''/etc/passwd'', (exists) => {
     console.log(exists ? ''it/'s there'' : ''no passwd!'');
  });
// or Sync

  if (fs.existsSync(''/etc/passwd'')) {
    console.log(''it/'s there'');
  }

ACTUALIZAR

Nuevas versiones de V6: nodejs.org/api/fs.html#fs_fs_stat_path_callback

fs.stat(''/etc/passwd'', function(err, stat) {
    if(err == null) {
        //Exist
    } else if(err.code == ''ENOENT'') {
        // NO exist
    } 
});

Answer 13

en los viejos tiempos, antes de sentarme, siempre controlo si la silla está allí, luego me siento; tengo otro plan alternativo, como sentarse en un autocar. Ahora el sitio node.js sugiere simplemente ir (no es necesario verificarlo) y la respuesta es así:

    fs.readFile( ''/foo.txt'', function( err, data )
    {
      if(err) 
      {
        if( err.code === ''ENOENT'' )
        {
            console.log( ''File Doesn/'t Exist'' );
            return;
        }
        if( err.code === ''EACCES'' )
        {
            console.log( ''No Permission'' );
            return;
        }       
        console.log( ''Unknown Error'' );
        return;
      }
      console.log( data );
    } );

código tomado de http://fredkschott.com/post/2014/03/understanding-error-first-callbacks-in-node-js/ de marzo de 2014, y ligeramente modificado para adaptarse a la computadora. También verifica el permiso: quite el permiso para probar chmod ar foo.txt

Answer 14

fs.exists(path, callback) y fs.existsSync(path) están en desuso ahora, consulte https://nodejs.org/api/fs.html#fs_fs_exists_path_callback y nodejs.org/api/fs.html#fs_fs_existssync_path .

Para probar la existencia de un archivo sincrónicamente uno puede usar, es decir. fs.statSync(path) . Se fs.Stats objeto fs.Stats si el archivo existe, consulte https://nodejs.org/api/fs.html#fs_class_fs_stats ; de lo contrario, se generará un error que será atrapado por la declaración try / catch.

var fs = require(''fs''),
  path = ''/path/to/my/file'',
  stats;

try {
  stats = fs.statSync(path);
  console.log("File exists.");
}
catch (e) {
  console.log("File does not exist.");
}

Answer 15

fs.exists ha quedado en desuso desde 1.0.0. Puede usar fs.stat lugar de eso.

var fs = require(''fs'');
fs.stat(path, (err, stats) => {
if ( !stats.isFile(filename) ) { // do this 
}  
else { // do this 
}});

Aquí está el enlace para la documentación nodejs.org/api/fs.html#fs_fs_stat_path_callback

Answer 16

  fs.statSync(path, function(err, stat){
      if(err == null) {
          console.log(''File exists'');
          //code when all ok
      }else if (err.code == "ENOENT") {
        //file doesn''t exist
        console.log(''not file'');

      }
      else {
        console.log(''Some other error: '', err.code);
      }
    });