Saya mencoba untuk mendapatkan daftar nama-nama semua file yang ada di direktori menggunakan Node.js. Saya ingin output yang merupakan array dari nama file. Bagaimana saya bisa melakukan ini?

Anda dapat menggunakan metode fs.readdiratau 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);
});

Perbedaan antara kedua metode, adalah bahwa yang pertama asinkron, jadi Anda harus menyediakan fungsi panggilan balik yang akan dieksekusi ketika proses membaca berakhir.

Yang kedua adalah sinkron, itu akan mengembalikan array nama file, tetapi akan menghentikan eksekusi lebih lanjut dari kode Anda sampai proses membaca berakhir.

IMO cara paling mudah untuk melakukan tugas-tugas tersebut adalah dengan menggunakan alat glob . Berikut adalah paket glob untuk node.js. Instal dengan

npm install glob

Kemudian gunakan wild card untuk mencocokkan nama file (contoh diambil dari situs web paket)

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

Jawaban di atas tidak melakukan pencarian rekursif ke direktori. Inilah yang saya lakukan untuk pencarian rekursif (menggunakan simpul-jalan : 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);
});

Dapatkan file di semua subdir

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

Inilah solusi sederhana dengan hanya menggunakan modul asli fsdan 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);
        }
    });
}

atau versi async ( fs.readdirsebagai gantinya):

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

Maka Anda cukup memanggil (untuk versi sinkronisasi):

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

atau versi async:

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

Perbedaannya terletak pada bagaimana node memblok saat melakukan IO. Mengingat bahwa API di atas sama, Anda bisa menggunakan versi async untuk memastikan kinerja maksimum.

Namun ada satu keuntungan menggunakan versi sinkron. Lebih mudah untuk mengeksekusi beberapa kode segera setelah perjalanan selesai, seperti pada pernyataan berikutnya setelah berjalan. Dengan versi async, Anda perlu cara ekstra untuk mengetahui kapan Anda selesai. Mungkin membuat peta dari semua jalur terlebih dahulu, lalu menghitungnya. Untuk skrip build / util sederhana (vs server web berkinerja tinggi) Anda dapat menggunakan versi sinkronisasi tanpa menyebabkan kerusakan.

Pada Node v10.10.0, dimungkinkan untuk menggunakan withFileTypesopsi baru untuk fs.readdirdan fs.readdirSyncdalam kombinasi dengan dirent.isDirectory()fungsi untuk memfilter nama file dalam direktori. Itu terlihat seperti ini:

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

Array yang dikembalikan dalam bentuk:

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

Documents untuk fs.Dirent class

Menggunakan Janji dengan ES7

Penggunaan asinkron dengan mz / fs

The mzmodul menyediakan versi promisified perpustakaan inti simpul. Menggunakannya sederhana. Pertama instal perpustakaan ...

npm install mz

Kemudian...

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

Atau Anda dapat menuliskannya dalam fungsi asinkron di ES7:

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

Perbarui untuk daftar rekursif

Beberapa pengguna telah menetapkan keinginan untuk melihat daftar rekursif (meskipun tidak dalam pertanyaan) ... Gunakan fs-promise. Ini pembungkus tipis di sekitar mz.

npm install fs-promise;

kemudian...

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

Ketergantungan.

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

Definisi.

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

Pemakaian.

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

Harap dicatat bahwa fileListitu terlalu optimis. Untuk hal yang serius, tambahkan beberapa penanganan kesalahan.

versi non-rekursif

Anda tidak mengatakan Anda ingin melakukannya secara rekursif jadi saya menganggap Anda hanya perlu anak langsung dari direktori.

Kode sampel:

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

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

Memuat fs:

const fs = require('fs');

Baca file async :

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

Baca sinkronisasi file :

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

jika seseorang masih mencari ini, saya melakukan ini:

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

dan kerjanya sangat bagus untuk saya

