Node.js kullanarak bir dizinde bulunan tüm dosyaların adlarının bir listesini almaya çalışıyorum. Ben bir dizi dosya adı çıktı istiyorum. Bunu nasıl yapabilirim?

fs.readdirVeya fs.readdirSyncyöntemlerini kullanabilirsiniz .

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

İki yöntem arasındaki fark, birincisinin eşzamansız olmasıdır, bu nedenle okuma işlemi sona erdiğinde yürütülecek bir geri arama işlevi sağlamanız gerekir.

İkincisi eşzamanlıdır, dosya adı dizisini döndürür, ancak okuma işlemi bitene kadar kodunuzun yürütülmesini durduracaktır.

IMO bu tür görevleri yapmanın en uygun yolu bir glob aracı kullanmaktır . İşte node.js için bir glob paketi . İle yükle

npm install glob

Ardından dosya adlarını eşleştirmek için joker karakter kullanın (paketin web sitesinden alınan örnek)

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

Yukarıdaki cevap dizinde yinelemeli arama yapmaz. İşte özyinelemeli bir arama için yaptığım şey ( node-walk : kullanarak 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);
});

Tüm alt dizinlerdeki dosyaları alma

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

İşte yalnızca yerel fsve pathmodülleri kullanan basit bir çözüm :

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

veya eşzamansız sürüm ( fs.readdirbunun yerine kullanır ):

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

Sonra sadece arayın (senkronizasyon sürümü için):

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

veya eşzamansız sürüm:

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

Fark, GÇ gerçekleştirirken düğümün nasıl bloke edildiğidir. Yukarıdaki API'nın aynı olduğu göz önüne alındığında, maksimum performans sağlamak için zaman uyumsuz sürümü kullanabilirsiniz.

Ancak senkron versiyonu kullanmanın bir avantajı vardır. Yürüyüşten sonraki bir sonraki açıklamada olduğu gibi, yürüyüş yapılır yapılmaz bazı kodların yürütülmesi daha kolaydır. Eşzamansız sürümde, ne zaman bittiğini bilmenin ekstra bir yoluna ihtiyacınız olacak. Belki de önce tüm yolların bir haritasını oluşturur, sonra onları numaralandırır. Basit derleme / kullanım komut dosyaları (yüksek performanslı web sunucularına karşı) için senkronizasyon sürümünü herhangi bir zarar vermeden kullanabilirsiniz.

Düğüm v10.10.0 itibaren, yeni kullanmak mümkündür withFileTypesseçeneğini fs.readdirve fs.readdirSyncbirlikte dirent.isDirectory()bir dizin içindeki bir dosya için filtre işlevi. Şöyle görünüyor:

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

Döndürülen dizi şu şekildedir:

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

Fs.Dirent sınıfı için dokümanlar

ES7 ile Vaatleri Kullanma

Mz / fs ile eşzamansız kullanım

mzModül merkez düğüm kütüphanesinin promisified sürümlerini içerir. Bunları kullanmak basittir. Önce kütüphaneyi kurun ...

npm install mz

Sonra...

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

Alternatif olarak, bunları ES7'de asenkron işlevlerde yazabilirsiniz:

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

Özyinelemeli liste için güncelleme

Bazı kullanıcılar (değil söz konusu olsa da) bir özyinelemeli Listesini görmek ... kullanın arzusu belirttiniz fs-promise. Etrafında ince bir sargı var mz.

npm install fs-promise;

sonra...

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

Bağımlılıklar.

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

Tanım.

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

Kullanımı.

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

Bunun fileListçok iyimser olduğunu lütfen unutmayın . Ciddi bir şey için, hata işleme ekleyin.

özyinelemesiz sürüm

Özyinelemeli olarak yapmak istediğinizi söylemezsiniz, bu nedenle dizinin yalnızca doğrudan çocuklarına ihtiyacınız olduğunu varsayalım.

Basit kod:

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

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

Yük fs:

const fs = require('fs');

Dosyaları zaman uyumsuz olarak okuma :

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

Dosyaları senkronize et :

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

Birisi hala bu arama, ben bunu:

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

ve işleri benim için çok iyi

