Sto cercando di ottenere un elenco dei nomi di tutti i file presenti in una directory usando Node.js. Voglio un output che sia una matrice di nomi di file. Come posso fare questo?

È possibile utilizzare i metodi fs.readdiro 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);
});

La differenza tra i due metodi è che il primo è asincrono, quindi è necessario fornire una funzione di callback che verrà eseguita al termine del processo di lettura.

Il secondo è sincrono, restituirà l'array del nome file, ma interromperà qualsiasi ulteriore esecuzione del codice fino al termine del processo di lettura.

L'IMO il modo più conveniente per svolgere tali compiti è usare uno strumento glob . Ecco un pacchetto glob per node.js. Installa con

npm install glob

Quindi utilizzare il carattere jolly per abbinare i nomi dei file (esempio tratto dal sito Web del pacchetto)

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

La risposta sopra non esegue tuttavia una ricerca ricorsiva nella directory. Ecco quello che ho fatto per una ricerca ricorsiva (usando nodo-passeggiata : 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);
});

Ottieni file in tutti i sottodiretti

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'))

Ecco una soluzione semplice che utilizza solo i moduli nativi fse path:

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

o versione asincrona (utilizza fs.readdirinvece):

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

Quindi basta chiamare (per la versione di sincronizzazione):

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

o versione asincrona:

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

La differenza sta nel modo in cui il nodo si blocca durante l'esecuzione dell'IO. Dato che l'API sopra è la stessa, puoi semplicemente utilizzare la versione asincrona per garantire le massime prestazioni.

Tuttavia, esiste un vantaggio nell'uso della versione sincrona. È più semplice eseguire un po 'di codice non appena viene eseguita la camminata, come nella dichiarazione successiva dopo la camminata. Con la versione asincrona, avresti bisogno di un modo extra per sapere quando hai finito. Forse prima creando una mappa di tutti i percorsi, quindi enumerandoli. Per semplici script build / util (vs server Web ad alte prestazioni) è possibile utilizzare la versione di sincronizzazione senza causare danni.

A partire dal Nodo v10.10.0, è possibile utilizzare la nuova withFileTypesopzione per fs.readdire fs.readdirSyncin combinazione con la dirent.isDirectory()funzione per filtrare i nomi dei file in una directory. Sembra così:

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

L'array restituito è nel formato:

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

Documenti per la classe fs.Dirent

Utilizzo di Promises con ES7

Uso asincrono con mz / fs

Il mzmodulo fornisce versioni promesse della libreria del nodo principale. Usarli è semplice. Prima installa la libreria ...

npm install mz

Poi...

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

In alternativa puoi scriverli in funzioni asincrone in ES7:

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

Aggiornamento per elenco ricorsivo

Alcuni utenti hanno specificato il desiderio di vedere un elenco ricorsivo (anche se non nella domanda) ... Usa fs-promise. È un involucro sottile in giro mz.

npm install fs-promise;

poi...

const fs = require('fs-promise');
fs.walk('./myDir').then(
    listing => listing.forEach(file => console.log(file.path))
).catch(err => console.error(err));

Dipendenze.

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

Definizione.

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

Uso.

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', ...]

Si noti che fileListè troppo ottimista. Per qualsiasi cosa seria, aggiungi un po 'di gestione degli errori.

versione non ricorsiva

Non dici che vuoi farlo in modo ricorsivo, quindi presumo che tu abbia bisogno solo di figli diretti della directory.

Codice di esempio:

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

fs.readdirSync('your-directory-path')
  .filter((file) => fs.lstatSync(path.join(folder, file)).isFile());

Carico fs:

const fs = require('fs');

Leggi i file asincroni :

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

Sincronizzazione dei file di lettura :

var files = fs.readdirSync('./dir');

se qualcuno cerca ancora questo, lo faccio:

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];
    }, []);

e il suo lavoro è molto buono per me

Ottieni sortednomi di file. È possibile filtrare i risultati in base a una specifica extension, come '.txt', '.jpg'e così via.

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

Presumo dalla tua domanda che non vuoi nomi di directory, solo file.

Esempio:

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