Dapatkan sortednama file. Anda dapat memfilter hasil berdasarkan spesifik extensionseperti '.txt', '.jpg'dan sebagainya.

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

Saya berasumsi dari pertanyaan Anda bahwa Anda tidak ingin nama direktori, hanya file.

Contoh:

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

Jika Anda hanya menginginkan larik jalur file gunakan 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'))

pengembalian:

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

Kredit pergi ke https://gist.github.com/lovasoa/8691344#gistcomment-2927279

Berikut adalah versi rekursif asinkron.

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

Mengambil pendekatan umum @ Hunan-Rostomyan, membuatnya sedikit lebih ringkas dan menambahkan excludeDirsargumen. Akan sepele untuk memperpanjang dengan includeDirs, cukup ikuti pola yang sama:

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

Contoh penggunaan:

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

Keluar dari kotak

Jika Anda ingin objek dengan struktur direktori out-of-the-box saya sangat merekomendasikan Anda untuk memeriksa direktori-pohon .

Katakanlah Anda memiliki struktur ini:

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

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

Akan kembali:

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

Objek Khusus

Kalau tidak, jika Anda ingin membuat objek pohon direktori dengan pengaturan khusus Anda lihat potongan berikut. Contoh langsung dapat dilihat di kode dan kotak ini .

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

Maka Anda cukup melakukan:

// another-file.js 

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

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

Ini adalah TypeScript, opsional rekursif, opsional logging kesalahan dan solusi asinkron. Anda dapat menentukan ekspresi reguler untuk nama file yang ingin Anda temukan.

Saya menggunakan fs-extra, karena perbaikan set super mudah 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
}

Ini akan bekerja dan menyimpan hasilnya dalam file test.txt yang akan hadir di direktori yang sama

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

Saya baru-baru ini membangun alat untuk ini yang melakukan ini ... Ini mengambil direktori secara tidak sinkron dan mengembalikan daftar item. Anda bisa mendapatkan direktori, file, atau keduanya, dengan folder yang lebih dulu. Anda juga dapat membuat paginasi data jika Anda tidak ingin mengambil seluruh folder.

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

Ini tautannya, semoga membantu seseorang!

Hanya kepala: jika Anda berencana untuk melakukan operasi pada setiap file dalam direktori, coba vinyl-fs (yang digunakan oleh tegukan , sistem pembangunan streaming).

Saya membuat modul simpul untuk mengotomatisasi tugas ini: mddir

Pemakaian

simpul mddir "../relative/path/"

Untuk menginstal: npm install mddir -g

Untuk menghasilkan penurunan harga untuk direktori saat ini: mddir

Untuk menghasilkan untuk setiap jalur absolut: mddir / absolute / path

Untuk menghasilkan jalur relatif: mddir ~ / Documents / whatever.

File md dihasilkan di direktori kerja Anda.

Saat ini mengabaikan node_modules, dan folder .git.

Penyelesaian masalah

Jika Anda menerima kesalahan 'simpul \ r: Tidak ada file atau direktori', masalahnya adalah bahwa sistem operasi Anda menggunakan akhiran baris yang berbeda dan mddir tidak dapat menguraikannya tanpa Anda secara eksplisit mengatur gaya akhiran baris ke Unix. Ini biasanya mempengaruhi Windows, tetapi juga beberapa versi Linux. Pengaturan akhir baris ke gaya Unix harus dilakukan dalam folder bin global mddir npm.

Memperbaiki ujung garis

Dapatkan jalur folder npm bin dengan:

npm config get prefix

Cd ke folder itu

buat instalasi dos2unix

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

Ini mengubah akhiran baris menjadi Unix dan bukan Dos

Kemudian jalankan seperti biasa dengan: node mddir "../relative/path/".

Contoh menghasilkan struktur file penurunan direktori '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

Gunakan modul npm daftar-isi . Itu membaca isi dan sub-isi dari direktori yang diberikan dan mengembalikan daftar path file dan folder.

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