නාමාවලියක ඇති සියලුම ලිපිගොනු වල නම් ලැයිස්තුවක් Node.js භාවිතා කර ලබා ගැනීමට මම උත්සාහ කරමි. මට ප්‍රතිදානය අවශ්‍යයි එය ගොනු නාම සමූහයකි. මට මෙය කළ හැක්කේ කෙසේද?

ඔබට fs.readdirහෝ 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);
});

ක්‍රම දෙක අතර ඇති වෙනස නම්, පළමුවැන්න අසමමුහුර්ත වීමයි, එබැවින් ඔබට කියවීමේ ක්‍රියාවලිය අවසන් වූ විට ක්‍රියාත්මක වන ඇමතුම් ආපසු ගැනීමේ ශ්‍රිතයක් සැපයිය යුතුය.

දෙවැන්න සමමුහුර්ත වේ, එය ගොනු නාම අරාව නැවත ලබා දෙනු ඇත, නමුත් කියවීමේ ක්‍රියාවලිය අවසන් වන තෙක් එය ඔබේ කේතය තවදුරටත් ක්‍රියාත්මක කිරීම නවත්වනු ඇත.

එක් රටකින් එවැනි කාර්යයන් ඉටු කිරීමට වඩාත් convinient ක්රමය භාවිතා කිරීමයි glob මෙවලමක්. මෙන්න 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.
})

ඉහත පිළිතුර ඩිරෙක්ටරියට පුනරාවර්තන සෙවීමක් සිදු නොකරයි. මෙහිදී (භාවිතා මම ආවර්තනික සෝදිසි වෙනුවෙන් කළ දේ node එකක් මතම ඊට අදාල-ඇවිදින්න : 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);
});

සියලුම උපසිරැසි වල ගොනු ලබා ගන්න

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

දේශීය 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);
        }
    });
}