Se si desidera solo una matrice dei percorsi dei file, utilizzare 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'))

ritorna:

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

I crediti vanno su https://gist.github.com/lovasoa/8691344#gistcomment-2927279

Ecco una versione ricorsiva asincrona.

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

Ha preso l'approccio generale di @ Hunan-Rostomyan, rendendolo un po 'più conciso e aggiunto excludeDirsargomento. Sarebbe banale estenderlo includeDirs, basta seguire lo stesso schema:

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]);
    }, []);
}

Esempio di utilizzo:

console.log(fileList('.', ['node_modules', 'typings', 'bower_components']));

Fuori dalla scatola

Nel caso in cui desideri un oggetto con la struttura della directory pronta all'uso, ti consiglio vivamente di controllare l' albero delle directory .

Diciamo che hai questa struttura:

photos
│   june
│   └── windsurf.jpg
└── january
    ├── ski.png
    └── snowboard.jpg

const dirTree = require("directory-tree");
const tree = dirTree("/path/to/photos");

Tornerà:

{
  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"
        }
      ]
    }
  ]
}

Oggetto personalizzato

Altrimenti, se si desidera creare un oggetto della struttura di directory con le proprie impostazioni personalizzate, consultare il frammento seguente. Un esempio dal vivo è visibile su questo codesandbox .

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

Quindi puoi semplicemente fare:

// another-file.js 

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

const allFiles = getAllFiles("/path/to/my-directory");

Si tratta di una soluzione TypeScript, facoltativamente ricorsiva, facoltativa di registrazione degli errori e asincrona. È possibile specificare un'espressione regolare per i nomi dei file che si desidera trovare.

L'ho usato fs-extra, perché è un facile miglioramento del super set 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
}

Questo funzionerà e memorizzerà il risultato nel file test.txt che sarà presente nella stessa directory

  fs.readdirSync(__dirname).forEach(file => {
    fs.appendFileSync("test.txt", file+"\n", function(err){
    })
})

Di recente ho creato uno strumento per questo che fa proprio questo ... Recupera una directory in modo asincrono e restituisce un elenco di elementi. Puoi ottenere directory, file o entrambi, con le cartelle al primo posto. Puoi anche impaginare i dati nel caso in cui non desideri recuperare l'intera cartella.

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

Questo è il link, spero che aiuti qualcuno!

Solo un avvertimento: se hai intenzione di eseguire operazioni su ciascun file in una directory, prova vinyl-fs (che è usato da gulp , il sistema di compilazione in streaming).

Ho creato un modulo nodo per automatizzare questo compito: mddir

uso

node mddir "../relative/path/"

Per installare: npm install mddir -g

Per generare markdown per la directory corrente: mddir

Per generare per qualsiasi percorso assoluto: mddir / absolute / path

Per generare per un percorso relativo: mddir ~ / Documents / qualunque.

Il file md viene generato nella directory di lavoro.

Attualmente ignora le cartelle node_modules e .git.

Risoluzione dei problemi

Se viene visualizzato l'errore "nodo \ r: nessun file o directory", il problema è che il sistema operativo utilizza terminazioni di linea diverse e mddir non può analizzarle senza che tu abbia impostato esplicitamente lo stile di fine linea su Unix. Questo di solito interessa Windows, ma anche alcune versioni di Linux. L'impostazione delle terminazioni di linea in stile Unix deve essere eseguita nella cartella bin globale di mddir npm.

Correzione delle terminazioni di linea

Ottieni il percorso della cartella bin npm con:

npm config get prefix

Cd in quella cartella

brew install dos2unix

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

Questo converte le terminazioni di linea in Unix anziché in Dos

Quindi eseguire normalmente: node mddir "../relative/path/".

Esempio di struttura del file di markdown generata '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

Usa il modulo npm elenco-contenuti . Legge i contenuti e i contenuti secondari della directory specificata e restituisce l'elenco dei percorsi di file e cartelle.

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

list("./dist",(o)=>{
  if(o.error) throw o.error;
   console.log('Folders: ', o.dirs);
   console.log('Files: ', o.files);
});

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