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


1209

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


58
Les opérations synchrones sont idéales pour effectuer des opérations de fichiers / répertoires uniques avant de retourner un module. Par exemple, amorcer un fichier de configuration.
jocull

1
@PaulDraper avec un cache chaud n'est pas vrai dans tous les cas.
mikemaccana

12
Peu importe les performances, vous souhaitez parfois simplement l'exécuter de manière synchronisée pour l'expérience du développeur. Par exemple, si vous utilisez Node pour un script de traitement de données qui devrait par nature être bloquant, dans ce cas, l'async existsajoute simplement des rappels inutiles.
Kunok

3
Certainement +1 à la déclaration de Kunok. Dans le reste de mon code, je ne fais que rendre le code plus complexe lorsque c'est un goulot d'étranglement où la vitesse compte vraiment. Pourquoi ne pourrais-je pas appliquer ce principe à la lecture de fichiers? Dans de nombreuses parties de nombreux programmes, la simplicité / lisibilité du code peut être plus importante que la vitesse d'exécution. S'il s'agit d'un goulot d'étranglement, j'utiliserai des méthodes asynchrones pour ne pas arrêter l'exécution de code supplémentaire. Sinon ... la synchronisation est super. Ne détestez pas aveuglément la synchronisation.
BryanGrezeszak

3
S'il vous plaît ... ne "vaut pas la peine d'être noté" car l'utilisateur demande explicitement comment le faire de manière synchrone.
jClark

Réponses:


2241

La réponse à cette question a changé au fil des ans. La réponse actuelle est ici en haut, suivie des différentes réponses au fil des années par ordre chronologique:

Réponse actuelle

Vous pouvez utiliser fs.existsSync():

const fs = require("fs"); // Or `import fs from "fs";` with ESM
if (fs.existsSync(path)) {
    // Do something
}

Il est obsolète depuis plusieurs années, mais ne l'est plus. De la documentation:

