Node.js prüft, ob der Pfad eine Datei oder ein Verzeichnis ist

Ich kann anscheinend keine Suchergebnisse erhalten, die erklären, wie das geht.

Ich möchte nur wissen können, ob ein bestimmter Pfad eine Datei oder ein Verzeichnis (Ordner) ist.

fs.lstatSync(path_string).isDirectory()sollte es dir sagen. Aus den Dokumenten :

Von fs.stat () und fs.lstat () zurückgegebene Objekte sind von diesem Typ.

stats.isFile()
stats.isDirectory()
stats.isBlockDevice()
stats.isCharacterDevice()
stats.isSymbolicLink() (only valid with fs.lstat())
stats.isFIFO()
stats.isSocket()

HINWEIS:

Die obige Lösung wird throwein Errorwenn; Zum Beispiel existiert das fileoder directorynicht.

Wenn Sie eine trueoder falseAnnäherung wünschen , versuchen Sie es fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();wie von Joseph in den Kommentaren unten erwähnt.

Update: Node.Js> = 10

Wir können die neue fs.promises- API verwenden

const fs = require('fs').promises;

(async() => {
    const stat = await fs.lstat('test.txt');
    console.log(stat.isFile());
})().catch(console.error)

Beliebige Node.Js-Version

So erkennen Sie, ob ein Pfad asynchron eine Datei oder ein Verzeichnis ist. Dies ist der empfohlene Ansatz in Node. mit fs.lstat

const fs = require("fs");

let path = "/path/to/something";

fs.lstat(path, (err, stats) => {

    if(err)
        return console.log(err); //Handle error

    console.log(`Is file: ${stats.isFile()}`);
    console.log(`Is directory: ${stats.isDirectory()}`);
    console.log(`Is symbolic link: ${stats.isSymbolicLink()}`);
    console.log(`Is FIFO: ${stats.isFIFO()}`);
    console.log(`Is socket: ${stats.isSocket()}`);
    console.log(`Is character device: ${stats.isCharacterDevice()}`);
    console.log(`Is block device: ${stats.isBlockDevice()}`);
});

Hinweis bei Verwendung der synchronen API:

Bei Verwendung des synchronen Formulars werden Ausnahmen sofort ausgelöst. Sie können try / catch verwenden, um Ausnahmen zu behandeln oder sie in die Luft sprudeln zu lassen.

try{
     fs.lstatSync("/some/path").isDirectory()
}catch(e){
   // Handle error
   if(e.code == 'ENOENT'){
     //no such file or directory
     //do something
   }else {
     //do something else
   }
}

Ernsthaft, Frage existiert fünf Jahre und keine schöne Fassade?

function is_dir(path) {
    try {
        var stat = fs.lstatSync(path);
        return stat.isDirectory();
    } catch (e) {
        // lstatSync throws an error if path doesn't exist
        return false;
    }
}

Abhängig von Ihren Anforderungen können Sie sich wahrscheinlich auf das pathModul des Knotens verlassen .

Möglicherweise können Sie das Dateisystem nicht erreichen (z. B. wurde die Datei noch nicht erstellt), und Sie möchten wahrscheinlich vermeiden, das Dateisystem zu erreichen, es sei denn, Sie benötigen wirklich die zusätzliche Validierung. Wenn Sie davon ausgehen können, dass das, wonach Sie .<extname>suchen, dem folgenden Format entspricht, sehen Sie sich einfach den Namen an.

Wenn Sie nach einer Datei ohne Ext-Namen suchen, müssen Sie natürlich auf das Dateisystem klicken, um sicherzugehen. Aber halten Sie es einfach, bis Sie komplizierter brauchen.

const path = require('path');

function isFile(pathItem) {
  return !!path.extname(pathItem);
}

Die obigen Antworten prüfen, ob ein Dateisystem einen Pfad enthält, der eine Datei oder ein Verzeichnis ist. Es wird jedoch nicht identifiziert, ob ein bestimmter Pfad allein eine Datei oder ein Verzeichnis ist.

Die Antwort besteht darin, verzeichnisbasierte Pfade mit "/" zu identifizieren. wie -> "/ c / dos / run /." <- Nachlaufzeit.

Wie ein Pfad eines Verzeichnisses oder einer Datei, die noch nicht geschrieben wurde. Oder ein Pfad von einem anderen Computer. Oder ein Pfad, in dem sowohl eine Datei als auch ein Verzeichnis mit demselben Namen vorhanden sind.

// /tmp/
// |- dozen.path
// |- dozen.path/.
//    |- eggs.txt
//
// "/tmp/dozen.path" !== "/tmp/dozen.path/"
//
// Very few fs allow this. But still. Don't trust the filesystem alone!

// Converts the non-standard "path-ends-in-slash" to the standard "path-is-identified-by current "." or previous ".." directory symbol.
function tryGetPath(pathItem) {
    const isPosix = pathItem.includes("/");
    if ((isPosix && pathItem.endsWith("/")) ||
        (!isPosix && pathItem.endsWith("\\"))) {
        pathItem = pathItem + ".";
    }
    return pathItem;
}
// If a path ends with a current directory identifier, it is a path! /c/dos/run/. and c:\dos\run\.
function isDirectory(pathItem) {
    const isPosix = pathItem.includes("/");
    if (pathItem === "." || pathItem ==- "..") {
        pathItem = (isPosix ? "./" : ".\\") + pathItem;
    }
    return (isPosix ? pathItem.endsWith("/.") || pathItem.endsWith("/..") : pathItem.endsWith("\\.") || pathItem.endsWith("\\.."));
} 
// If a path is not a directory, and it isn't empty, it must be a file
function isFile(pathItem) {
    if (pathItem === "") {
        return false;
    }
    return !isDirectory(pathItem);
}

Knotenversion: v11.10.0 - Februar 2019

Letzter Gedanke: Warum überhaupt ins Dateisystem?

Hier ist eine Funktion, die ich benutze. Niemand nutzt promisifyund präsentiert await/asyncin diesem Beitrag, also dachte ich, ich würde teilen.

const promisify = require('util').promisify;
const lstat = promisify(require('fs').lstat);

async function isDirectory (path) {
  try {
    return (await lstat(path)).isDirectory();
  }
  catch (e) {
    return false;
  }
}

Hinweis: Ich benutze require('fs').promises;es nicht, weil es seit einem Jahr experimentell ist. Verlassen Sie sich besser nicht darauf.