Jak uzyskać listę nazw wszystkich plików znajdujących się w katalogu w Node.js?

979

Próbuję uzyskać listę nazw wszystkich plików obecnych w katalogu przy użyciu Node.js. Chcę wynik, który jest tablicą nazw plików. W jaki sposób mogę to zrobić?

resopollution
źródło
9
fs.readdirdziała, ale nie może używać wzorców globów nazw plików, takich jak ls /tmp/*core*. Sprawdź github.com/isaacs/node-glob . Globusy mogą nawet wyszukiwać w podkatalogach.
Jess
readdir-recursiveSprawdź moduł NPM, jeśli szukasz także nazw plików w podkatalogach
Ethan Davis
1
fs.readdir to proste rozwiązanie asynchroniczne - przykłady tutaj
drorw
Nadal nie odbierasz za pomocą iteratora? Mam do skanowania 2,5 miliona plików… Nie chcę uzyskać listy 2,5m ścieżki po 10 minutach.
Flavien Volken

Odpowiedzi:

1342

Możesz użyć metod fs.readdirlub fs.readdirSync.

fs.readdir

const testFolder = './tests/';
const fs = require('fs');

fs.readdir(testFolder, (err, files) => {
  files.forEach(file => {
    console.log(file);
  });
});

fs.readdirSync

const testFolder = './tests/';
const fs = require('fs');

fs.readdirSync(testFolder).forEach(file => {
  console.log(file);
});

Różnica między tymi dwiema metodami polega na tym, że pierwsza jest asynchroniczna, dlatego musisz zapewnić funkcję zwrotną, która zostanie wykonana po zakończeniu procesu odczytu.

Drugi jest synchroniczny, zwróci tablicę nazw plików, ale zatrzyma dalsze wykonywanie kodu do czasu zakończenia procesu odczytu.

CMS
źródło
204
Uwaga: readdirpokazuje także nazwy katalogów . Aby je przefiltrować, użyj fs.stat(path, callback(err, stats))i stats.isDirectory().
Rob W
3
Powinienem dodać, że najprawdopodobniej powinieneś użyć readdire, ponieważ nie chcesz blokować IO w węźle.
DragonKnight
5
@ user3705055, chyba że używasz gulp do czytania w katalogu plików zależnych od kolejności źródeł i kompilowania ich w jeden plik wykonywalny.
r3wt,
2
@Sancarn Chcesz spróbować parsować wyjście ls? Poczekaj, aż ktoś utworzy jakieś nazwy plików z osadzonymi spacjami i
znakami
199

IMO najbardziej przekonującym sposobem na wykonanie takich zadań jest użycie narzędzia globalnego . Oto pakiet globalny dla node.js. Zainstaluj za pomocą

npm install glob

Następnie użyj symboli wieloznacznych, aby dopasować nazwy plików (przykład pochodzi ze strony internetowej pakietu)

var glob = require("glob")

// options is optional
glob("**/*.js", options, function (er, files) {
  // files is an array of filenames.
  // If the `nonull` option is set, and nothing
  // was found, then files is ["**/*.js"]
  // er is an error object or null.
})
KFL
źródło
5
było to dla mnie najlepsze rozwiązanie, ponieważ chciałem łatwiej określić typ pliku niż porównania ciągów. Dzięki.
Pogrindis,
Podoba mi się również dlatego, że globowanie jest prawie podstawową umiejętnością w węźle. Jeśli chcesz odzyskać nazwy plików, podaj a cwdw obiekcie opcji.
jcollum
1
Jak uzyskać wyniki globpoza sobą? Na przykład. Chcę console.logwyniki, ale nie w środku glob()?
Lanti
13
@Lanti: glob.sync(pattern, [options])Metoda może być łatwiejsza w użyciu, ponieważ zwraca tablicę nazw plików, a nie oddzwanianie. Więcej informacji tutaj: github.com/isaacs/node-glob
Glenn Lawrence
1
Dla ludzi takich jak ja, którzy szukają globalnej implementacji za pomocą Promises, sprawdź globby przez sindresorhus: github.com/sindresorhus/globby
Nacho Coloma
180

