下面的文档可以告诉你：

fs.lstatSync(path_string).isDirectory()

从fs.stat（）和fs.lstat（）返回的对象就是这种类型。

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

注：

• • 上述解**将throw和Error，如果：例如，file或directory不存在。

如果您想要true或false方法，请尝试Joseph在下面的评论中提到的fs.existsSync(dirPath) && fs.lstatSync(dirPath).isDirectory();。

更新：节点. J〉= 10

我们可以使用新的fs.promises API

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

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

任何Node.Js版本

下面介绍如何异步检测路径是文件还是目录，这是node. using 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()}`);
});

使用同步API时请注意：
当使用同步形式时，任何异常都会被立即抛出。你可以使用try/catch来处理异常或允许它们冒泡。

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

说真的，问题存在了五年，没有一个漂亮的门面？

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

根据您的需要，您可能会依赖node的path模块。
您可能无法命中文件系统（例如，文件还没有创建），并且您可能希望避免命中文件系统，除非您真的需要额外的验证。如果您可以假设您要检查的内容遵循.<extname>，只需查看名称即可。
显然，如果你要找一个没有扩展名的文件，你需要找到文件系统来确认，但是要保持简单，直到你需要更复杂的文件。

const path = require('path');

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

如果在遍历目录时需要此选项1

由于节点10.10+，fs.readdir有withFileTypes选项，使其返回目录条目fs.Dirent，而不仅仅是文件名。目录条目包含其name和有用的方法，如isDirectory或isFile，所以你不需要显式调用fs.lstat！
您可以像这样使用它：

import { promises as fs } from 'fs';

// ./my-dir has two subdirectories: dir-a, and dir-b
const dirEntries = await fs.readdir('./my-dir', { withFileTypes: true });

// let's filter all directories in ./my-dir
const onlyDirs = dirEntries.filter(de => de.isDirectory()).map(de => de.name);
// onlyDirs is now [ 'dir-a', 'dir-b' ]

1)因为我就是这样找到这个问题的。

这是我使用的一个函数。没有人在这篇文章中使用promisify和await/async特性，所以我想我可以分享一下。

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

注意：我不使用require('fs').promises;，因为它已经实验了一年，最好不要依赖它。

上面的答案检查了文件系统是否包含一个文件或目录路径，但是它不能识别一个给定的路径是否是一个文件或目录。
答案是使用"/."类似于--〉"/c/dos/run/."〈--尾随句点来标识基于目录的路径。
例如尚未写入的目录或文件的路径，或者来自不同计算机的路径，或者同时存在同名文件和目录的路径。

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

节点版本：版本11.10.0 - 2019年2月
最后的想法：为什么还要攻击文件系统？

我可以使用以下命令检查目录或文件是否存在：

// This returns if the file is not a directory.
if(fs.lstatSync(dir).isDirectory() == false) return;

// This returns if the folder is not a file.
if(fs.lstatSync(dir).isFile() == false) return;

返回类型的函数

我喜欢咖啡

type: (uri)-> (fina)->
        fs.lstat uri, (erro,stats) ->
            console.log {erro} if erro
            fina(
                stats.isDirectory() and "directory" or
                stats.isFile() and "document" or
                stats.isSymbolicLink() and "link" or
                stats.isSocket() and "socket" or
                stats.isBlockDevice() and "block" or
                stats.isCharacterDevice() and "character" or
                stats.isFIFO() and "fifo"
            )

用法：

dozo.type("<path>") (type)->
     console.log "type is #{type}"