sortedDosya adları alın . Sonuçları , vb. extensionGibi belirli bir özelliğe göre filtreleyebilirsiniz .'.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();
}

Sorunuzdan dizin isimleri, sadece dosyalar istemediğinizi varsayıyorum.

Misal:

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

Dosya yollarının yalnızca bir dizisini kullanmak istiyorsanız 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'))

İadeler:

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

Krediler https://gist.github.com/lovasoa/8691344#gistcomment-2927279 adresine gidin.

İşte asenkron bir özyinelemeli sürüm.

    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'ın genel yaklaşımını benimsedi, biraz daha özlü hale getirdi ve excludeDirsargüman ekledi . Genişlemek önemsizdir includeDirs, sadece aynı modeli takip edin:

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

Örnek kullanım:

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

Kutudan dışarı

Kullanıma hazır dizin yapısına sahip bir nesne istiyorsanız , dizin ağacını kontrol etmenizi öneririm .

Diyelim ki bu yapıya sahipsin:

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

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

Geri dönücek:

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

Özel Nesne

Aksi takdirde , özel ayarlarınızla bir dizin ağacı nesnesi oluşturmak istiyorsanız aşağıdaki snippet'e bakın. Bu kod ve kutuda canlı bir örnek görülebilir .

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

Sonra şunları yapabilirsiniz:

// another-file.js 

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

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

Bu bir TypeScript, isteğe bağlı olarak özyinelemeli, isteğe bağlı olarak hata günlüğü ve asenkron çözümdür. Bulmak istediğiniz dosya adları için normal bir ifade belirleyebilirsiniz.

Kullandım fs-extra, çünkü kolay bir süper set iyileştirmesi 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
}

Bu, sonucu aynı dizinde bulunacak test.txt dosyasında çalıştıracak ve depolayacaktır.

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

Geçenlerde bunun için sadece bir araç inşa ettik ... Bu bir dizini senkronize olmayan bir şekilde alır ve bir öğe listesi döndürür. Dizinleri, dosyaları veya her ikisini birden alabilirsiniz; klasörler önce gelir. Ayrıca, tüm klasörü getirmek istemediğiniz durumlarda verileri sayfalandırabilirsiniz.

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

Bu bağlantı, umarım birine yardım eder!

Sadece bir adım yukarı: bir dizindeki her dosya üzerinde işlem yapmayı planlıyorsanız vinyl-fs ( gulp , akış oluşturma sistemi tarafından kullanılır) deneyin .

Bu görevi otomatikleştirmek için bir düğüm modülü yaptım: mddir

kullanım

düğüm mddir "../relative/path/"

Yüklemek için: npm install mddir -g

Geçerli dizin için işaretleme oluşturmak için: mddir

Herhangi bir mutlak yol için oluşturmak için: mddir / absolute / path

Göreli bir yol oluşturmak için: mddir ~ / Documents / whatever.

Md dosyası çalışma dizininizde oluşturulur.

Şu anda node_modules ve .git klasörlerini yok sayar.

Sorun giderme

'Düğüm \ r: Böyle bir dosya veya dizin yok' hatasını alırsanız, sorun işletim sisteminizin farklı satır sonları kullanması ve satır sonlandırma stilini açıkça Unix olarak ayarlamadan mddir bunları ayrıştıramamasıdır. Bu genellikle Windows'u değil, bazı Linux sürümlerini de etkiler. Mddir npm global bin klasörü içinde satır sonlarının Unix stiline ayarlanması gerekir.

Satır sonları düzeltildi

Npm bin klasör yolunu şununla alın:

npm config get prefix

Cd bu klasöre

demlemek dos2unix yükleyin

dos2unix lib / düğüm_ modülleri / mddir / src / mddir.js

Bu, satır sonlarını Dos yerine Unix'e dönüştürür

Daha sonra şu şekilde çalıştırın: node mddir "../relative/path/".

Oluşturulan örnekleme markdown dosya yapısı '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 Liste içeriği modülünü kullanın . Verilen dizinin içeriğini ve alt içeriğini okur ve dosyaların ve klasörlerin yollarının listesini döndürür.

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