Powyższa odpowiedź nie wykonuje jednak wyszukiwania cyklicznego w katalogu. Oto co zrobiłem dla rekurencyjnego wyszukiwania (za pomocą węzła-walk : npm install walk)

var walk    = require('walk');
var files   = [];

// Walker options
var walker  = walk.walk('./test', { followLinks: false });

walker.on('file', function(root, stat, next) {
    // Add this file to the list of files
    files.push(root + '/' + stat.name);
    next();
});

walker.on('end', function() {
    console.log(files);
});
Ruben Tan
źródło
4
fs.readdirSync jest lepszą, natywną alternatywą stworzoną specjalnie do tego.
Eraden,
37
fs.readdirSync nie wchodzi niestety do podkatalogów, chyba że jesteś gotów napisać własną procedurę, aby to zrobić, czego nie wiesz, że istnieją już moduły npm, aby rozwiązać ten bardzo problem.
Ruben Tan
6
Oto link do repozytorium github walk + docs: github.com/coolaj86/node-walk
santiagoIT
OP nie zapytał o to, który interfejs API dokonuje odczytu rekurencyjnego. W każdym razie zaakceptowana odpowiedź stanowi, co może również służyć jako podstawa do odczytania rekurencyjnego.
Igwe Kalu,
To fantastyczna funkcja. Szybkie pytanie: czy istnieje szybki sposób na zignorowanie niektórych katalogów? Chcę zignorować katalogi zaczynające się od.git
j_d
91

Pobierz pliki we wszystkich podkatalogach

function getFiles (dir, files_){
    files_ = files_ || [];
    var files = fs.readdirSync(dir);
    for (var i in files){
        var name = dir + '/' + files[i];
        if (fs.statSync(name).isDirectory()){
            getFiles(name, files_);
        } else {
            files_.push(name);
        }
    }
    return files_;
}

console.log(getFiles('path/to/dir'))
Tito100
źródło
4
Dlaczego if (typeof files_ === 'undefined') files_=[];? musisz tylko zrobić var files_ = files_ || [];zamiast files_ = files_ || [];.
jkutianski
4
Zapomniałeś dodać var fs = require('fs');na początku getFiles.
GFoley83
To jest metoda rekurencyjna. Nie obsługuje bardzo głębokich struktur folderów, co spowoduje przepełnienie stosu.
Mathias Lykkegaard Lorenzen
63

Oto proste rozwiązanie wykorzystujące tylko natywny fsi pathmoduły:

// sync version
function walkSync(currentDirPath, callback) {
    var fs = require('fs'),
        path = require('path');
    fs.readdirSync(currentDirPath).forEach(function (name) {
        var filePath = path.join(currentDirPath, name);
        var stat = fs.statSync(filePath);
        if (stat.isFile()) {
            callback(filePath, stat);
        } else if (stat.isDirectory()) {
            walkSync(filePath, callback);
        }
    });
}

lub wersja asynchroniczna ( fs.readdirzamiast tego używa ):

// async version with basic error handling
function walk(currentDirPath, callback) {
    var fs = require('fs'),
        path = require('path');
    fs.readdir(currentDirPath, function (err, files) {
        if (err) {
            throw new Error(err);
        }
        files.forEach(function (name) {
            var filePath = path.join(currentDirPath, name);
            var stat = fs.statSync(filePath);
            if (stat.isFile()) {
                callback(filePath, stat);
            } else if (stat.isDirectory()) {
                walk(filePath, callback);
            }
        });
    });
}

Następnie wystarczy zadzwonić (dla wersji synchronizacji):

walkSync('path/to/root/dir', function(filePath, stat) {
    // do something with "filePath"...
});

lub wersja asynchroniczna:

walk('path/to/root/dir', function(filePath, stat) {
    // do something with "filePath"...
});

Różnica polega na tym, jak węzły blokują się podczas wykonywania operacji we / wy. Biorąc pod uwagę, że powyższy interfejs API jest taki sam, możesz po prostu użyć wersji asynchronicznej, aby zapewnić maksymalną wydajność.

