Bagaimana Anda mendapatkan daftar nama semua file yang ada di direktori di Node.js?

979

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?

resopollution
sumber
9
fs.readdirberfungsi, tetapi tidak bisa menggunakan nama file seperti pola glob ls /tmp/*core*. Lihat github.com/isaacs/node-glob . Glob bahkan dapat mencari di sub-direktori.
Jess
Periksa readdir-recursivemodul NPM jika Anda mencari nama file di subdirektori juga
Ethan Davis
1
fs.readdir adalah solusi async sederhana - contoh di sini
drorw
Masih belum menjawab menggunakan iterator? Saya memiliki 2,5 juta file untuk dipindai ... Saya tidak ingin mendapatkan daftar jalur 2,5 m setelah 10 menit.
Flavien Volken

Jawaban:

1342

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.

CMS
sumber
204
Catatan: readdirjuga menunjukkan nama direktori . Untuk memfilter ini, gunakan fs.stat(path, callback(err, stats))dan stats.isDirectory().
Rob W
3
Saya harus menambahkan bahwa paling mungkin Anda harus pergi dengan readdire karena Anda tidak ingin memblokir IO di node.
DragonKnight
5
@ user3705055 kecuali jika Anda menggunakan tegukan untuk membaca dalam direktori file yang bergantung pada urutan sumber dan mengkompilasinya menjadi satu yang dapat dieksekusi.
r3wt
2
@ Sabanc Anda ingin mencoba menguraikan output dari ls? Tunggu saja sampai ada orang yang membuat beberapa nama file dengan spasi dan baris baru ...
Radon Rosborough
201

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.
})
KFL
sumber
5
ini adalah solusi terbaik bagi saya karena saya ingin menentukan tipe file lebih mudah daripada perbandingan string. Terima kasih.
Pogrindis
Saya suka yang ini juga hanya karena globbing hampir merupakan keterampilan mendasar dalam simpul. Jika Anda hanya ingin mendapatkan nama file kembali, masukkan dalam cwdobjek pilihan.
jcollum
1
Bagaimana bisa mendapatkan hasil dari globluar itu sendiri? Misalnya. Saya ingin console.loghasil, tetapi tidak di dalam glob()?
Lanti
13
@ Lanti: glob.sync(pattern, [options])Metode ini mungkin lebih mudah digunakan karena hanya mengembalikan array nama file, daripada menggunakan panggilan balik. Info lebih lanjut di sini: github.com/isaacs/node-glob
Glenn Lawrence
2
Bagi orang-orang seperti saya yang mencari implementasi glob menggunakan Promises, periksa globby oleh sindresorhus: github.com/sindresorhus/globby
Nacho Coloma
180

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);
});
Ruben Tan
sumber
4
fs.readdirSync lebih baik, alternatif asli yang dibuat khusus untuk ini.
Eraden
37
Sayangnya, fs.readdirSync tidak masuk ke dalam sub direktori, kecuali jika Anda bersedia menulis rutin sendiri untuk melakukan hal itu, yang tidak Anda berikan bahwa sudah ada modul npm di luar sana untuk menyelesaikan masalah ini.
Ruben Tan
6
Berikut adalah tautan ke walk github repo + docs: github.com/coolaj86/node-walk
santiagoIT
OP tidak bertanya tentang API mana yang melakukan pembacaan berulang. Dalam kasus apa pun, jawaban yang diterima memberikan apa yang juga bisa berfungsi sebagai dasar untuk membuat bacaan rekursif.
Igwe Kalu
Ini adalah fungsi yang fantastis. Pertanyaan cepat: apakah ada cara cepat untuk mengabaikan dir tertentu? Saya ingin mengabaikan direktori yang dimulai dengan.git
j_d
91

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'))
Tito100
sumber
4
Mengapa if (typeof files_ === 'undefined') files_=[];? Anda hanya perlu melakukan var files_ = files_ || [];alih - alih files_ = files_ || [];.
jkutianski
4
Anda lupa menambahkan var fs = require('fs');di awal getFiles.
GFoley83
Ini adalah metode rekursif. Itu tidak mendukung struktur folder yang sangat dalam, yang akan menghasilkan Stack Overflow.
Mathias Lykkegaard Lorenzen
63

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.

Ali
sumber
1
Harus ganti saluran masuk walkSyncdari walk(filePath, callback);kewalkSync(filePath, callback);
MIDE11
3
Tapi Anda masih menggunakan fs.statSync, yang memblokir, dalam versi async. Bukankah Anda seharusnya menggunakan fs.stat saja?
MindlessRanger
Ini sangat membantu, dan metode ini bersifat rekursif. Terima kasih!
Little Roys
35

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

bnp887
sumber
7
Sejauh ini itulah jawaban terbaik di sini!
Alex Ivasyuv
2
inilah yang dicari orang pada tahun 2020 - harus "disematkan"
Val Redchenko
1
Jawaban terbaik 2020!
Yves Lange
26

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));
Evan Carroll
sumber
5
fs.walk dihapus dari fs-janji karena tidak didukung oleh fs ( github.com/kevinbeaty/fs-promise/issues/28 )
adnan
20

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.

Hunan Rostomyan
sumber
1
Saya menambahkan excludeDirsargumen array juga. Itu cukup mengubahnya sehingga mungkin Anda harus mengeditnya (jika Anda menginginkannya). Kalau tidak, saya akan menambahkannya dalam jawaban yang berbeda. gist.github.com/AlecTaylor/f3f221b4fb86b4375650
AT
1
@AT Bagus! Anda harus memposting jawaban Anda sendiri, karena itu ekstensi yang bermanfaat. Mari kita menjaga yang satu ini tanpa fitur.
Hunan Rostomyan
19

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());
Tyler Long
sumber
10

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');
Eduardo Cuomo
sumber
10

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

Josh
sumber
Bekerja dengan baik untuk saya DAN itu bersifat rekursif. Ingat saja bahwa sintaks impor masih di belakang bendera di Node, Anda mungkin harus menggunakan cara lama: const fs = require ('fs');
mjsarfatti
@Josh Ini berfungsi seperti pesona. Namun, mengalami sedikit kesulitan untuk memahami cara kerjanya [...files, ...getAllFiles(name)]atau [...files, name]. Sedikit penjelasan akan sangat membantu :)
Md Mazedul Islam Khan
1
@MdMazedulIslamKhan Yang ...digunakan di sini disebut sintaks spread. Apa yang pada dasarnya dilakukannya adalah mengambil semua objek di dalam array dan 'menyebar' ke dalam array baru. Dalam hal ini, semua entri di dalam filesarray ditambahkan ke pengembalian bersama dengan semua nilai yang dikembalikan dari panggilan rekursif. Anda dapat merujuk ke sintaksis penyebaran di sini: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
T90
8

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

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

a.barbieri
sumber
5

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()
    }
Oggy Transfluxitor Jones
sumber
4
Biasakan menambahkan tanda titik koma di akhir pernyataan Anda. Anda tidak dapat memperkecil kode jika tidak. Namun demikian, terima kasih atas kontribusi async yang sangat dibutuhkan.
user2867288
2
HAHAHAHA itu bukan bagian dari spec, hanya beberapa orang acak memanggil gaya linting pilihan mereka "standardjs". Titik koma adalah praktik yang baik terutama dalam Javascript untuk menjaga kejelasan kode. Kalau tidak, Anda dan tim Anda harus mengingat aturan penyisipan titik koma otomatis , dan saya tahu setidaknya rata-rata pengembang JS tempat saya bekerja tidak rajin.
user2867288
@ user2867288 Tapi karena ASI ada, kita bisa menggunakannya, bukan? Saya menggunakan eslint dan lebih cantik untuk memformat kode saya di save secara teratur dan penyisipan titik koma adalah masalah.
douira
5

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']));
DI
sumber
Saya memiliki folder utama: scss, dan di dalamnya folder lain: tema, tetapi daftar terakhir memberi saya semua direktori, tidak hanya direktori tanpa mengecualikan directorie, apa yang terjadi?
SalahAdDin
Hanya berfungsi dengan baik dengan '.' direktori folder, dengan direktori lainnya tidak berfungsi.
SalahAdDin
5

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");
Mahesh
sumber
3

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
}
Paul F. Wood
sumber
1

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){
    })
})
Rama
sumber
1

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!

stefantigro
sumber
0

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

XåpplI'-I0llwlg'I -
sumber
0

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
John Byrne
sumber
0

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);
});
Paweł
sumber
-1
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);
        }
    }
}
Francois
sumber