it-swarm.com.de

Holen Sie sich alle Dateien rekursiv in den Verzeichnissen NodejS

Ich habe ein kleines Problem mit meiner Funktion. Ich möchte alle Dateien in vielen Verzeichnissen erhalten. Derzeit kann ich die Dateien in der übergebenen Datei abrufen. Ich möchte die HTML-Dateien jedes Ordners in dem als Parameter übergebenen Ordner abrufen. Ich erkläre, wenn ich den Parameter "test" eingebe, rufe ich die Dateien in "test" ab, möchte aber "test/1/*. Html", "test/2/././Html" abrufen: 

var srcpath2 = path.join('.', 'diapo', result);
function getDirectories(srcpath2) {
                return fs.readdirSync(srcpath2).filter(function (file) {
                    return fs.statSync(path.join(srcpath2, file)).isDirectory();
                });
            }

Das Ergebnis: [1,2,3]

vielen Dank !

7
user6285277

Es sieht so aus, als würde das glob npm-Paket Ihnen helfen. Hier ist ein Beispiel, wie man es benutzt:

Dateihierarchie:

test
├── one.html
└── test-nested
    └── two.html

JS-Code:

var getDirectories = function (src, callback) {
  glob(src + '/**/*', callback);
};
getDirectories('test', function (err, res) {
  if (err) {
    console.log('Error', err);
  } else {
    console.log(res);
  }
});

welche zeigt:

[ 'test/one.html',
  'test/test-nested',
  'test/test-nested/two.html' ]
16
Paul Mougel

Ich musste so etwas ähnliches in einer Electron-App: alle Unterordner in einem bestimmten Basisordner mit TypeScript abrufen und kam dazu:

import { readdirSync, statSync, existsSync } from "fs";
import * as path from "path";

// recursive synchronous "walk" through a folder structure, with the given base path
getAllSubFolders = (baseFolder, folderList = []) => {

    let folders:string[] = readdirSync(baseFolder).filter(file => statSync(path.join(baseFolder, file)).isDirectory());
    folders.forEach(folder => {
        folderList.Push(path.join(baseFolder,folder));
        this.getAllSubFolders(path.join(baseFolder,folder), folderList);
    });
}
3
Ben
const fs = require('fs');
const path = require('path');
var filesCollection = [];
const directoriesToSkip = ['bower_components', 'node_modules', 'www', 'platforms'];

function readDirectorySynchronously(directory) {
    var currentDirectorypath = path.join(__dirname + directory);

    var currentDirectory = fs.readdirSync(currentDirectorypath, 'utf8');

    currentDirectory.forEach(file => {
        var fileShouldBeSkipped = directoriesToSkip.indexOf(file) > -1;
        var pathOfCurrentItem = path.join(__dirname + directory + '/' + file);
        if (!fileShouldBeSkipped && fs.statSync(pathOfCurrentItem).isFile()) {
            filesCollection.Push(pathOfCurrentItem);
        }
        else if (!fileShouldBeSkipped) {
            var directorypath = path.join(directory + '\\' + file);
            readDirectorySynchronously(directorypath);
        }
    });
}

readDirectorySynchronously('');

Dadurch wird filesCollection mit allen Dateien im Verzeichnis und seinen Unterverzeichnissen gefüllt (rekursiv). Sie haben die Möglichkeit, einige Verzeichnisnamen im DirectoriesToSkip array zu überspringen.

1
vvn050

Hier ist meins. Wie alle guten Antworten ist es schwer zu verstehen:

const isDirectory = path => statSync(path).isDirectory();
const getDirectories = path =>
    readdirSync(path).map(name => join(path, name)).filter(isDirectory);

const isFile = path => statSync(path).isFile();  
const getFiles = path =>
    readdirSync(path).map(name => join(path, name)).filter(isFile);

const getFilesRecursively = (path) => {
    let dirs = getDirectories(path);
    let files = dirs
        .map(dir => getFilesRecursively(dir)) // go through each directory
        .reduce((a,b) => a.concat(b), []);    // map returns a 2d array (array of file arrays) so flatten
    return files.concat(getFiles(path));
};
1
user875234

Sie können auch Ihren eigenen Code wie unten beschrieben schreiben, um das Verzeichnis wie folgt zu durchsuchen:

var fs = require('fs');
function traverseDirectory(dirname, callback) {
  var directory = [];
  fs.readdir(dirname, function(err, list) {
    dirname = fs.realpathSync(dirname);
    if (err) {
      return callback(err);
    }
    var listlength = list.length;
    list.forEach(function(file) {
      file = dirname + '\\' + file;
      fs.stat(file, function(err, stat) {
        directory.Push(file);
 if (stat && stat.isDirectory()) {
          traverseDirectory(file, function(err, parsed) {
     directory = directory.concat(parsed);
     if (!--listlength) {
       callback(null, directory);
     }
   });
 } else {
     if (!--listlength) {
       callback(null, directory);
     }
          }
      });
    });
  });
}
traverseDirectory(__dirname, function(err, result) {
  if (err) {
    console.log(err);
  }
  console.log(result);
});

Weitere Informationen hierzu finden Sie hier: http://www.codingdefined.com/2014/09/how-to-navigate-through-directories-in.html

0
CodingDefined

Ich habe meins mit TypeScript gut verstanden

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

    export const getAllSubFolders = (
      baseFolder: string,
      folderList: string[] = []
    ) => {
      const folders: string[] = fs
        .readdirSync(baseFolder)
        .filter(file => fs.statSync(path.join(baseFolder, file)).isDirectory());
      folders.forEach(folder => {
        folderList.Push(path.join(baseFolder, folder));
        getAllSubFolders(path.join(baseFolder, folder), folderList);
      });
      return folderList;
    };
    export const getFilesInFolder = (rootPath: string) => {
      return fs
        .readdirSync(rootPath)
        .filter(
          filePath => !fs.statSync(path.join(rootPath, filePath)).isDirectory()
        )
        .map(filePath => path.normalize(path.join(rootPath, filePath)));
    };
    export const getFilesRecursively = (rootPath: string) => {
      const subFolders: string[] = getAllSubFolders(rootPath);
      const allFiles: string[][] = subFolders.map(folder =>
        getFilesInFolder(folder)
      );
      return [].concat.apply([], allFiles);
    };
0
Chris Sprance