Jest jednak jedna zaleta korzystania z wersji synchronicznej. Łatwiej jest wykonać jakiś kod zaraz po zakończeniu marszu, jak w następnej instrukcji po marszu. W wersji asynchronicznej potrzebujesz dodatkowego sposobu na sprawdzenie, kiedy skończysz. Być może najpierw utworzysz mapę wszystkich ścieżek, a następnie je wyliczysz. W przypadku prostych skryptów kompilacji / wykorzystania (w porównaniu z wysokowydajnymi serwerami WWW) można użyć wersji synchronizacji bez powodowania żadnych szkód.

Ali
źródło
1
Powinien zastąpić linię walkSyncod walk(filePath, callback);dowalkSync(filePath, callback);
MIDE11
3
Ale nadal używasz fs.statSync, który blokuje, w wersji asynchronicznej. Nie powinieneś zamiast tego używać fs.stat?
MindlessRanger,
Jest to naprawdę pomocne, a ta metoda jest rekurencyjna. Dzięki!
Little Roys,
35

Począwszy od Node 10.10.0, można używać nowej withFileTypesopcji dla fs.readdiri fs.readdirSyncw połączeniu z dirent.isDirectory()funkcją do filtrowania nazw plików w katalogu. To wygląda tak:

fs.readdirSync('./dirpath', {withFileTypes: true})
.filter(item => !item.isDirectory())
.map(item => item.name)

Zwrócona tablica ma postać:

['file1.txt', 'file2.txt', 'file3.txt']

Dokumenty dla klasy fs.Dirent

bnp887
źródło
7
Jak dotąd najlepsza odpowiedź tutaj!
Alex Ivasyuv
2
tego właśnie ludzie szukają w 2020 roku - należy je „przypiąć”
Val Redchenko
1
Najlepsza odpowiedź 2020!
Yves Lange
26

Korzystanie z obietnic w ES7

Wykorzystanie asynchroniczne z mz / fs

mzModuł zapewnia promisified wersje biblioteki węzła lokalnego. Korzystanie z nich jest proste. Najpierw zainstaluj bibliotekę ...

npm install mz

Następnie...

const fs = require('mz/fs');
fs.readdir('./myDir').then(listing => console.log(listing))
  .catch(err => console.error(err));

Możesz też zapisać je w funkcjach asynchronicznych w ES7:

async function myReaddir () {
  try {
    const file = await fs.readdir('./myDir/');
  }
  catch (err) { console.error( err ) }
};

Zaktualizuj listę rekurencyjną

Niektórzy użytkownicy wyrazili chęć zobaczenia listy rekurencyjnej (choć nie w pytaniu) ... Użyj fs-promise. Wokół jest cienkie opakowanie mz.

npm install fs-promise;

następnie...

const fs = require('fs-promise');
fs.walk('./myDir').then(
    listing => listing.forEach(file => console.log(file.path))
).catch(err => console.error(err));
Evan Carroll
źródło
5
fs.walk został usunięty z fs-promise, ponieważ nie jest obsługiwany przez fs ( github.com/kevinbeaty/fs-promise/issues/28 )
adnan
20

Zależności

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

Definicja.

// String -> [String]
function fileList(dir) {
  return fs.readdirSync(dir).reduce(function(list, file) {
    var name = path.join(dir, file);
    var isDir = fs.statSync(name).isDirectory();
    return list.concat(isDir ? fileList(name) : [name]);
  }, []);
}

Stosowanie.

var DIR = '/usr/local/bin';

// 1. List all files in DIR
fileList(DIR);
// => ['/usr/local/bin/babel', '/usr/local/bin/bower', ...]

// 2. List all file names in DIR
fileList(DIR).map((file) => file.split(path.sep).slice(-1)[0]);
// => ['babel', 'bower', ...]

Pamiętaj, że fileListjest to zbyt optymistyczne. W przypadku czegoś poważnego dodaj obsługę błędów.

Hunan Rostomyan
źródło
1
Dodałem excludeDirsrównież argument tablicowy. Zmienia to na tyle, że może powinieneś go edytować (jeśli chcesz). W przeciwnym razie dodam to w innej odpowiedzi. gist.github.com/AlecTaylor/f3f221b4fb86b4375650
AT
1
@AT Nice! Powinieneś opublikować własną odpowiedź, ponieważ jest to przydatne rozszerzenie. Zachowajmy ten jeden bez cech.
Hunan Rostomyan
19