Notez que fs.exists()c'est obsolète, mais ce fs.existsSync()n'est pas le cas. (Le paramètre de rappel pour fs.exists()accepter les paramètres qui ne sont pas cohérents avec les autres rappels Node.js. N'utilise fs.existsSync()pas de rappel.)

Vous avez spécifiquement demandé une vérification synchrone , mais si vous pouvez utiliser une vérification asynchrone à la place (généralement mieux avec les E / S), utilisez fs.promises.accesssi vous utilisez des asyncfonctions ou fs.access(car existsest déconseillé ) sinon:

Dans une asyncfonction:

try {
    await fs.promises.access("somefile");
    // The check succeeded
} catch (error) {
    // The check failed
}

Ou avec un rappel:

fs.access("somefile", error => {
    if (!error) {
        // The check succeeded
    } else {
        // The check failed
    }
});

Réponses historiques

Voici les réponses historiques par ordre chronologique:

  • Réponse originale de 2010
    ( stat/ statSyncou lstat/ lstatSync)
  • Mise à jour de septembre 2012
    ( exists/ existsSync)
  • Mise à jour de février 2015
    (Notant la dépréciation imminente de exists/ existsSync, nous sommes donc probablement de retour à stat/ statSyncou lstat/ lstatSync)
  • Mise à jour de décembre 2015
    (il y a aussi fs.access(path, fs.F_OK, function(){})/ fs.accessSync(path, fs.F_OK), mais notez que si le fichier / répertoire n'existe pas, c'est une erreur; documents à fs.statrecommander fs.accesssi vous devez vérifier l'existence sans ouvrir)
  • La mise à jour de décembre 2016
    fs.exists() est toujours obsolète mais fs.existsSync()n'est plus obsolète. Vous pouvez donc l'utiliser en toute sécurité maintenant.

Réponse originale de 2010:

Vous pouvez utiliser statSyncou lstatSync( lien docs ), qui vous donne un fs.Statsobjet . En général, si une version synchrone d'une fonction est disponible, elle aura le même nom que la version asynchrone avec Syncà la fin. Il en statSyncva de même pour la version synchrone de stat; lstatSyncest la version synchrone de lstat, etc.

lstatSync vous indique à la fois si quelque chose existe, et si oui, s'il s'agit d'un fichier ou d'un répertoire (ou dans certains systèmes de fichiers, un lien symbolique, un bloc, un caractère, etc.), par exemple si vous avez besoin de savoir s'il existe et s'il est un répertoire:

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) {
    // ...
}

... et de même, s'il s'agit d'un fichier, il y a isFile; s'il s'agit d'un périphérique bloc, il y a isBlockDevice, etc., etc. Notez le try/catch; il renvoie une erreur si l'entrée n'existe pas du tout.

Si vous ne vous inquiétez pas ce que l'entrée est et que vous voulez seulement savoir si elle existe, vous pouvez utiliser path.existsSync(ou plus tard fs.existsSync) comme indiqué par user618408 :

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

Il ne nécessite pas de try/catchmais ne vous donne aucune information sur ce qu'est la chose, juste qu'elle est là. path.existsSynca été dépréciée depuis longtemps.


Note latérale: Vous avez expressément demandé comment vérifier de manière synchrone , j'ai donc utilisé les xyzSyncversions des fonctions ci-dessus. Mais dans la mesure du possible, avec les E / S, il est préférable d'éviter les appels synchrones. Les appels dans le sous-système d'E / S prennent beaucoup de temps du point de vue du processeur. Notez combien il est facile d'appeler lstatplutôt que lstatSync:

// Is it a directory?
lstat('/the/path', function(err, stats) {
    if (!err && stats.isDirectory()) {
        // Yes it is
    }
});

Mais si vous avez besoin de la version synchrone, elle est là.

Mise à jour de septembre 2012

La réponse ci-dessous d'il y a quelques années est maintenant un peu dépassée. La méthode actuelle consiste à utiliser fs.existsSyncpour effectuer une vérification synchrone de l'existence d'un fichier / répertoire (ou bien sûr fs.existspour une vérification asynchrone), plutôt que les pathversions ci-dessous.

Exemple:

var fs = require('fs');

if (fs.existsSync(path)) {
    // Do something
}

// Or

fs.exists(path, function(exists) {
    if (exists) {
        // Do something
    }
});

Mise à jour février 2015

Et nous voici en 2015 et les docs Node disent maintenant que fs.existsSync(et fs.exists) "sera déprécié". (Parce que les gens du Node pensent qu'il est stupide de vérifier si quelque chose existe avant de l'ouvrir, ce qu'il est; mais ce n'est pas la seule raison de vérifier si quelque chose existe!)

Donc, nous sommes probablement de retour aux différentes statméthodes ... Jusqu'à / à moins que cela ne change encore une fois, bien sûr.

Mise à jour décembre 2015

Je ne sais pas depuis combien de temps il y est, mais il y a aussi fs.access(path, fs.F_OK, ...)/fs.accessSync(path, fs.F_OK) . Et au moins depuis octobre 2016, la fs.statdocumentation recommande d'utiliser fs.accesspour faire des vérifications d'existence ( "Pour vérifier si un fichier existe sans le manipuler par la suite, fs.access()est recommandé." ). Mais notez que l'accès non disponible est considéré comme une erreur , donc ce serait probablement mieux si vous vous attendez à ce que le fichier soit accessible:

var fs = require('fs');

try {
    fs.accessSync(path, fs.F_OK);
    // Do something
} catch (e) {
    // It isn't accessible
}

// Or

fs.access(path, fs.F_OK, function(err) {
    if (!err) {
        // Do something
    } else {
        // It isn't accessible
    }
});

Mise à jour décembre 2016

Vous pouvez utiliser fs.existsSync():

if (fs.existsSync(path)) {
    // Do something
}

Il est obsolète depuis plusieurs années, mais ne l'est plus. De la documentation:

Notez que fs.exists()c'est obsolète, mais ce fs.existsSync()n'est pas le cas. (Le paramètre de rappel pour fs.exists()accepter les paramètres qui ne sont pas cohérents avec les autres rappels Node.js. N'utilise fs.existsSync()pas de rappel.)


7
path.exists et path.existsSync ont tous deux été dépréciés en faveur de fs.exists et fs.existsSync
Drew

15
"Les gens du nœud pensent qu'il est stupide de vérifier si quelque chose existe avant de l'ouvrir, ce qui est le cas;" Pourquoi est-il stupide de vérifier si le fichier existe?
Petr Hurtak

32
@PetrHurtak: Ce n'est pas toujours (car il y a beaucoup de raisons de vérifier l'existence), mais si vous allez ouvrir le fichier, il est préférable d'émettre l' openappel et de gérer l'exception ou peu importe si le fichier n'était pas a trouvé. Après tout, le monde réel est chaotique: si vous vérifiez d'abord et qu'il est là, cela ne signifie pas qu'il sera toujours là lorsque vous essayez de l'ouvrir; si vous vérifiez d'abord et qu'il n'est pas là, cela ne signifie pas qu'il ne sera pas là un instant plus tard. Des choses comme ça ressemblent à des cas marginaux, mais elles reviennent tout le temps . Donc, si vous allez ouvrir, inutile de vérifier d'abord.
TJ Crowder

13
Et ici, je pensais que c'était un anti-modèle d'utiliser des erreurs pour le flux de contrôle: lien
argyle

4
@ jeromeyers: Vous pourriez, mais Ionică l' a déjà fait pour vous (voir commentaire ci-dessus ). :-)
TJ Crowder

124

En regardant la source, il existe une version synchrone de path.exists- path.existsSync. On dirait que ça a été oublié dans la documentation.

Mise à jour:

path.existset path.existsSyncsont désormais obsolètes . Veuillez utiliser fs.existsetfs.existsSync .

Mise à jour 2016:

fs.exists et fs.existsSyncont également été dépréciés . Utilisez plutôt fs.stat () ou fs.access () .

Mise à jour 2019:

utiliser fs.existsSync. Ce n'est pas obsolète. https://nodejs.org/api/fs.html#fs_fs_existssync_path


1
path.existsSync (p) est dans la documentation 0.4.10 nodejs.org/docs/v0.4.10/api/path.html
Paul Beusterien

21
En fait, une réponse plus récente: path.existsSync est déconseillée. Il est maintenant appelé fs.existsSync.
Olivier Lalonde

9
Maintenant, les docs disent que fs.exists sera obsolète. nodejs.org/api/fs.html#fs_fs_existssync_path
Greg Hornby

J'ai écrit une petite bibliothèque pour remplacer l'ancienne existsfonction:is-there
Ionică Bizău

6
les documents currenct (version ~ 9) ne sont étiquetés fs.existsque comme obsolètes alors qu'ils fs.existsSyncne le sont pas!
Kunok

57

En utilisant les API actuellement recommandées (à partir de 2015) (selon la documentation Node), voici ce que je fais:

var fs = require('fs');

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

En réponse au problème EPERM soulevé par @broadband dans les commentaires, cela soulève un bon point. fileExists () n'est probablement pas un bon moyen d'y penser dans de nombreux cas, car fileExists () ne peut pas vraiment promettre un retour booléen. Vous pouvez être en mesure de déterminer définitivement que le fichier existe ou n'existe pas, mais vous pouvez également obtenir une erreur d'autorisations. L'erreur d'autorisations n'implique pas nécessairement que le fichier existe, car vous pourriez ne pas avoir l'autorisation sur le répertoire contenant le fichier sur lequel vous vérifiez. Et bien sûr, il est possible que vous rencontriez une autre erreur lors de la vérification de l'existence du fichier.

Donc, mon code ci-dessus est vraiment doesFileExistAndDoIHaveAccessToIt (), mais votre question pourrait être doesFileNotExistAndCouldICreateIt (), ce qui serait une logique complètement différente (qui devrait tenir compte d'une erreur EPERM, entre autres).

Bien que la réponse fs.existsSync réponde directement à la question posée ici, ce ne sera souvent pas ce que vous voulez (vous ne voulez pas simplement savoir si "quelque chose" existe sur un chemin, vous vous demandez probablement si la "chose" qui existe est un fichier ou un répertoire).

L'essentiel, c'est que si vous vérifiez pour voir si un fichier existe, vous le faites probablement parce que vous avez l'intention de prendre des mesures en fonction du résultat, et que la logique (la vérification et / ou l'action ultérieure) devrait tenir compte de l'idée qu'une chose trouvée sur ce chemin peut être un fichier ou un répertoire, et que vous pouvez rencontrer EPERM ou d'autres erreurs dans le processus de vérification.


4
Bien, j'ai ajouté || isDirectory () pour en faire un vérificateur de fichiers / dossiers. var stats = fs.statSync (filePath); return stats.isFile () || stats.isDirectory ();
bob

4
Si le programme n'a pas les droits d'accès au fichier, il retourne toujours false même si le fichier existe, c'est-à-dire supprimer tous les rigts du fichier chmod ugo-rwx file.txt ou dans Windows Clic droit ... Message d'exception: Exception fs.statSync (./ f.txt): Erreur: EPERM: opération non autorisée, stat 'X: \ f.txt'. Donc, ce cas n'est pas couvert par le code supérieur.
haut débit du

2
Wow, JS est parfois retardé. Alors, bien sûr, 97% du temps, vous utiliserez le fichier, mais vous n'aurez pas un simple file.exists()util pour les 3% et nous obliger à la place à envelopper dans une prise d'essai? Soyez réel ... Salope du jour.
expelledboy

20

Une autre mise à jour

Ayant moi-même besoin d'une réponse à cette question, j'ai recherché les documents du nœud, il semble que vous ne devriez pas utiliser fs.exists, utilisez plutôt fs.open et utilisez une erreur de sortie pour détecter si un fichier n'existe pas:

à partir des documents:

fs.exists () est un anachronisme et n'existe que pour des raisons historiques. Il ne devrait presque jamais y avoir de raison de l'utiliser dans votre propre code.

En particulier, vérifier si un fichier existe avant de l'ouvrir est un anti-modèle qui vous rend vulnérable aux conditions de concurrence: un autre processus peut supprimer le fichier entre les appels à fs.exists () et fs.open (). Ouvrez simplement le fichier et gérez l'erreur lorsqu'il n'est pas là.

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


1
existe-t-il un moyen de le faire avec openSync, plutôt que d'ouvrir
Greg Hornby

1
@GregHornby J'imagine que cela devrait fonctionner de la même manière avec openSync
Melbourne2991

2
Pour ceux qui en ont encore besoin exists et existsSyncj'ai créé is-there.
Ionică Bizău

6
Cette dépréciation me dérange. L'ouverture d'un fichier juste pour voir si une erreur est levée ou non semble être un gaspillage de ressources alors qu'il suffit de connaître l'existence du fichier.
Josh Hansen

11

J'utilise la fonction ci-dessous pour tester si le fichier existe. Il intercepte également d'autres exceptions. Donc, dans le cas où il y a des problèmes de droits, par exemple, chmod ugo-rwx filenameou dans Windows, la Right Click -> Properties -> Security -> Advanced -> Permission entries: empty list ..fonction renvoie une exception comme il se doit. Le fichier existe mais nous n'avons pas le droit d'y accéder. Il serait faux d'ignorer ce type d'exceptions.

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

Sortie d'exception, documentation des erreurs nodejs dans le cas où le fichier n'existe pas:

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

Exception dans le cas où nous n'avons pas de droits sur le fichier, mais qui existe:

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

2
Vraiment comme ça, c'est l'une des rares réponses à jour depuis que le nœud a déprécié les 37 dernières façons de le faire
1mike12

Bah, tu m'as battu. J'aurais pu gagner du temps si j'avais lu ceci.
jgmjgm

5

fs.exists () est déconseillé ne l'utilisez pas https://nodejs.org/api/fs.html#fs_fs_exists_path_callback

Vous pouvez implémenter la manière principale de nodejs utilisée ici: 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;
}

