Dizin nodejs içindeki tüm dizinleri alın

Bunun basit bir şey olacağını umuyordum, ama orada yapacak bir şey bulamıyorum.

Sadece belirli bir klasör / dizin içindeki tüm klasörleri / dizinleri almak istiyorum.

Yani mesela:

<MyFolder>
|- SomeFolder
|- SomeOtherFolder
|- SomeFile.txt
|- SomeOtherFile.txt
|- x-directory

Ben bir dizi almak beklenir:

["SomeFolder", "SomeOtherFolder", "x-directory"]

Ya da yukarıdaki yol bu şekilde sunulmuşsa ...

Peki yukarıdakileri yapmak için zaten bir şey var mı?

Bu cevabın geçerli dizindeki tüm dizinleri (gizli veya değil) listeleyebilen daha kısa, senkronize bir sürümü :

const { lstatSync, readdirSync } = require('fs')
const { join } = require('path')

const isDirectory = source => lstatSync(source).isDirectory()
const getDirectories = source =>
  readdirSync(source).map(name => join(source, name)).filter(isDirectory)

Düğüm 10.10.0+ için güncelleştirme

Ekstra aramayı atlamak için yeni withFileTypesseçeneğini kullanabiliriz :readdirSynclstatSync

const { readdirSync } = require('fs')

const getDirectories = source =>
  readdirSync(source, { withFileTypes: true })
    .filter(dirent => dirent.isDirectory())
    .map(dirent => dirent.name)

JavaScript ES6 (ES2015) sözdizimi özellikleri sayesinde bir astardır:

Senkron versiyon

const { readdirSync, statSync } = require('fs')
const { join } = require('path')

const dirs = p => readdirSync(p).filter(f => statSync(join(p, f)).isDirectory())

Node.js 10+ için eşzamansız sürüm (deneysel)

const { readdir, stat } = require("fs").promises
const { join } = require("path")

const dirs = async path => {
  let dirs = []
  for (const file of await readdir(path)) {
    if ((await stat(join(path, file))).isDirectory()) {
      dirs = [...dirs, file]
    }
  }
  return dirs
}

Dizinleri bir yol kullanarak listeleyin.

function getDirectories(path) {
  return fs.readdirSync(path).filter(function (file) {
    return fs.statSync(path+'/'+file).isDirectory();
  });
}

Özyinelemeli çözüm

Buraya tüm alt dizinleri ve tüm alt dizinlerini vb. Almanın bir yolunu bulmak için geldim. Kabul edilen cevaba dayanarak şunu yazdım:

const fs = require('fs');
const path = require('path');

function flatten(lists) {
  return lists.reduce((a, b) => a.concat(b), []);
}

function getDirectories(srcpath) {
  return fs.readdirSync(srcpath)
    .map(file => path.join(srcpath, file))
    .filter(path => fs.statSync(path).isDirectory());
}

function getDirectoriesRecursive(srcpath) {
  return [srcpath, ...flatten(getDirectories(srcpath).map(getDirectoriesRecursive))];
}

Bunu yapmalı:

CoffeeScript (senkronizasyon)

fs = require 'fs'

getDirs = (rootDir) ->
    files = fs.readdirSync(rootDir)
    dirs = []

    for file in files
        if file[0] != '.'
            filePath = "#{rootDir}/#{file}"
            stat = fs.statSync(filePath)

            if stat.isDirectory()
                dirs.push(file)

    return dirs

CoffeeScript (zaman uyumsuz)

fs = require 'fs'

getDirs = (rootDir, cb) ->
    fs.readdir rootDir, (err, files) ->
        dirs = []

        for file, index in files
            if file[0] != '.'
                filePath = "#{rootDir}/#{file}"
                fs.stat filePath, (err, stat) ->
                    if stat.isDirectory()
                        dirs.push(file)
                    if files.length == (index + 1)
                        cb(dirs)

JavaScript (zaman uyumsuz)

var fs = require('fs');
var getDirs = function(rootDir, cb) { 
    fs.readdir(rootDir, function(err, files) { 
        var dirs = []; 
        for (var index = 0; index < files.length; ++index) { 
            var file = files[index]; 
            if (file[0] !== '.') { 
                var filePath = rootDir + '/' + file; 
                fs.stat(filePath, function(err, stat) {
                    if (stat.isDirectory()) { 
                        dirs.push(this.file); 
                    } 
                    if (files.length === (this.index + 1)) { 
                        return cb(dirs); 
                    } 
                }.bind({index: index, file: file})); 
            }
        }
    });
}