wersja nierekurencyjna

Nie mówisz, że chcesz to robić rekurencyjnie, więc zakładam, że potrzebujesz tylko bezpośrednich potomków katalogu.

Przykładowy kod:

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

fs.readdirSync('your-directory-path')
  .filter((file) => fs.lstatSync(path.join(folder, file)).isFile());
Tyler Long
źródło
10

Obciążenie fs:

const fs = require('fs');

Czytaj pliki asynchronicznie :

fs.readdir('./dir', function (err, files) {
    // "files" is an Array with files names
});

Czytaj synchronizację plików :

var files = fs.readdirSync('./dir');
Eduardo Cuomo
źródło
10

jeśli ktoś nadal tego szuka, robię to:

import fs from 'fs';
import path from 'path';

const getAllFiles = dir =>
    fs.readdirSync(dir).reduce((files, file) => {
        const name = path.join(dir, file);
        const isDirectory = fs.statSync(name).isDirectory();
        return isDirectory ? [...files, ...getAllFiles(name)] : [...files, name];
    }, []);

i jego praca jest dla mnie bardzo dobra

Josh
źródło
Działa świetnie dla mnie I jest rekurencyjny. Pamiętaj tylko, że składnia importu nadal znajduje się za flagą w węźle, być może będziesz musiał iść starą drogą: const fs = wymagany ('fs');
mjsarfatti
@Josh Działa jak urok. Mając jednak trochę trudności ze zrozumieniem, jak działa [...files, ...getAllFiles(name)]lub [...files, name]. Trochę wyjaśnienia byłoby bardzo pomocne :)
Md Mazedul Islam Khan
1
@MdMazedulIslamKhan Zastosowana ...tutaj nazwa nazywa się składnią rozszerzoną. Zasadniczo zajmuje wszystkie obiekty wewnątrz tablicy i „przenosi” ją do nowej tablicy. W takim przypadku wszystkie wpisy w filestablicy są dodawane do zwrotu wraz ze wszystkimi wartościami zwracanymi z wywołania rekurencyjnego. Możesz zapoznać się ze składnią rozprzestrzeniania tutaj: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
T90
8

Uzyskaj sortednazwy plików. Można filtrować wyniki na podstawie konkretnych extension, takich jak '.txt', '.jpg'i tak dalej.

import * as fs from 'fs';
import * as Path from 'path';

function getFilenames(path, extension) {
    return fs
        .readdirSync(path)
        .filter(
            item =>
                fs.statSync(Path.join(path, item)).isFile() &&
                (extension === undefined || Path.extname(item) === extension)
        )
        .sort();
}
Tak
źródło
6

Z twojego pytania zakładam, że nie chcesz nazw katalogów, tylko pliki.

Przykład:

animals
├── all.jpg
├── mammals
   └── cat.jpg
   └── dog.jpg
└── insects
    └── bee.jpg

Jeśli chcesz tylko tablicę ścieżek plików, użyj return_object: false:

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

async function walk(dir) {
    let files = await fs.readdir(dir);
    files = await Promise.all(files.map(async file => {
        const filePath = path.join(dir, file);
        const stats = await fs.stat(filePath);
        if (stats.isDirectory()) return walk(filePath);
        else if(stats.isFile()) return filePath;
    }));

    return files.reduce((all, folderContents) => all.concat(folderContents), []);
}

console.log(walk('animals'))

zwroty:

[
  "/animals/all.jpg",
  "/animals/mammals/cat.jpg",
  "/animals/mammals/dog.jpg",
  "/animals/insects/bee.jpg"
];

Kredyty trafiają na https://gist.github.com/lovasoa/8691344#gistcomment-2927279

a.barbieri
źródło
5

Oto asynchroniczna wersja rekurencyjna.

    function ( path, callback){
     // the callback gets ( err, files) where files is an array of file names
     if( typeof callback !== 'function' ) return
     var
      result = []
      , files = [ path.replace( /\/\s*$/, '' ) ]
     function traverseFiles (){
      if( files.length ) {
       var name = files.shift()
       fs.stat(name, function( err, stats){
        if( err ){
         if( err.errno == 34 ) traverseFiles()
    // in case there's broken symbolic links or a bad path
    // skip file instead of sending error
         else callback(err)
        }
        else if ( stats.isDirectory() ) fs.readdir( name, function( err, files2 ){
         if( err ) callback(err)
         else {
          files = files2
           .map( function( file ){ return name + '/' + file } )
           .concat( files )
          traverseFiles()
         }
        })
        else{
         result.push(name)
         traverseFiles()
        }
       })
      }
      else callback( null, result )
     }
     traverseFiles()
    }