හෝ අසින්ක් අනුවාදය ( 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 එක සමාන බැවින්, ඔබට උපරිම ක්‍රියාකාරීත්වය සහතික කිරීම සඳහා අසින්ක් අනුවාදය භාවිතා කළ හැකිය.

කෙසේ වෙතත් සමමුහුර්ත අනුවාදය භාවිතා කිරීමෙන් එක් වාසියක් ඇත. ඇවිදීමෙන් පසු ඊළඟ ප්‍රකාශයේ දී මෙන්, ඇවිදීම අවසන් වූ වහාම යම් කේතයක් ක්‍රියාත්මක කිරීම පහසුය. අසින්ක් අනුවාදය සමඟ, ඔබ අවසන් වූ විට දැන ගැනීමට අමතර ක්‍රමයක් අවශ්‍ය වේ. සමහර විට පළමුව සියලු මාර්ගවල සිතියමක් නිර්මාණය කර ඒවා ගණනය කරන්න. සරල තැනීමේ / උපයෝගීතා ස්ක්‍රිප්ට් සඳහා (ඉහළ කාර්යසාධනයක් සහිත වෙබ් සේවාදායකයන්ට එරෙහිව) ඔබට කිසිදු හානියක් සිදු නොවී සමමුහුර්ත අනුවාදය භාවිතා කළ හැකිය.

Node v10.10.0 වන විට, නාමාවලියක ගොනු නාම සඳහා පෙරීම සඳහා ශ්‍රිතය සමඟ සහ ඒකාබද්ධව නව withFileTypesවිකල්පය භාවිතා කළ හැකිය . එය මේ වගේ ය:fs.readdirfs.readdirSyncdirent.isDirectory()

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

ආපසු ලබා දුන් අරාව ස්වරූපයෙන් ඇත:

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

Fs.Dirent පන්තිය සඳහා ලියකියවිලි

ES7 සමඟ පොරොන්දු භාවිතා කිරීම

Mz / fs සමඟ අසමමුහුර්ත භාවිතය

මෙම mzමොඩියුලය හරය node එකක් මතම ඊට අදාල පුස්තකාලයේ promisified සංස්කරණ සපයයි. ඒවා භාවිතා කිරීම සරලයි. මුලින්ම පුස්තකාලය ස්ථාපනය කරන්න ...

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

පුනරාවර්තන ලැයිස්තුගත කිරීම සඳහා යාවත්කාලීන කරන්න

සමහර පරිශීලකයින් පුනරාවර්තන ලැයිස්තුවක් දැකීමට ඇති ආශාව නියම කර ඇත (ප්‍රශ්නයේ නොමැති වුවද) ... භාවිතා කරන්න fs-promise. එය වටා තුනී එතුමකි mz.

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

යැපීම්.

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එය එතරම් සුබවාදී නොවන බව කරුණාවෙන් සලකන්න . බැරෑරුම් ඕනෑම දෙයක් සඳහා, යම් දෝෂ හැසිරවීමක් එක් කරන්න.

පුනරාවර්තන නොවන අනුවාදය

ඔබට එය පුනරාවර්තන ලෙස කිරීමට අවශ්‍ය යැයි ඔබ නොකියයි, එබැවින් ඔබට අවශ්‍ය වන්නේ නාමාවලියේ සෘජු දරුවන් පමණක් බව මම සිතමි.

නියැදි කේතය:

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

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

පූරණය fs:

const fs = require('fs');

ගොනු අසංක ලෙස කියවන්න :

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

ලිපිගොනු කියවීම සමමුහුර්ත කරන්න :

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

කවුරුහරි තවමත් මෙය සොයන්නේ නම්, මම මෙය කරන්නේ:

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

ඒකෙ වැඩ මට ගොඩක් හොඳයි

මම ඔබේ ප්‍රශ්නයෙන් උපකල්පනය කරන්නේ ඔබට නාමාවලි නාම අවශ්‍ය නොවන බවයි.

උදාහරණයක්:

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

ඔබට අවශ්‍ය නම් ගොනු මාර්ග පෙළක් භාවිතා කරන්න 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'))

ප්‍රතිලාභ:

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

බැර https://gist.github.com/lovasoa/8691344#gistcomment-2927279 වෙත යන්න

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

කොටුවෙන් පිටත

ඔබට පිටතින් ඇති නාමාවලි ව්‍යුහය සහිත වස්තුවක් අවශ්‍ය නම්, ඩිරෙක්ටරි-ගස පරීක්ෂා කිරීමට මම ඔබව බෙහෙවින් පිළිගනිමි .

ඔබට මෙම ව්‍යුහය ඇති බව කියමු:

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

මෙන්න අසමමුහුර්ත පුනරාවර්තන අනුවාදය.

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

@ හුනාන්-රොස්ටොමියන්ගේ පොදු ප්‍රවේශය ගත් විට, එය වඩාත් සංක්ෂිප්ත හා 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']));

මෙය යතුරු ලියනයකි, විකල්ප ලෙස පුනරාවර්තන, විකල්ප වශයෙන් දෝෂ ලොග් වීම සහ අසමමුහුර්ත විසඳුමකි. ඔබට සොයා ගැනීමට අවශ්‍ය ගොනු නාම සඳහා සාමාන්‍ය ප්‍රකාශනයක් නියම කළ හැකිය.

මම භාවිතා කළෙමි 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
}

මෙය එකම ඩිරෙක්ටරියේම ඇති test.txt ගොනුවේ ප්‍රති result ලය ක්‍රියා කර ගබඩා කරනු ඇත

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

මම මෑතකදී මේ සඳහා මෙවලමක් ගොඩනගා ඇත ... එය සමමුහුර්තව නාමාවලියක් ලබා ගෙන අයිතම ලැයිස්තුවක් ලබා දෙයි. ෆෝල්ඩර පළමුවැන්න සමඟ ඔබට නාමාවලි, ලිපිගොනු හෝ දෙකම ලබා ගත හැකිය. සම්පූර්ණ ෆෝල්ඩරය ලබා ගැනීමට ඔබට අවශ්‍ය නැති අවස්ථාවකදී ඔබට දත්ත පේජින් කළ හැකිය.

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