Alternatif olarak, harici kütüphaneleri kullanabiliyorsanız, filehound . Geri çağrıları, vaatleri ve çağrıları senkronize etmeyi destekler.

Sözleri kullanma:

const Filehound = require('filehound');

Filehound.create()
  .path("MyFolder")
  .directory() // only search for directories
  .find()
  .then((subdirectories) => {
    console.log(subdirectories);
  });

Geri çağrıları kullanma:

const Filehound = require('filehound');

Filehound.create()
  .path("MyFolder")
  .directory()
  .find((err, subdirectories) => {
    if (err) return console.error(err);

    console.log(subdirectories);
  });

Aramayı senkronize et:

const Filehound = require('filehound');

const subdirectories = Filehound.create()
  .path("MyFolder")
  .directory()
  .findSync();

console.log(subdirectories);

Daha fazla bilgi (ve örnekler) için dokümanlara göz atın: https://github.com/nspragg/filehound

Feragatname: Ben yazarım.

Node.js sürüm> = v10.13.0 ile fs.readdirSync bir dizi döndürür fs.Dirent eğer nesneleri withFileTypesseçeneğin ayarlandığı true.

Böylece kullanabilirsiniz,

const fs = require('fs')

const directories = source => fs.readdirSync(source, {
   withFileTypes: true
}).reduce((a, c) => {
   c.isDirectory() && a.push(c.name)
   return a
}, [])

 var getDirectories = (rootdir , cb) => {
    fs.readdir(rootdir, (err, files) => {
        if(err) throw err ;
        var dirs = files.map(filename => path.join(rootdir,filename)).filter( pathname => fs.statSync(pathname).isDirectory());
        return cb(dirs);
    })

 }
 getDirectories( myDirectories => console.log(myDirectories));``

Async fs çağrılarını vaat eden fs-extra kullanmak ve yeni async sözdizimini bekliyor:

const fs = require("fs-extra");

async function getDirectories(path){
    let filesAndDirectories = await fs.readdir(path);

    let directories = [];
    await Promise.all(
        filesAndDirectories.map(name =>{
            return fs.stat(path + name)
            .then(stat =>{
                if(stat.isDirectory()) directories.push(name)
            })
        })
    );
    return directories;
}

let directories = await getDirectories("/")

Ve getDirectories'in eşzamansız bir sürümü için bunun için eşzamansız modüle ihtiyacınız vardır :

var fs = require('fs');
var path = require('path');
var async = require('async'); // https://github.com/caolan/async

// Original function
function getDirsSync(srcpath) {
  return fs.readdirSync(srcpath).filter(function(file) {
    return fs.statSync(path.join(srcpath, file)).isDirectory();
  });
}

function getDirs(srcpath, cb) {
  fs.readdir(srcpath, function (err, files) {
    if(err) { 
      console.error(err);
      return cb([]);
    }
    var iterator = function (file, cb)  {
      fs.stat(path.join(srcpath, file), function (err, stats) {
        if(err) { 
          console.error(err);
          return cb(false);
        }
        cb(stats.isDirectory());
      })
    }
    async.filter(files, iterator, cb);
  });
}

Bu cevap, readdirSyncveya gibi engelleme işlevlerini kullanmaz statSync. Dış bağımlılıkları kullanmaz ve kendini geri arama cehenneminin derinliklerinde bulmaz.

Bunun yerine Promises ve async-awaitsözdizimleri gibi modern JavaScript kolaylıklarını kullanıyoruz . Ve eşzamansız sonuçlar paralel olarak işlenir; sırayla değil -

const { readdir, stat } =
  require ("fs") .promises

const { join } =
  require ("path")

const dirs = async (path = ".") =>
  (await stat (path)) .isDirectory ()
    ? Promise
        .all
          ( (await readdir (path))
              .map (p => dirs (join (path, p)))
          )
        .then
          ( results =>
              [] .concat (path, ...results)
          )
    : []

Bir örnek paket kuracağım ve sonra fonksiyonumuzu test edeceğim -

