Node.js 디렉토리에 있는 모든 파일 이름 목록을 가져오려면 어떻게 해야 합니까?

Node.js 디렉토리에 있는 모든 파일 이름 목록을 가져오려면 어떻게 해야 합니까?

Node.js를 사용하여 디렉토리에 있는 모든 파일 이름 목록을 가져오려고 합니다.파일명이 배열된 출력을 원합니다.이거 어떻게 해?

또는 메서드를 사용할 수 있습니다. fsNode.js 코어에 포함되어 있기 때문에 아무것도 설치할 필요가 없습니다.

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는 이러한 작업을 수행하는 가장 편리한 방법으로 글로벌 도구를 사용하는 것입니다.이것은 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.
})

globby를 사용하는 경우 현재 폴더 아래에 있는 XML 파일을 찾는 예를 보여 줍니다.

var globby = require('globby');

const paths = await globby("**/*.xml");  

그러나 위의 답변은 디렉토리에 대한 재귀 검색을 수행하지 않습니다.재귀 검색을 위해 수행한 작업은 다음과 같습니다(노드 워크 사용: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);
});

모든 서브디르에서 파일 가져오기

const fs=require('fs');

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

Node Node v10.10.0 을 할 수 .withFileTypes디렉토리내의 파일명을 필터링 하는 기능과 를 조합한 옵션.이것은 다음과 같습니다.

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

반환되는 어레이는 다음 형식입니다.

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

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

async 를 사용)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가 동일하기 때문에 비동기 버전을 사용하여 성능을 최대한 높일 수 있습니다.

그러나 동기 버전을 사용하는 데는 한 가지 이점이 있습니다.걷기 후 다음 문에서처럼 걷기 작업이 완료되자마자 일부 코드를 실행하는 것이 더 쉽습니다.비동기 버전에서는 완료 시기를 알 수 있는 추가 방법이 필요합니다.먼저 모든 경로의 맵을 만든 다음 열거합니다.심플한 빌드/유틸리티 스크립트(하이 퍼포먼스 웹 서버 대비)에서는, 파손을 일으키지 않고 동기 버전을 사용할 수 있습니다.

ES7에서의 약속 사용

mz/fs에서의 비동기 사용

모듈은 코어 노드 라이브러리의 프로미스 버전을 제공합니다.사용법은 간단합니다.먼저 라이브러리 설치...

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

재귀 목록 업데이트

일부 사용자가 재귀 목록을 표시하도록 지정했습니다(질문에는 없지만).사용. 얇은 포장지입니다.

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

비호환 버전

재귀적으로 하고 싶다고는 말하지 않기 때문에 디렉토리의 직계 자녀만 있으면 될 것 같습니다.

샘플 코드:

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

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

의존관계

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너무 낙관적이다.심각한 경우에는 오류 처리를 추가합니다.

당신의 질문으로 미루어 짐작하건대 디렉토리 이름은 원하지 않고 파일만 원하는 것 같군요.

디렉토리 구조 예시

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

Walk

Justin Maier에게 크레딧이 주어집니다.

경로에서 사용하는 파일 배열만 원하는 경우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), []);
}

사용.

async function main() {
   console.log(await walk('animals'))
}

산출량

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

누군가 아직도 이걸 찾고 있다면, 난 이렇게 할 거야:

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

그리고 그것은 나에게 매우 좋다.

★★fs:

const fs = require('fs');

비동기 파일 읽기:

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

읽기 파일 동기화:

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

하나뿐인 라이너 코드:

const fs = require("fs")
const path = 'somePath/'

const filesArray = fs.readdirSync(path).filter(file => fs.lstatSync(path+file).isFile())

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

내 2센트는 누군가:

프로젝트의 로컬 하위 폴더에서 파일 이름(디렉토리 제외)을 나열하고 싶다

• ✅추가 의존관계 없음
• ✅ 1 기능
• ✅ 경로 정규화(Unix vs.Windows)

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

/**
 * @param {string} relativeName "resources/foo/goo"
 * @return {string[]}
 */
const listFileNames = (relativeName) => {
  try {
    const folderPath = path.join(process.cwd(), ...relativeName.split("/"));
    return fs
      .readdirSync(folderPath, { withFileTypes: true })
      .filter((dirent) => dirent.isFile())
      .map((dirent) => dirent.name.split(".")[0]);
  } catch (err) {
    // ...
  }
};

README.md
package.json
resources
 |-- countries
    |-- usa.yaml
    |-- japan.yaml
    |-- gb.yaml
    |-- provinces
       |-- .........


listFileNames("resources/countries") #=> ["usa", "japan", "gb"]

이것은 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
}

즉시 사용 가능

