Vérifier de manière synchrone si le fichier/répertoire existe dans Node.js

Question

Comment puis-je vérifier de manière synchrone, en utilisant node.js si un fichier ou un répertoire existe ?

Answer 1

Vous pouvez utiliser graph-fs

directory.exists // boolean

Answer 2

Voici une solution simple pour cela :

var fs = require('fs')
function getFileRealPath(s){
    try {return fs.realpathSync(s);} catch(e){return false;}
}

Utilisation :

• Fonctionne à la fois pour les répertoires et les fichiers
• Si l'élément existe, il renvoie le chemin d'accès au fichier ou au répertoire.
• Si l'élément n'existe pas, il renvoie false

Ejemplo:

var realPath,pathToCheck='<your_dir_or_file>'
if( (realPath=getFileRealPath(pathToCheck)) === false){
    console.log('file/dir not found: '+pathToCheck);
} else {
    console.log('file/dir exists: '+realPath);
}

Assurez-vous d'utiliser l'opérateur === pour tester si le retour est égal à faux. Il n'y a aucune raison logique pour que fs.realpathSync() renvoie false dans des conditions de travail correctes, donc je pense que cela devrait fonctionner à 100%.

Je préfèrerais voir une solution qui ne génère pas d'erreur ni de baisse de performance. Du point de vue de l'API, fs.exists() semble être la solution la plus élégante.

Answer 3

D'après les réponses, il semble qu'il n'y ait pas de support officiel de l'API pour cela (comme une vérification directe et explicite). De nombreuses réponses indiquent qu'il faut utiliser stat, mais elles ne sont pas strictes. Nous ne pouvons pas supposer, par exemple, que toute erreur lancée par stat signifie que quelque chose n'existe pas.

Disons que nous essayons avec quelque chose qui n'existe pas :

$ node -e 'require("fs").stat("god",err=>console.log(err))'
{ Error: ENOENT: no such file or directory, stat 'god' errno: -2, code: 'ENOENT', syscall: 'stat', path: 'god' }

Essayons avec quelque chose qui existe mais auquel nous n'avons pas accès :

$ mkdir -p fsm/appendage && sudo chmod 0 fsm
$ node -e 'require("fs").stat("fsm/appendage",err=>console.log(err))'
{ Error: EACCES: permission denied, stat 'access/access' errno: -13, code: 'EACCES', syscall: 'stat', path: 'fsm/appendage' }

Au minimum, vous voudrez :

let dir_exists = async path => {
    let stat;
    try {
       stat = await (new Promise(
           (resolve, reject) => require('fs').stat(path,
               (err, result) => err ? reject(err) : resolve(result))
       ));
    }
    catch(e) {
        if(e.code === 'ENOENT') return false;
        throw e;
    }

    if(!stat.isDirectory())
        throw new Error('Not a directory.');

    return true;
};

La question n'est pas claire quant à savoir si vous voulez réellement qu'elle soit syncrone ou si vous voulez seulement qu'elle soit écrite comme si elle était syncrone. Cet exemple utilise await/async pour qu'il soit écrit de manière synchrone mais s'exécute de manière asynchrone.

Cela signifie que vous devez l'appeler comme tel au niveau supérieur :

(async () => {
    try {
        console.log(await dir_exists('god'));
        console.log(await dir_exists('fsm/appendage'));
    }
    catch(e) {
        console.log(e);
    }
})();

Une alternative consiste à utiliser .then et .catch sur la promesse renvoyée par l'appel asynchrone si vous en avez besoin plus tard.

Si vous voulez vérifier si quelque chose existe, il est bon de s'assurer qu'il s'agit du bon type de chose, comme un répertoire ou un fichier. Ceci est inclus dans l'exemple. Si ce n'est pas autorisé à être un lien symbolique, vous devez utiliser lstat au lieu de stat car stat traverse automatiquement les liens.

Vous pouvez remplacer tout le code async to sync ici et utiliser statSync à la place. Cependant, attendez-vous à ce qu'une fois que async et await seront universellement supportés, les appels de synchronisation deviendront redondants et seront finalement dépréciés (sinon, vous devrez les définir partout et en amont de la chaîne, comme avec async, ce qui les rendrait vraiment inutiles).

Answer 4

Il est fort probable que si vous voulez savoir si un fichier existe, vous prévoyez de le demander s'il existe.

function getFile(path){
    try{
        return require(path);
    }catch(e){
        return false;
    }
}