$ npm install ramda
$ node

Bakalım işe yarıyor -

> dirs (".") .then (console.log, console.error)

[ '.'
, 'node_modules'
, 'node_modules/ramda'
, 'node_modules/ramda/dist'
, 'node_modules/ramda/es'
, 'node_modules/ramda/es/internal'
, 'node_modules/ramda/src'
, 'node_modules/ramda/src/internal'
]

Genelleştirilmiş bir modül kullanarak Parallel, dirs-

const Parallel =
  require ("./Parallel")

const dirs = async (path = ".") =>
  (await stat (path)) .isDirectory ()
    ? Parallel (readdir (path))
        .flatMap (f => dirs (join (path, f)))
        .then (results => [ path, ...results ])
    : []

ParallelYukarıda kullanılan modül benzer bir sorunu çözmek için tasarlanmış bir fonksiyon grubu ekstrakte edilmiştir yapısıdır. Daha fazla açıklama için ilgili S ve C'ye bakın .

Bu hatanın doğru hata işleme özelliğine sahip CoffeeScript sürümü :

fs = require "fs"
{join} = require "path"
async = require "async"

get_subdirs = (root, callback)->
    fs.readdir root, (err, files)->
        return callback err if err
        subdirs = []
        async.each files,
            (file, callback)->
                fs.stat join(root, file), (err, stats)->
                    return callback err if err
                    subdirs.push file if stats.isDirectory()
                    callback null
            (err)->
                return callback err if err
                callback null, subdirs

Zaman uyumsuzluğa bağlıdır

Alternatif olarak, bunun için bir modül kullanın! (Her şey için modüller vardır. [Alıntı gerekli])

Tüm asyncsürümü kullanmanız gerekiyorsa . Böyle bir şey olabilir.

1. Dizin uzunluğunu kaydedin, tüm zaman uyumsuz istatistik görevlerinin tamamlanıp tamamlanmadığını göstermek için bir gösterge olarak kullanır.

2. Zaman uyumsuz istatistik görevleri tamamlandıysa, tüm dosya durumu kontrol edilir, bu nedenle geri aramayı çağırın

Bu yalnızca Node.js tek bir iş parçacığı olduğu sürece çalışır, çünkü hiçbir zaman uyumsuz görevin sayacı aynı anda artıracağını varsaymaz.

'use strict';

var fs = require("fs");
var path = require("path");
var basePath = "./";

function result_callback(results) {
    results.forEach((obj) => {
        console.log("isFile: " + obj.fileName);
        console.log("fileName: " + obj.isFile);
    });
};

fs.readdir(basePath, (err, files) => {
    var results = [];
    var total = files.length;
    var finished = 0;

    files.forEach((fileName) => {
        // console.log(fileName);
        var fullPath = path.join(basePath, fileName);

        fs.stat(fullPath, (err, stat) => {
            // this will work because Node.js is single thread
            // therefore, the counter will not increment at the same time by two callback
            finished++;

            if (stat.isFile()) {
                results.push({
                    fileName: fileName,
                    isFile: stat.isFile()
                });
            }

            if (finished == total) {
                result_callback(results);
            }
        });
    });
});

Gördüğünüz gibi, bu bir "önce derinlik" yaklaşımıdır ve bu geri arama cehennemi ile sonuçlanabilir ve oldukça "işlevsel" değildir. İnsanlar zaman uyumsuz görevi bir Promise nesnesine sararak bu sorunu Promise ile çözmeye çalışırlar.

'use strict';

var fs = require("fs");
var path = require("path");
var basePath = "./";

function result_callback(results) {
    results.forEach((obj) => {
        console.log("isFile: " + obj.fileName);
        console.log("fileName: " + obj.isFile);
    });
};

fs.readdir(basePath, (err, files) => {
    var results = [];
    var total = files.length;
    var finished = 0;

    var promises = files.map((fileName) => {
        // console.log(fileName);
        var fullPath = path.join(basePath, fileName);

        return new Promise((resolve, reject) => {
            // try to replace fullPath wil "aaa", it will reject
            fs.stat(fullPath, (err, stat) => {
                if (err) {
                    reject(err);
                    return;
                }

                var obj = {
                    fileName: fileName,
                    isFile: stat.isFile()
                };

                resolve(obj);
            });
        });
    });

    Promise.all(promises).then((values) => {
        console.log("All the promise resolved");
        console.log(values);
        console.log("Filter out folder: ");
        values
            .filter((obj) => obj.isFile)
            .forEach((obj) => {
                console.log(obj.fileName);
            });
    }, (reason) => {
        console.log("Not all the promise resolved");
        console.log(reason);
    });
});