Oggy Transfluxitor Jones
źródło
4
Nabierz nawyku dodawania średników na końcu instrukcji. W przeciwnym razie nie można zminimalizować kodu. Niemniej jednak dziękuję za bardzo potrzebny wkład asynchroniczny.
user2867288,
2
HAHAHAHA nie jest to częścią specyfikacji, tylko przypadkowa osoba nazywająca swój ulubiony styl sznurowania „standardjs”. Średniki są dobrą praktyką, szczególnie w JavaScript, aby zachować przejrzystość kodu. W przeciwnym razie ty i twój zespół musicie zapamiętać zasady automatycznego wstawiania średników i znam przynajmniej przeciętnego programistę JS, w którym pracuję, nie jest tak pracowity.
user2867288
@ user2867288 Ale skoro ASI istnieje, możemy go użyć, nie? Używam eslint i ładniej do formatowania kodu przy zapisywaniu regularnie, a wstawianie średnika nie jest problemem.
douira
5

Przyjęła ogólne podejście @ Hunan-Rostomyan, uczyniła go nieco bardziej zwięzłym i dodała excludeDirsargument. Rozszerzanie byłoby trywialne includeDirs, wystarczy postępować według tego samego wzoru:

import * as fs from 'fs';
import * as path from 'path';

function fileList(dir, excludeDirs?) {
    return fs.readdirSync(dir).reduce(function (list, file) {
        const name = path.join(dir, file);
        if (fs.statSync(name).isDirectory()) {
            if (excludeDirs && excludeDirs.length) {
                excludeDirs = excludeDirs.map(d => path.normalize(d));
                const idx = name.indexOf(path.sep);
                const directory = name.slice(0, idx === -1 ? name.length : idx);
                if (excludeDirs.indexOf(directory) !== -1)
                    return list;
            }
            return list.concat(fileList(name, excludeDirs));
        }
        return list.concat([name]);
    }, []);
}

Przykładowe użycie:

console.log(fileList('.', ['node_modules', 'typings', 'bower_components']));
W
źródło
Mam główny folder: scss, aw nim inny folder: motywy, ale ostateczna lista zawiera wszystkie katalogi, nie tylko katalogi bez wykluczenia reżysera, co się dzieje?
SalahAdDin
Działa dobrze tylko z „.” katalog folderów, z resztą katalogów nie działa.
SalahAdDin
5

Po wyjęciu z pudełka

Jeśli chcesz mieć obiekt ze strukturą katalogów od razu po wyjęciu z pudełka, gorąco polecam sprawdzenie drzewa katalogów .

Powiedzmy, że masz tę strukturę:

photos
   june
   └── windsurf.jpg
└── january
    ├── ski.png
    └── snowboard.jpg
const dirTree = require("directory-tree");
const tree = dirTree("/path/to/photos");

Wróci:

{
  path: "photos",
  name: "photos",
  size: 600,
  type: "directory",
  children: [
    {
      path: "photos/june",
      name: "june",
      size: 400,
      type: "directory",
      children: [
        {
          path: "photos/june/windsurf.jpg",
          name: "windsurf.jpg",
          size: 400,
          type: "file",
          extension: ".jpg"
        }
      ]
    },
    {
      path: "photos/january",
      name: "january",
      size: 200,
      type: "directory",
      children: [
        {
          path: "photos/january/ski.png",
          name: "ski.png",
          size: 100,
          type: "file",
          extension: ".png"
        },
        {
          path: "photos/january/snowboard.jpg",
          name: "snowboard.jpg",
          size: 100,
          type: "file",
          extension: ".jpg"
        }
      ]
    }
  ]
}

Obiekt niestandardowy

