Tôi đang cố gắng để có được một danh sách tên của tất cả các tệp có trong một thư mục bằng Node.js. Tôi muốn đầu ra đó là một loạt các tên tập tin. Tôi có thể làm cái này như thế nào?

Bạn có thể sử dụng fs.readdirhoặc fs.readdirSyncphương pháp.

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

Sự khác biệt giữa hai phương thức là phương thức thứ nhất không đồng bộ, do đó bạn phải cung cấp hàm gọi lại sẽ được thực thi khi quá trình đọc kết thúc.

Thứ hai là đồng bộ, nó sẽ trả về mảng tên tệp, nhưng nó sẽ dừng mọi hoạt động thực thi mã khác của bạn cho đến khi quá trình đọc kết thúc.

IMO cách thuận tiện nhất để thực hiện các nhiệm vụ đó là sử dụng một công cụ toàn cầu . Đây là gói toàn cầu cho node.js. Cài đặt với

npm install glob

Sau đó sử dụng thẻ đại diện để khớp tên tệp (ví dụ được lấy từ trang web của gói)

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

Câu trả lời ở trên không thực hiện tìm kiếm đệ quy vào thư mục. Đây là những gì tôi đã làm cho một tìm kiếm đệ quy (sử dụng nút-đi bộ : 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);
});

Nhận tệp trong tất cả các thư mục con

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

Đây là một giải pháp đơn giản chỉ sử dụng mô đun gốc fsvà pathmô-đun:

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

hoặc phiên bản không đồng bộ (sử dụng fs.readdirthay thế):

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

Sau đó, bạn chỉ cần gọi (cho phiên bản đồng bộ):

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

hoặc phiên bản không đồng bộ:

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

Sự khác biệt là cách khối nút trong khi thực hiện IO. Vì API ở trên giống nhau, bạn chỉ có thể sử dụng phiên bản không đồng bộ để đảm bảo hiệu suất tối đa.

Tuy nhiên, có một lợi thế khi sử dụng phiên bản đồng bộ. Sẽ dễ dàng hơn để thực thi một số mã ngay khi bước đi được thực hiện, như trong câu lệnh tiếp theo sau khi đi bộ. Với phiên bản async, bạn sẽ cần thêm một số cách để biết khi nào bạn hoàn thành. Có lẽ tạo ra một bản đồ của tất cả các đường dẫn đầu tiên, sau đó liệt kê chúng. Đối với các tập lệnh xây dựng / sử dụng đơn giản (so với các máy chủ web hiệu suất cao), bạn có thể sử dụng phiên bản đồng bộ hóa mà không gây ra bất kỳ thiệt hại nào.

Kể từ Node v10.10.0, có thể sử dụng withFileTypestùy chọn mới cho fs.readdirvà fs.readdirSynckết hợp với dirent.isDirectory()chức năng để lọc tên tệp trong một thư mục. Trông như thế này:

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

Mảng trả về có dạng:

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

Tài liệu cho lớp fs.Dirent

Sử dụng lời hứa với ES7

Sử dụng không đồng bộ với mz / fs

Các mzmô-đun cung cấp các phiên bản promisified của thư viện nút lõi. Sử dụng chúng rất đơn giản. Đầu tiên cài đặt thư viện ...

npm install mz

Sau đó...

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

Ngoài ra, bạn có thể viết chúng trong các hàm không đồng bộ trong ES7:

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

Cập nhật cho danh sách đệ quy

Một số người dùng đã chỉ định mong muốn xem danh sách đệ quy (mặc dù không có trong câu hỏi) ... Sử dụng fs-promise. Đó là một lớp bọc mỏng xung quanh mz.

npm install fs-promise;

sau đó...

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

Phụ thuộc.

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

Định nghĩa.

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

Sử dụng.

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

Xin lưu ý rằng đó fileListlà cách quá lạc quan. Đối với bất cứ điều gì nghiêm trọng, thêm một số xử lý lỗi.

phiên bản không đệ quy

Bạn không nói rằng bạn muốn làm điều đó một cách đệ quy vì vậy tôi giả sử bạn chỉ cần con trực tiếp của thư mục.

Mã mẫu:

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

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

Tải fs:

const fs = require('fs');

Đọc các tệp async :

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

Đọc đồng bộ tệp :

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

Nếu ai đó vẫn tìm kiếm cái này, tôi sẽ làm cái này:

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

và nó hoạt động rất tốt cho tôi