kullanmak fs, yol modülü klasörü var olabilir. Bu kullanım Promise. Doldurma, kutu değişim senin alacak olursa isDirectory () için ) (isFile fs - - Nodejs fs.Stats .AT son sen file'name file'extname alabilir ve böylece Nodejs --- Yolu

var fs = require("fs"),
path = require("path");
//your <MyFolder> path
var p = "MyFolder"
fs.readdir(p, function (err, files) {
    if (err) {
        throw err;
    }
    //this can get all folder and file under  <MyFolder>
    files.map(function (file) {
        //return file or folder path, such as **MyFolder/SomeFile.txt**
        return path.join(p, file);
    }).filter(function (file) {
        //use sync judge method. The file will add next files array if the file is directory, or not. 
        return fs.statSync(file).isDirectory();
    }).forEach(function (files) {
        //The files is array, so each. files is the folder name. can handle the folder.
        console.log("%s", files);
    });
});

ES6 ile tam eşzamansız sürüm, yalnızca yerel paketler, fs.promises ve async / await, dosya işlemlerini paralel olarak yapar:

const fs = require('fs');
const path = require('path');

async function listDirectories(rootPath) {
    const fileNames = await fs.promises.readdir(rootPath);
    const filePaths = fileNames.map(fileName => path.join(rootPath, fileName));
    const filePathsAndIsDirectoryFlagsPromises = filePaths.map(async filePath => ({path: filePath, isDirectory: (await fs.promises.stat(filePath)).isDirectory()}))
    const filePathsAndIsDirectoryFlags = await Promise.all(filePathsAndIsDirectoryFlagsPromises);
    return filePathsAndIsDirectoryFlags.filter(filePathAndIsDirectoryFlag => filePathAndIsDirectoryFlag.isDirectory)
        .map(filePathAndIsDirectoryFlag => filePathAndIsDirectoryFlag.path);
}

Test edildi, güzel çalışıyor.

Herkesin bir web aramasından gelmesi ve Grunt'un zaten bağımlılık listesinde olması durumunda, bunun cevabı önemsiz hale gelir. İşte benim çözümüm:

/**
 * Return all the subfolders of this path
 * @param {String} parentFolderPath - valid folder path
 * @param {String} glob ['/*'] - optional glob so you can do recursive if you want
 * @returns {String[]} subfolder paths
 */
getSubfolders = (parentFolderPath, glob = '/*') => {
    return grunt.file.expand({filter: 'isDirectory'}, parentFolderPath + glob);
}

Başka bir özyinelemeli yaklaşım

Beni tanıdığı için Mayur'a teşekkürler withFileTypes. Belirli bir klasördeki dosyaları yinelemeli olarak almak için aşağıdaki kodu yazdım. Yalnızca dizinleri almak için kolayca değiştirilebilir.

const getFiles = (dir, base = '') => readdirSync(dir, {withFileTypes: true}).reduce((files, file) => {
    const filePath = path.join(dir, file.name)
    const relativePath = path.join(base, file.name)
    if(file.isDirectory()) {
        return files.concat(getFiles(filePath, relativePath))
    } else if(file.isFile()) {
        file.__fullPath = filePath
        file.__relateivePath = relativePath
        return files.concat(file)
    }
}, [])

fonksiyonel programlama

const fs = require('fs')
const path = require('path')
const R = require('ramda')

const getDirectories = pathName => {
    const isDirectory = pathName => fs.lstatSync(pathName).isDirectory()
    const mapDirectories = pathName => R.map(name => path.join(pathName, name), fs.readdirSync(pathName))
    const filterDirectories = listPaths => R.filter(isDirectory, listPaths)

    return {
        paths:R.pipe(mapDirectories)(pathName),
        pathsFiltered: R.pipe(mapDirectories, filterDirectories)(pathName)
    }
}