Node.js를 사용하여 디렉토리에있는 모든 파일의 이름 목록을 얻으려고합니다. 파일 이름의 배열 인 출력을 원합니다. 어떻게해야합니까?

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

두 메소드의 차이점은 첫 번째 메소드는 비동기 적이므로 읽기 프로세스가 종료 될 때 실행될 콜백 함수를 제공해야한다는 것입니다.

두 번째는 동기식이며 파일 이름 배열을 반환하지만 읽기 프로세스가 끝날 때까지 코드의 추가 실행을 중지합니다.

이러한 작업을 수행하기 위해 IMO 가장 convinient 방법은 사용하는 것입니다 글로브의 도구를. 다음 은 node.js를위한 glob 패키지 입니다. 함께 설치

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

위의 대답은 디렉토리에 대한 재귀 검색을 수행하지 않습니다. 여기에 내가 재귀 검색에 무슨 짓을했는지 (사용 노드 산책 : 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);
});

모든 하위 디렉토리에서 파일 가져 오기

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

다음은 기본 모듈 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"...
});

차이점은 IO를 수행하는 동안 노드가 어떻게 차단되는지에 있습니다. 위의 API가 같으면 비동기 버전을 사용하여 최대 성능을 보장 할 수 있습니다.

그러나 동기식 버전을 사용하면 한 가지 이점이 있습니다. 보행 후 다음 명령문에서와 같이 보행이 완료 되 자마자 일부 코드를 실행하는 것이 더 쉽습니다. 비동기 버전을 사용하면 완료 시점을 알 수있는 추가 방법이 필요합니다. 아마도 모든 경로의 맵을 먼저 만든 다음 열거합니다. 간단한 빌드 / 유틸리티 스크립트 (고성능 웹 서버)의 경우 동기화 버전을 손상없이 사용할 수 있습니다.

노드 v10.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 클래스 용 문서

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

의존성.

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너무 낙관적이다. 심각한 일이 있으면 오류 처리를 추가하십시오.

비 재귀 버전

당신은 당신이 그것을 재귀 적으로하고 싶다고 말하지 않으므로 디렉토리의 직접적인 자식 만 필요하다고 가정합니다.

샘플 코드 :

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

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

짐 fs:

const fs = require('fs');

비동기 파일 읽기 :

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

읽기 파일 동기화 :

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

누군가가 여전히 이것을 찾고 있다면, 나는 이것을한다 :

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

그 작업은 저에게 아주 좋습니다

가져 오기 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();
}

귀하의 질문에서 디렉토리 이름을 원하지 않고 파일 만 원한다고 가정합니다.

예:

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

파일 경로 의 배열 만 원한다면 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'))

보고:

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

크레딧은 https://gist.github.com/lovasoa/8691344#gistcomment-2927279 로 이동 하십시오.

비동기 재귀 버전이 있습니다.

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

@ 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']));

상자 밖으로

디렉토리 구조를 가진 객체 를 원할 경우 디렉토리 트리 를 확인하는 것이 좋습니다. .

이 구조를 가지고 있다고 가정 해 봅시다.

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

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

돌아올 것이다 :

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

커스텀 객체

그렇지 않으면 사용자 정의 설정으로 디렉토리 트리 객체 를 만들려면 다음 스 니펫을 살펴보십시오. 이 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 };

그런 다음 간단히 할 수 있습니다.

// another-file.js 

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

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

이것은 선택적으로 재귀 적이며 선택적으로 오류 로깅 및 비동기 솔루션 인 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
}

이것은 작동하고 동일한 디렉토리에있는 test.txt 파일에 결과를 저장합니다

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

최근 에이 작업을 수행하는 도구를 만들었습니다 ... 디렉토리를 비동기 적으로 가져 와서 항목 목록을 반환합니다. 폴더가 첫 번째 인 디렉토리, 파일 또는 둘 다를 가져올 수 있습니다. 전체 폴더를 가져 오지 않으려는 경우 데이터를 페이지 매김 할 수도 있습니다.

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

이것은 링크입니다, 누군가를 돕기를 바랍니다!

디렉토리에있는 각 파일에 대해 작업을 수행하려는 경우 Vinyl-fs ( 스트리밍 빌드 시스템 인 gulp 에서 사용)를 사용해보십시오 .

이 작업을 자동화하기 위해 노드 모듈을 만들었습니다. mddir

용법

노드 mddir "../relative/path/"

설치하려면 다음을 수행하십시오. npm install mddir -g

현재 디렉토리에 대한 마크 다운을 생성하려면 : mddir

절대 경로를 생성하려면 다음을 수행하십시오. mddir / absolute / path

상대 경로를 생성하려면 : mddir ~ / Documents / whatever.

md 파일은 작업 디렉토리에 생성됩니다.

현재 node_modules 및 .git 폴더는 무시합니다.

문제 해결

'node \ r : No such file or directory'오류가 표시되면 운영 체제에서 다른 줄 끝을 사용하고 줄 끝 스타일을 Unix로 명시 적으로 설정하지 않으면 mddir에서 구문을 분석 할 수 없다는 것입니다. 이것은 일반적으로 Windows뿐만 아니라 일부 Linux 버전에도 영향을 미칩니다. 줄 끝을 Unix 스타일로 설정하려면 mddir npm 전역 bin 폴더 내에서 수행해야합니다.

줄 끝 수정

다음을 사용하여 npm bin 폴더 경로를 가져옵니다.

npm config get prefix

해당 폴더에 CD

brew install dos2unix

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

이것은 줄 끝을 Dos 대신 Unix로 변환합니다.

그런 다음 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

npm list-contents 모듈을 사용하십시오 . 주어진 디렉토리의 내용과 하위 내용을 읽고 파일 및 폴더 경로 목록을 반환합니다.

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