디렉토리 구조를 즉시 사용할 수 있는 오브젝트를 원하는 경우 디렉토리 트리를 체크할 것을 강력히 권장합니다.

예를 들어 다음과 같은 구조를 가지고 있다고 합시다.

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

커스텀 오브젝트

또는 커스텀 설정으로 디렉토리 트리 오브젝트를 작성하는 경우는, 다음의 스니펫을 참조해 주세요.이 코드 및 상자에 라이브 예가 표시됩니다.

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

코드 두 줄만 있으면 됩니다.

fs=require('fs')
fs.readdir("./img/", (err,filename)=>console.log(filename))

이미지:

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

    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-Lastomyan을 했다.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']));

platMap 사용:

function getFiles(dir) {
  return fs.readdirSync(dir).flatMap((item) => {
    const path = `${dir}/${item}`;
    if (fs.statSync(path).isDirectory()) {
      return getFiles(path);
    }

    return path;
  });
}

다음 디렉토리가 지정됩니다.

dist
├── 404.html
├── app-AHOLRMYQ.js
├── img
│   ├── demo.gif
│   └── start.png
├── index.html
└── sw.js

사용방법:

getFiles("dist")

출력:

[
  'dist/404.html',
  'dist/app-AHOLRMYQ.js',
  'dist/img/demo.gif',
  'dist/img/start.png',
  'dist/index.html'
]

이거 먹어봐, 난 괜찮아

import fs from 'fs/promises';
const files= await fs.readdir('path/to/folder');
console.log(files); // array

나는 주로 FS-Extra를 사용한다.

const fileNameArray = Fse.readdir('/some/path');

결과:

[
  "b7c8a93c-45b3-4de8-b9b5-a0bf28fb986e.jpg",
  "daeb1c5b-809f-4434-8fd9-410140789933.jpg"
]

주의사항: 디렉토리 내의 각 파일에 대해 작업을 수행할 예정이라면 vinyl-fs(스트리밍 빌드 시스템인 gulp에 의해 사용됨)를 사용해 보십시오.

이렇게 하면 결과가 테스트에 저장되고 작동합니다.같은 디렉토리에 존재하는 txt 파일

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

저는 최근에 이 작업을 위한 도구를 만들었습니다. 바로 이 작업을...비동기적으로 디렉토리를 가져오고 항목 목록을 반환합니다.디렉토리, 파일, 또는 그 양쪽 모두를 취득할 수 있습니다.폴더를 선두로 합니다.전체 폴더를 가져오지 않으려는 경우 데이터 페이지를 지정할 수도 있습니다.

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

이 링크입니다. 도움이 되길 바랍니다!

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

사용.

노드 mdir "../module/path/"

설치 방법: npm install mdir -g

현재 디렉토리의 마크다운을 생성하려면: mdir

임의의 절대 경로에 대해 생성하려면 mdir /absolute/path

상대 경로에 대해 생성하려면 mdir ~/Documents/anything.

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

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

트러블 슈팅

'node\r: No such file or directory'라는 오류가 표시되는 경우 운영체제는 다른 행 엔딩을 사용하고 있으며 mdir는 행 엔딩 스타일을 UNIX로 명시적으로 설정하지 않으면 이러한 엔딩을 해석할 수 없습니다.이 문제는 보통 Windows뿐만 아니라 Linux 일부 버전에도 영향을 미칩니다.행 끝을 Unix 스타일로 설정하는 작업은 mdir npm 글로벌 bin 폴더 내에서 수행해야 합니다.

회선 끝의 수정

npm bin 폴더 경로 가져오기:

npm config get prefix

그 폴더에 CD를 넣습니다.

brew install dos2built

dos2disp lib/node_disp/mdir/src/mdir.disp

이렇게 하면 행 엔딩이 DOS가 아닌 Unix로 변환됩니다.

그런 다음 node mdir "../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 목록 표시 모듈지정된 디렉터리의 내용 및 하위 내용을 읽고 파일 및 폴더 경로 목록을 반환합니다.

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

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

위의 많은 옵션이 너무 복잡하거나 복잡하지 않은 경우 노드 맵을 사용하는 다른 접근법도 있습니다.https://github.com/fshost/node-dir

npm install node-dir

서브 디렉토리에서 검색되는 모든 .xml 파일을 나열하는 간단한 함수는 다음과 같습니다.

import * as nDir from 'node-dir' ;

listXMLs(rootFolderPath) {
    let xmlFiles ;

    nDir.files(rootFolderPath, function(err, items) {
        xmlFiles = items.filter(i => {
            return path.extname(i) === '.xml' ;
        }) ;
        console.log(xmlFiles) ;       
    });
}

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

언급URL : https://stackoverflow.com/questions/2727167/how-do-you-get-a-list-of-the-names-of-all-files-present-in-a-directory-in-node-j