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);
}
});