W przeciwnym razie, jeśli chcesz utworzyć obiekt drzewa katalogów z własnymi ustawieniami niestandardowymi, zapoznaj się z poniższym fragmentem. Przykład na żywo jest widoczny na tym kodzie i skrzynce .

// my-script.js
const fs = require("fs");
const path = require("path");

const isDirectory = filePath => fs.statSync(filePath).isDirectory();
const isFile = filePath => fs.statSync(filePath).isFile();

const getDirectoryDetails = filePath => {
  const dirs = fs.readdirSync(filePath);
  return {
    dirs: dirs.filter(name => isDirectory(path.join(filePath, name))),
    files: dirs.filter(name => isFile(path.join(filePath, name)))
  };
};

const getFilesRecursively = (parentPath, currentFolder) => {
  const currentFolderPath = path.join(parentPath, currentFolder);
  let currentDirectoryDetails = getDirectoryDetails(currentFolderPath);

  const final = {
    current_dir: currentFolder,
    dirs: currentDirectoryDetails.dirs.map(dir =>
      getFilesRecursively(currentFolderPath, dir)
    ),
    files: currentDirectoryDetails.files
  };

  return final;
};

const getAllFiles = relativePath => {
  const fullPath = path.join(__dirname, relativePath);
  const parentDirectoryPath = path.dirname(fullPath);
  const leafDirectory = path.basename(fullPath);

  const allFiles = getFilesRecursively(parentDirectoryPath, leafDirectory);
  return allFiles;
};

module.exports = { getAllFiles };

Następnie możesz po prostu zrobić:

// another-file.js 

const { getAllFiles } = require("path/to/my-script");

const allFiles = getAllFiles("/path/to/my-directory");
Mahesh
źródło
3

Jest to TypeScript, opcjonalnie rekurencyjny, opcjonalnie rejestrowanie błędów i rozwiązanie asynchroniczne. Możesz określić wyrażenie regularne dla nazw plików, które chcesz znaleźć.

Użyłem fs-extra, ponieważ jest to łatwa, super-poprawka na fs.

import * as FsExtra from 'fs-extra'

/**
 * Finds files in the folder that match filePattern, optionally passing back errors .
 * If folderDepth isn't specified, only the first level is searched. Otherwise anything up
 * to Infinity is supported.
 *
 * @static
 * @param {string} folder The folder to start in.
 * @param {string} [filePattern='.*'] A regular expression of the files you want to find.
 * @param {(Error[] | undefined)} [errors=undefined]
 * @param {number} [folderDepth=0]
 * @returns {Promise<string[]>}
 * @memberof FileHelper
 */
public static async findFiles(
    folder: string,
    filePattern: string = '.*',
    errors: Error[] | undefined = undefined,
    folderDepth: number = 0
): Promise<string[]> {
    const results: string[] = []

    // Get all files from the folder
    let items = await FsExtra.readdir(folder).catch(error => {
        if (errors) {
            errors.push(error) // Save errors if we wish (e.g. folder perms issues)
        }

        return results
    })

    // Go through to the required depth and no further
    folderDepth = folderDepth - 1

    // Loop through the results, possibly recurse
    for (const item of items) {
        try {
            const fullPath = Path.join(folder, item)

            if (
                FsExtra.statSync(fullPath).isDirectory() &&
                folderDepth > -1)
            ) {
                // Its a folder, recursively get the child folders' files
                results.push(
                    ...(await FileHelper.findFiles(fullPath, filePattern, errors, folderDepth))
                )
            } else {
                // Filter by the file name pattern, if there is one
                if (filePattern === '.*' || item.search(new RegExp(filePattern, 'i')) > -1) {
                    results.push(fullPath)
                }
            }
        } catch (error) {
            if (errors) {
                errors.push(error) // Save errors if we wish
            }
        }
    }

    return results
}
Paul F. Wood
źródło
1

To zadziała i zapisze wynik w pliku test.txt, który będzie obecny w tym samym katalogu

  fs.readdirSync(__dirname).forEach(file => {
    fs.appendFileSync("test.txt", file+"\n", function(err){
    })
})
Rama
źródło
1

Niedawno zbudowałem do tego narzędzie, które właśnie to robi ... Pobiera katalog asynchronicznie i zwraca listę elementów. Możesz pobrać katalogi, pliki lub oba, z pierwszymi folderami. Możesz także paginować dane w przypadku, gdy nie chcesz pobierać całego folderu.

