Un moyen plus facile de le faire de manière synchrone.

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

Le document API indique comment existsSync fonctionne:
testez si le chemin donné existe ou non en vérifiant avec le système de fichiers.

Une alternative pour stat pourrait utiliser le nouveau fs.access(...):

Fonction de promesse courte minifiée pour vérifier:

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

Exemple d'utilisation:

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

Manière de promesse élargie:

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

Ou si vous voulez le faire de manière synchrone:

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

fs.exists(path, callback) et fs.existsSync(path) sont obsolètes maintenant, voir https://nodejs.org/api/fs.html#fs_fs_exists_path_callback et https://nodejs.org/api/fs.html#fs_fs_existssync_path.

Pour tester l'existence d'un fichier synchrone, on peut utiliser ie. fs.statSync(path). Un objet fs.Stats sera retourné si le fichier existe, voir https://nodejs.org/api/fs.html#fs_class_fs_stats , sinon une erreur est levée qui sera interceptée par l'instruction 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.");
}

Ancienne Version avant V6: voici la documentation

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

Mise à JOUR

Nouvelles versions à partir de V6: documentation pour fs.stat

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

fs.exists a été obsolète depuis 1.0.0. Vous pouvez utiliser fs.stat à la place de cela.

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

Voici le lien pour la documentation fs.les statistiques

@ Fox: excellente réponse! Voici un peu d'une extension avec quelques options supplémentaires. C'est ce que j'ai utilisé dernièrement comme solution de choix:

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://stackoverflow.com/a/7550430/486547
  //
  var sizeInBytes = inodeStatus.size;

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


}

P.S. consultez fs-extra si vous ne l'utilisez pas déjà-c'est assez doux. https://github.com/jprichardson/node-fs-extra)

Il y a beaucoup de commentaires inexacts sur fs.existsSync() étant obsolète; ce n'est pas le cas.

Https://nodejs.org/api/fs.html#fs_fs_existssync_path

Notez que fs.il existe() est obsolète, mais fs.existsSync() ne l'est pas.

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

Eh Bien, je l'ai fait de cette façon, comme on le voit sur https://nodejs.org/api/fs.html#fs_fs_access_path_mode_callback

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

Y a-t-il un problème avec cela?

Après un peu d'expérimentation, j'ai trouvé l'exemple suivant en utilisant fs.stat pour être un bon moyen de vérifier de manière asynchrone si un fichier existe. Il vérifie également que votre "fichier" est "vraiment-est-un-fichier" (et non pas un répertoire).

Cette méthode utilise des promesses, en supposant que vous travaillez avec une base de code asynchrone:

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 le fichier n'existe pas, la promesse se résout toujours, bien que false. Si le fichier existe, et qu'il s'agit d'un répertoire, alors il est résolu true. Toutes les erreurs tenter de lire le fichier reject promet l'erreur elle-même.

async/await version utilisant util.promisify à partir du nœud 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);
    }
  });
});

Dans les vieux jours avant de m'asseoir, je vérifie toujours si la chaise est là, puis je m'assois sinon j'ai un plan alternatif comme s'asseoir sur un entraîneur. Maintenant nœud.le site js suggère juste d'aller (pas besoin de vérifier) et la réponse ressemble à ceci:

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

Code tiré de http://fredkschott.com/post/2014/03/understanding-error-first-callbacks-in-node-js / de Mars 2014, et légèrement modifié pour s'adapter à l'ordinateur. Il vérifie également l'autorisation - supprime l'autorisation pour tester chmod a-r foo.txt

Rappel 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.
}

Les documents indiquent que vous devriez utiliser {[3] } en remplacement de exists()

Nodejs avec promesse de construction (noeud 7+)

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

Cadre JavaScript populaire

Fs-extra

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

Comme vous le voyez beaucoup plus simple. Et l'avantage par rapport à promisify est que vous avez des typages complets avec ce paquet (IntelliSense/typescript complet)! La plupart des cas, vous aurez déjà inclus cette bibliothèque parce que (+-10.000) d'autres bibliothèques en dépendent.

Vous pouvez utiliser fs.stat pour vérifier si la cible est un fichier ou un répertoire et vous pouvez utiliser fs.access pour vérifier si vous pouvez écrire/lire/exécuter le fichier. (n'oubliez pas d'utiliser path.resolve pour obtenir le chemin complet de la cible)

Documentation:

• chemin d'accès.résoudre
• fs.stat
• fs.accès

Exemple complet (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);
}());

À partir du nœud.js documentation:

En utilisant fs.stat() pour vérifier l'existence d'un fichier avant de l'appeler fs.open(), fs.readFile () ou fs.writeFile() n'est pas recommandé. Au lieu de cela, le code utilisateur doit ouvrir/lire/écrire le fichier directement et gérer l'erreur si le fichier n'est pas disponible.

Pour vérifier si un fichier existe sans le manipuler par la suite, fs.access() est recommandé.

Comme l'indique la documentation officielle Nodejs:

Fs.existe (chemin, rappel) Stabilité: 0-obsolète: utiliser fs.stat() ou fs.d'accès() à la place.