it-swarm.com.de

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.

329
ThomasReggi

fs.lstatSync(path_string).isDirectory() sollte es Ihnen sagen. Aus dem docs :

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 ist throw und Error if; Zum Beispiel existiert das file oder directory nicht. Wenn Sie ein truthy oder falsy möchten, versuchen Sie fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();, wie von Joseph in den Kommentaren unten erwähnt.

523
Jason Sperske

Update: Node.Js> = 10

Wir können die neue fs.promises API verwenden

Experimentell Diese Funktion befindet sich noch in der aktiven Entwicklung und kann in zukünftigen Versionen nicht abwärtskompatibel geändert oder sogar entfernt werden. Die Verwendung der Funktion wird in Produktionsumgebungen nicht empfohlen. Experimentelle Funktionen unterliegen nicht dem Semantic Versioning-Modell von Node.j.

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

(async() => {

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

Beliebige Node.Js-Version

So können Sie feststellen, ob ein Pfad eine Datei oder ein Verzeichnis ist , und zwar asynchron . 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 der synchronen Form werden Ausnahmen sofort geworfen. 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
   }
}
45

Im Ernst, Frage besteht seit fünf Jahren 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;
    }
}
13
lama12345

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

Sie sind möglicherweise nicht in der Lage, auf das Dateisystem zuzugreifen (z. B. die Datei wurde noch nicht erstellt), und Sie möchten wahrscheinlich vermeiden, auf das Dateisystem zuzugreifen, es sei denn, Sie benötigen wirklich die zusätzliche Überprüfung. Wenn Sie davon ausgehen können, dass das, wonach Sie suchen, dem Format .<extname> entspricht, sehen Sie sich nur den Namen an.

Wenn Sie nach einer Datei ohne extname suchen, müssen Sie natürlich das Dateisystem treffen, um sicherzugehen. Aber halten Sie es einfach, bis Sie komplizierter brauchen.

const path = require('path');

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

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 - Feb 2019

Letzter Gedanke: Warum überhaupt das Dateisystem treffen?

1
TamusJRoyce

Hier ist eine eigenständige Funktion, die ich in einigen meiner Programme verwende. Niemand nutzt die Funktionen promisify und await/async in diesem Beitrag, also dachte ich, ich würde sie teilen.

const isDirectory = async path => {
  try {
    return (await require('util').promisify(require('fs').lstat)(path)).isDirectory()
  } catch (e) {
    return false // or custom the error
  }
}

Hinweis: Ich verwende require('fs').promises; nicht, weil es seit einem Jahr experimentell ist, sondern verlasse mich nicht darauf.

0
vdegenne