https://www.npmjs.com/package/fs-browser

To jest link, mam nadzieję, że komuś pomoże!

Stefanantro
źródło
0

Tylko jedna głowa: jeśli planujesz wykonywać operacje na każdym pliku w katalogu, wypróbuj winyl-fs (używany przez gulp , system kompilacji strumieniowej).

XåpplI'-I0llwlg'I -
źródło
0

Zrobiłem moduł węzła, aby zautomatyzować to zadanie: mddir

Stosowanie

węzeł mddir „../relative/path/”

Aby zainstalować: npm install mddir -g

Aby wygenerować przecenę dla bieżącego katalogu: mddir

Aby wygenerować dla dowolnej ścieżki bezwzględnej: mddir / absolut / ścieżka

Aby wygenerować dla ścieżki względnej: mddir ~ / Documents /okolwiek.

Plik md zostanie wygenerowany w katalogu roboczym.

Obecnie ignoruje moduły node_modules i .git.

Rozwiązywanie problemów

Jeśli pojawi się błąd „node \ r: Brak takiego pliku lub katalogu”, problem polega na tym, że twój system operacyjny używa różnych zakończeń linii i mddir nie może ich przetworzyć bez wyraźnego ustawienia stylu zakończenia linii na Unix. Zwykle dotyczy to systemu Windows, ale także niektórych wersji systemu Linux. Ustawienie zakończenia linii na styl uniksowy należy wykonać w globalnym folderze bin mddir npm.

Naprawić zakończenia linii

Uzyskaj ścieżkę folderu bin npm za pomocą:

npm config get prefix

Cd do tego folderu

napar zainstaluj dos2unix

dos2unix lib / node_modules / mddir / src / mddir.js

Konwertuje to zakończenia linii na Unix zamiast Dos

Następnie uruchom normalnie z: node mddir „../relative/path/”.

Przykładowa wygenerowana struktura pliku Markdown „directoryList.md”

    |-- .bowerrc
    |-- .jshintrc
    |-- .jshintrc2
    |-- Gruntfile.js
    |-- README.md
    |-- bower.json
    |-- karma.conf.js
    |-- package.json
    |-- app
        |-- app.js
        |-- db.js
        |-- directoryList.md
        |-- index.html
        |-- mddir.js
        |-- routing.js
        |-- server.js
        |-- _api
            |-- api.groups.js
            |-- api.posts.js
            |-- api.users.js
            |-- api.widgets.js
        |-- _components
            |-- directives
                |-- directives.module.js
                |-- vendor
                    |-- directive.draganddrop.js
            |-- helpers
                |-- helpers.module.js
                |-- proprietary
                    |-- factory.actionDispatcher.js
            |-- services
                |-- services.cardTemplates.js
                |-- services.cards.js
                |-- services.groups.js
                |-- services.posts.js
                |-- services.users.js
                |-- services.widgets.js
        |-- _mocks
            |-- mocks.groups.js
            |-- mocks.posts.js
            |-- mocks.users.js
            |-- mocks.widgets.js
John Byrne
źródło
0

Użyj modułu npm zawartości listy . Odczytuje zawartość i podkatalogi danego katalogu i zwraca listę ścieżek plików i folderów.

const list = require('list-contents');

list("./dist",(o)=>{
  if(o.error) throw o.error;
   console.log('Folders: ', o.dirs);
   console.log('Files: ', o.files);
});
Paweł
źródło
-1
function getFilesRecursiveSync(dir, fileList, optionalFilterFunction) {
    if (!fileList) {
        grunt.log.error("Variable 'fileList' is undefined or NULL.");
        return;
    }
    var files = fs.readdirSync(dir);
    for (var i in files) {
        if (!files.hasOwnProperty(i)) continue;
        var name = dir + '/' + files[i];
        if (fs.statSync(name).isDirectory()) {
            getFilesRecursiveSync(name, fileList, optionalFilterFunction);
        } else {
            if (optionalFilterFunction && optionalFilterFunction(name) !== true)
                continue;
            fileList.push(name);
        }
    }
}
Francois
źródło