Lấy sortedtên tập tin. Bạn có thể lọc kết quả dựa trên một cụ thể extensionnhư '.txt', '.jpg'v.v.

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

Tôi giả sử từ câu hỏi của bạn rằng bạn không muốn tên thư mục, chỉ tập tin.

Thí dụ:

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

Nếu bạn chỉ muốn một mảng các đường dẫn tệp, hãy sử dụng 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'))

trả về:

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

Tín dụng truy cập https://gist.github.com/lovasoa/8691344#gistcomment-2927279

Đây là một phiên bản đệ quy không đồng bộ.

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

Thực hiện cách tiếp cận chung của @ Hunan-Rostomyan, làm cho nó trở thành một excludeDirstranh luận ngắn gọn hơn và bổ sung . Nó là tầm thường để mở rộng với includeDirs, chỉ cần làm theo cùng một mô hình:

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

Ví dụ sử dụng:

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

Ngoài cái hộp

Trong trường hợp bạn muốn một đối tượng có cấu trúc thư mục bên ngoài, tôi rất khuyến khích bạn kiểm tra cây thư mục .

Hãy nói rằng bạn có cấu trúc này:

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

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

Sẽ trở lại:

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

Đối tượng tùy chỉnh

Mặt khác, nếu bạn muốn tạo một đối tượng cây thư mục với các cài đặt tùy chỉnh của bạn, hãy xem đoạn trích sau. Một ví dụ trực tiếp có thể nhìn thấy trên hộp mã này .

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

Sau đó, bạn có thể chỉ cần làm:

// another-file.js 

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

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

Đây là một TypeScript, tùy chọn đệ quy, ghi nhật ký lỗi tùy chọn và giải pháp không đồng bộ. Bạn có thể chỉ định một biểu thức chính quy cho tên tệp bạn muốn tìm.

Tôi đã sử dụng fs-extra, bởi vì nó là một cải tiến siêu dễ dàng trên 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
}

Điều này sẽ hoạt động và lưu trữ kết quả trong tệp test.txt sẽ có trong cùng thư mục

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

Gần đây tôi đã xây dựng một công cụ để thực hiện công việc này ... Nó tìm nạp một thư mục không đồng bộ và trả về một danh sách các mục. Bạn có thể lấy thư mục, tệp hoặc cả hai, với các thư mục là đầu tiên. Bạn cũng có thể phân trang dữ liệu trong trường hợp bạn không muốn tìm nạp toàn bộ thư mục.

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

Đây là liên kết, hy vọng nó sẽ giúp được ai đó!

Chỉ cần cảnh giác: nếu bạn dự định thực hiện các thao tác trên mỗi tệp trong một thư mục, hãy thử vinyl-fs (được sử dụng bởi gulp , hệ thống xây dựng phát trực tuyến).

Tôi đã tạo một mô-đun nút để tự động hóa nhiệm vụ này: mddir

Sử dụng

nút mddir "../relative/path/"

Để cài đặt: npm cài đặt mddir -g

Để tạo markdown cho thư mục hiện tại: mddir

Để tạo cho bất kỳ đường dẫn tuyệt đối: mddir / perfect / path

Để tạo đường dẫn tương đối: mddir ~ / Documents / anything.

Các tập tin md được tạo ra trong thư mục làm việc của bạn.

Hiện tại bỏ qua các thư mục node_modules và .git.

Xử lý sự cố

Nếu bạn nhận được lỗi 'nút \ r: Không có tệp hoặc thư mục như vậy', thì vấn đề là hệ điều hành của bạn sử dụng các kết thúc dòng khác nhau và mddir không thể phân tích chúng mà không cần bạn đặt kiểu kết thúc dòng thành Unix. Điều này thường ảnh hưởng đến Windows, nhưng cũng có một số phiên bản Linux. Việc đặt kết thúc dòng thành kiểu Unix phải được thực hiện trong thư mục bin toàn cầu mddir npm.

Sửa chữa kết thúc dòng

Nhận đường dẫn thư mục bin npm với:

npm config get prefix

Cd vào thư mục đó

pha cài đặt dos2unix

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

Điều này chuyển đổi kết thúc dòng thành Unix thay vì Dos

Sau đó chạy như bình thường với: nút mddir "../relative/path/".

Ví dụ tạo cấu trúc tệp markdown 'thư mụcList.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

Sử dụng mô-đun npm danh sách nội dung . Nó đọc nội dung và nội dung phụ của thư mục đã cho và trả về danh sách các đường dẫn của tệp và thư mục.

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