මෙය සබැඳිය, එය යමෙකුට උපකාරී වේ යැයි සිතමු!

හුදෙක් හිස්: ඔයා තමයි සැලසුම් කරන්න, නාමාවලියක් එක් එක් ගොනුව මත මෙහෙයුම් ඉටු කිරීමට නම් විනිල්-fs (විසින් භාවිතා කරන ඔවුන්ගේ උගුරෙන් පහළට , ප්රවාහක ගොඩ නැඟීමට පද්ධතිය).

මෙම කාර්යය ස්වයංක්‍රීය කිරීම සඳහා මම නෝඩ් මොඩියුලයක් සාදන ලදී: mddir

භාවිතය

node mddir "../relative/path/"

ස්ථාපනය කිරීමට: npm ස්ථාපනය mddir -g

වත්මන් නාමාවලිය සඳහා ලකුණු කිරීම ජනනය කිරීම සඳහා: mddir

ඕනෑම නිරපේක්ෂ මාර්ගයක් සඳහා උත්පාදනය කිරීම සඳහා: mddir / absolute / path

සාපේක්ෂ මාර්ගයක් සඳහා උත්පාදනය කිරීම සඳහා: mddir Docu / ලේඛන / ඕනෑම දෙයක්.

ඔබේ වැඩ කරන නාමාවලිය තුළ md ගොනුව ජනනය වේ.

දැනට node_modules සහ .git ෆෝල්ඩර නොසලකා හරිනු ලැබේ.

දෝෂගවේෂණය

ඔබට 'node \ r: එවැනි ගොනුවක් හෝ නාමාවලියක් නැත' යන දෝෂය ලැබුනේ නම්, ගැටළුව වන්නේ ඔබේ මෙහෙයුම් පද්ධතිය විවිධ රේඛා අවසානයන් භාවිතා කරන අතර ඔබ රේඛා අවසන් කිරීමේ ශෛලිය යුනික්ස් වෙත පැහැදිලිවම සැකසීමකින් තොරව mddir හට ඒවා විග්‍රහ කළ නොහැක. මෙය සාමාන්‍යයෙන් වින්ඩෝස් වලට පමණක් නොව ලිනක්ස් හි සමහර අනුවාදයන්ටද බලපායි. රේඛීය අවසානයන් යුනික්ස් ශෛලියට සැකසීම mddir npm ගෝලීය බින් ෆෝල්ඩරය තුළ සිදු කළ යුතුය.

රේඛා අවසානය නිවැරදි කරයි

සමඟ npm බින් ෆෝල්ඩර මාර්ගය ලබා ගන්න:

npm config get prefix

එම ෆෝල්ඩරයට සීඩී

බීර ස්ථාපනය dos2unix

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

මෙය ඩොස් වෙනුවට රේඛීය අවසානය යුනික්ස් බවට පරිවර්තනය කරයි

ඉන්පසු සාමාන්‍ය පරිදි ධාවනය කරන්න: node mddir "../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);
});

මම සාමාන්‍යයෙන් භාවිතා කරන්නේ: FS-Extra .

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

ප්‍රති ult ලය:

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

මගේ ශත 2 කවුරුහරි නම්:

ඔවුන්ගේ ව්‍යාපෘතියේ දේශීය උප ෆෝල්ඩරයකින් ගොනු නාම (නාමාවලි හැර) ලැයිස්තු ගත කිරීමට අවශ්‍යය

• Additional අතිරේක පරායත්තතා නොමැත
• Function 1 ශ්‍රිතය
• Path මාර්ගය සාමාන්‍යකරණය කරන්න (යුනික්ස් එදිරිව වින්ඩෝස්)

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

/**
 * @param {string} relativeName "resources/foo/goo"
 * @return {string[]}
 */
const listFileNames = (relativeName) => {
  try {
    const path = path.join(process.cwd(), ...relativeName.split("/"));
    return fs
      .readdirSync(path, { 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"]

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