it-swarm.com.ru

Как получить список имен всех файлов, присутствующих в каталоге в Node.js?

Я пытаюсь получить список имен всех файлов, присутствующих в каталоге, используя Node.js. Я хочу вывод, который является массивом имен файлов. Как я могу это сделать?

726
resopollution

Вы можете использовать методы fs.readdir или 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);
});

Разница между этими двумя методами заключается в том, что первый метод является асинхронным, поэтому вы должны предоставить функцию обратного вызова, которая будет выполняться после завершения процесса чтения.

Второй является синхронным, он вернет массив имен файлов, но остановит дальнейшее выполнение вашего кода, пока не завершится процесс чтения.

988
CMS

Ответ выше не выполняет рекурсивный поиск в каталоге. Вот что я сделал для рекурсивного поиска (используя node-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);
});
172
Ruben Tan

IMO самый удобный способ выполнить такие задачи - использовать инструмент glob . Вот глобальный пакет для node.js. Установить с

npm install glob

Затем используйте подстановочный знак для сопоставления имен файлов (пример взят с сайта пакета)

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

Получить файлы во всех подкаталогах

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

Вот простое решение с использованием только собственных модулей fs и 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);
        }
    });
}

или асинхронная версия (вместо нее используется fs.readdir):

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

Тогда вы просто позвоните (для синхронизации версии):

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

или асинхронная версия:

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

Разница в том, как блокирует узлы при выполнении ввода-вывода. Учитывая, что API выше, вы можете просто использовать асинхронную версию для обеспечения максимальной производительности.

Однако есть одно преимущество использования синхронной версии. Некоторый код легче выполнить, как только завершится обход, как в следующем операторе после обхода. В асинхронной версии вам понадобится дополнительный способ узнать, когда вы закончите. Возможно, сначала создайте карту всех путей, а затем перечислите их. Для простых сценариев сборки/утилит (против высокопроизводительных веб-серверов) вы можете использовать синхронизирующую версию без какого-либо ущерба.

55
Ali

Использование обещаний с ES7

Асинхронное использование с mz/fs

Модуль mz предоставляет многообещающие версии библиотеки базовых узлов. Использовать их просто. Сначала установите библиотеку ...

npm install mz

Затем...

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

В качестве альтернативы вы можете написать их в асинхронных функциях в ES7:

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

Обновление для рекурсивного листинга

Некоторые пользователи указали желание увидеть рекурсивный листинг (хотя и не в вопросе) ... Используйте fs-promise . Это тонкая обертка вокруг mz .

npm install fs-promise;

затем...

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

Зависимости.

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

Определение.

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

Использование.

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

Обратите внимание, что fileList слишком оптимистичен. Для чего-то серьезного, добавьте обработку ошибок.

15
Hunan Rostomyan

Вы не говорите, что хотите сделать это рекурсивно, поэтому я предполагаю, что вам нужны только прямые дочерние элементы каталога.

Образец кода:

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

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

Загрузить fs:

const fs = require('fs');

Чтение файлов async :

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

Чтение файлов синхронизация :

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

Вот асинхронная рекурсивная версия.

    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()
    }
4
Oggy Transfluxitor Jones

Взял общий подход к @ Hunan-Rostomyan, сделал его немного более лаконичным и добавил аргумент excludeDirs. Было бы тривиально расширить с помощью includeDirs, просто следуя той же схеме:

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

Пример использования:

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

Получить sorted имена файлов. Вы можете фильтровать результаты на основе определенной extension, такой как '.txt', '.jpg' и так далее.

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

если кто-то все еще ищет это, я делаю это:

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

и его работа очень хорошо для меня

1
Josh

Это TypeScript, опционально рекурсивный, опционально протоколирование ошибок и асинхронное решение. Вы можете указать регулярное выражение для имен файлов, которые вы хотите найти.

Я использовал fs-extra, потому что это легкое супер-набор улучшений 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
}
0
Paul F. Wood

Начиная с узла 10.10.0, можно использовать новую опцию withFileTypes для fs.readdir и fs.readdirSync в сочетании с функцией dirent.isDirectory() для фильтрации имен файлов в каталоге. Это выглядит так:

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

Возвращенный массив имеет вид:

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

Документы для класса fs.Dirent

0
bnp887

Используйте npmсписок содержимого модуль. Он читает содержимое и под-содержимое данного каталога и возвращает список путей к файлам и папкам.

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

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

Я сделал модуль узла для автоматизации этой задачи: mddir

Использование

узел mddir "../relative/path/"

Для установки: npm установить mddir -g

Чтобы создать уценку для текущего каталога: mddir

Чтобы сгенерировать для любого абсолютного пути: mddir/absolute/path

Чтобы сгенерировать относительный путь: mddir ~/Documents/what.

MD-файл генерируется в вашем рабочем каталоге.

В настоящее время игнорирует node_modules и папки .git.

Поиск проблемы

Если вы получаете сообщение об ошибке «узел\r: нет такого файла или каталога», проблема заключается в том, что ваша операционная система использует разные окончания строк, и mddir не сможет их проанализировать без явного задания стиля окончания строк в Unix. Обычно это влияет на Windows, но также и на некоторые версии Linux. Установка конца строки в стиле Unix должна выполняться в глобальной папке bin mddir npm.

Исправление концов строки

Получить путь к папке npm bin с помощью:

npm config get prefix

Компакт-диск в эту папку

заварить установить dos2unix

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

Это преобразует окончания строк в Unix вместо Dos

Затем запустите как обычно с: node mddir "../relative/path/".

Пример сгенерированной структуры файла уценки '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
0
John Byrne

Вы также можете сделать это рекурсивно.

Для этого есть модуль NPM: 

npm dree

Это позволяет вам иметь представление дерева каталогов в виде строки или объекта. С помощью функции обратного вызова вы также можете достичь своей цели. Если вы хотите, вы также можете указать, какие расширения файлов для рассмотрения. 

Вот код:

const dree = require('dree');

const fileNames = [];
const fileCb = function(file) {
    fileNames.Push(file.name);
}

dree.scan('path-to-directory', { extensions: [ 'html', 'js' ] }, fileCb);

console.log(fileNames); // All the html and js files inside the given folder and its subfolders
0
EuberDeveloper

Просто наперед: если вы планируете выполнять операции с каждым файлом в каталоге, попробуйте vinyl-fs (который используется gulp , системой потоковой сборки).

0
XåpplI'-I0llwlg'I -