cela renverra l'objet stats puis une fois que vous aurez l'objet stats vous pourrez essayer

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

4

Certaines réponses ici le disent fs.existset fs.existsSyncsont toutes deux obsolètes. Selon les documents, cela n'est plus vrai. Seul fs.existsest désormais déprécié:

Notez que fs.exists () est déconseillé, mais fs.existsSync () ne l'est pas. (Le paramètre de rappel de fs.exists () accepte des paramètres qui ne sont pas cohérents avec les autres rappels Node.js. Fs.existsSync () n'utilise pas de rappel.)

Vous pouvez donc utiliser en toute sécurité fs.existsSync () pour vérifier de manière synchrone si un fichier existe.


3

Le pathmodule ne fournit pas de version synchrone de path.existsdonc vous devez faire le tour avec le fsmodule.

La chose la plus rapide que j'imagine est d'utiliser fs.realpathSyncqui générera une erreur que vous devrez intercepter, vous devez donc créer votre propre fonction wrapper avec un try / catch.


1

L'utilisation de tests fileSystem (fs) déclenchera des objets d'erreur, que vous devrez ensuite encapsuler dans une instruction try / catch. Épargnez-vous un peu d'effort et utilisez une fonctionnalité introduite dans la branche 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);
  });
});

2
Le path.exists est maintenant sous fs donc c'est fs.exists (path, callback)
Todd Moses

0

Les documents sur fs.stat()indiquent à utiliser fs.access()si vous n'allez pas manipuler le fichier. Il n'a pas donné de justification, pourrait être une utilisation plus rapide ou moins de la mémoire?

J'utilise node pour l'automatisation linéaire, j'ai donc pensé partager la fonction que j'utilise pour tester l'existence d'un fichier.

var fs = require("fs");

function exists(path){
    //Remember file access time will slow your program.
    try{
        fs.accessSync(path);
    } catch (err){
        return false;
    }
    return true;
}

0

mis à jour une réponse pour ces personnes indiquant «correctement» qu'il ne répond pas directement à la question, apportez davantage une option alternative.

Solution de synchronisation:

fs.existsSync('filePath')voir aussi les documents ici .

Renvoie vrai si le chemin existe, faux sinon.

Solution Async Promise

Dans un contexte asynchrone, vous pouvez simplement écrire la version asynchrone dans la méthode de synchronisation en utilisant le awaitmot clé. Vous pouvez simplement transformer la méthode de rappel asynchrone en promesse comme ceci:

function fileExists(path){
  return new Promise((resolve, fail) => fs.access(path, fs.constants.F_OK, 
    (err, result) => err ? fail(err) : resolve(result))
  //F_OK checks if file is visible, is default does no need to be specified.

}

async function doSomething() {
  var exists = await fileExists('filePath');
  if(exists){ 
    console.log('file exists');
  }
}

la documentation sur access ().


1
le PO veut une solution synchrone
vdegenne

vous devez mettre à jour votre code versfunction asyncFileExists(path) { //F_OK checks if file is visible, is default does no need to be specified. return new Promise(function (res, rej) { fs.access( path, fs.constants.F_OK, function (err) { err ? rej(err) : res(true); }, ); }); }
pery mimon

0

Il y a de fortes chances que si vous voulez savoir si un fichier existe, vous prévoyez de l'exiger s'il le fait.

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

-1

Voici une solution d'emballage simple pour cela:

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

Usage:

  • Fonctionne 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 faux

Exemple:

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 return est égal à false. Il n'y a aucune raison logique 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 et les performances qui en résultent. Du point de vue de l'API, fs.exists () semble être la solution la plus élégante.


1
@Dan, merci. J'ai supprimé le texte tronqué. Je ne me souviens pas de la note. Si cela me vient, j'ajouterai des notes.
Timothy C. Quinn du

1
Np. J'efface mon commentaire.
Dan Dascalescu

-2

D'après les réponses, il semble qu'il n'y ait pas de support API officiel pour cela (comme dans une vérification directe et explicite). Beaucoup de réponses disent 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' }

Vous voudrez au moins:

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 de 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 wait / async pour qu'il ne soit écrit que de manière syncrone mais s'exécute de manière asyncrone.

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 loin.

Si vous voulez vérifier si quelque chose existe, c'est une bonne pratique de vous assurer que c'est le bon type de chose comme un répertoire ou un fichier. Ceci est inclus dans l'exemple. S'il n'est pas autorisé à être un lien symbolique, vous devez utiliser lstat au lieu de stat car stat traversera automatiquement les liens.

Vous pouvez remplacer tous les codes asynchrones pour synchroniser le code ici et utiliser statSync à la place. Cependant, attendez-vous à ce qu'une fois que l'async et l'attente deviennent universellement pris en charge, les appels de synchronisation deviendront redondants pour être éventuellement amortis (sinon vous devrez les définir partout et en amont, tout comme avec async, ce qui le rend vraiment inutile).


1
La question d'origine ne le précise pas. Je montre également comment faire les choses sans ambiguïté. De nombreuses réponses peuvent induire des bugs par manque de clarté. Les gens veulent souvent programmer des choses pour qu'il apparaisse syncron mais ne veulent pas nécessairement une exécution synchrone. statSync n'est pas le même que le code que j'ai démontré. Les deux comptes rendus de ce qui est réellement souhaité sont ambigus, vous n'imposez donc que vos interprétations personnelles. Si vous trouvez une réponse que vous ne comprenez pas, il serait préférable de simplement demander dans les commentaires ou dans le MP de déterminer les modifications nécessaires.
jgmjgm

1
Si vous le souhaitez, vous pouvez également voler mon exemple de code, le nommer de manière appropriée, le mettre sur github, l'ajouter à npm et la réponse ne sera qu'une seule ligne / lien: D.
jgmjgm

Le code est court à titre d'exemple, mais vous êtes invités à soumettre une suggestion de modification pour inclure &&! IsFile ou une vérification des liens symboliques, etc. Comme je l'ai déjà souligné, ma réponse satisfait à une interprétation de la question et ne fait pas la même chose que votre proposition sur une ligne.
jgmjgm
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.