Como você obtém uma lista dos nomes de todos os arquivos presentes em um diretório no Node.js.


979

Estou tentando obter uma lista dos nomes de todos os arquivos presentes em um diretório usando o Node.js. Eu quero saída que é uma matriz de nomes de arquivos. Como posso fazer isso?


9
fs.readdirfunciona, mas não pode usar padrões glob de nome de arquivo como ls /tmp/*core*. Confira github.com/isaacs/node-glob . Globs podem até procurar em subdiretórios.
Jess

Da Caixa NPM readdir-recursivemódulo mas se você está procurando os nomes de arquivos em subdiretórios também
Ethan Davis


1
fs.readdir é uma solução assíncrona simples - exemplos aqui
drorw 18/04/19

Ainda não respondeu usando um iterador? Tenho 2,5 milhões de arquivos para digitalizar ... Não quero obter uma lista de 2,5m de caminho após 10 minutos.
Flavien Volken

Respostas:


1342

Você pode usar o fs.readdirou fs.readdirSyncmétodos.

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

A diferença entre os dois métodos é que o primeiro é assíncrono; portanto, é necessário fornecer uma função de retorno de chamada que será executada quando o processo de leitura terminar.

O segundo é síncrono, ele retornará a matriz do nome do arquivo, mas interromperá qualquer execução adicional do seu código até que o processo de leitura termine.


204
Nota: readdirtambém mostra os nomes dos diretórios . Para filtrá-los, use fs.stat(path, callback(err, stats))e stats.isDirectory().
Rob W

3
Devo acrescentar que provavelmente você deve ir com readdire porque não deseja bloquear E / S no nó.
DragonKnight 15/15

5
@ user3705055, a menos que você esteja usando o gulp para ler em um diretório de arquivos dependentes da ordem de origem e compilá-los em um único executável.
R3wt


2
@ Santanc Você quer tentar analisar a saída de ls? Basta esperar até que alguém cria alguns nomes de arquivos com espaços incorporados e novas linhas ...
Radon Rosborough

201

Na IMO, a maneira mais conveniente de executar essas tarefas é usar uma ferramenta glob . Aqui está um pacote glob para o node.js. Instale com

npm install glob

Em seguida, use o curinga para corresponder aos nomes de arquivos (exemplo extraído do site do pacote)

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

5
esta foi a melhor solução para mim, pois queria especificar o tipo de arquivo mais fácil do que as comparações de strings. Obrigado.
Pogrindis 26/10

Também gosto desse porque o globbing é quase uma habilidade fundamental no nó. Se você quiser apenas recuperar os nomes dos arquivos, passe um cwdno objeto de opções.
Jcollum 01/09

1
Como obter os resultados de globfora de si mesmo? Por exemplo. Eu quero console.logos resultados, mas não por dentro glob()?
Lanti

13
@ Lanti: O glob.sync(pattern, [options])método pode ser mais fácil de usar, pois simplesmente retorna uma matriz de nomes de arquivos, em vez de usar um retorno de chamada. Mais informações aqui: github.com/isaacs/node-glob
Glenn Lawrence

2
Para pessoas como eu à procura de uma implementação glob usando Promises, confira globby por sindresorhus: github.com/sindresorhus/globby
Nacho Coloma

180

A resposta acima não realiza uma pesquisa recursiva no diretório. Aqui está o que eu fiz para uma pesquisa recursiva (usando nó-pé : 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);
});

4
fs.readdirSync é melhor, alternativa nativa criada especialmente para isso.
Eraden

37
Infelizmente, o fs.readdirSync não entra em subdiretórios, a menos que você esteja disposto a escrever sua própria rotina para fazer exatamente isso, o que você não considera que já existem módulos npm disponíveis para resolver esse problema.
Ruben Tan

6
Aqui está um link para a caminhada repositório no GitHub docs +: github.com/coolaj86/node-walk
santiagoIT

O OP não perguntou sobre qual API faz uma leitura recursiva. De qualquer forma, a resposta aceita fornece o que também pode servir de base para fazer uma leitura recursiva.
Igwe Kalu

Esta é uma função fantástica. Pergunta rápida: existe uma maneira rápida de ignorar determinados diretórios? Eu quero ignorar diretórios começando com.git
j_d 3/16/16

91

Obter arquivos em todos os subdiretórios

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

4
Por que if (typeof files_ === 'undefined') files_=[];? você só precisa fazer em var files_ = files_ || [];vez de files_ = files_ || [];.
Jkutianski

4
Você esqueceu de adicionar var fs = require('fs');no início de getFiles.
precisa saber é o seguinte

Este é um método recursivo. Ele não suporta estruturas de pastas muito profundas, o que resultará em um estouro de pilha.
Mathias Lykkegaard Lorenzen

63

Aqui está uma solução simples usando apenas o nativo fse os pathmódulos:

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

ou versão assíncrona (usa em fs.readdirvez disso):

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

Então você acabou de ligar (para versão de sincronização):

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

ou versão assíncrona:

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

A diferença está em como o nó é bloqueado durante a execução do IO. Como a API acima é a mesma, você pode apenas usar a versão assíncrona para garantir o desempenho máximo.

No entanto, há uma vantagem em usar a versão síncrona. É mais fácil executar algum código assim que a caminhada é concluída, como na próxima instrução após a caminhada. Com a versão assíncrona, você precisaria de uma maneira extra de saber quando terminar. Talvez criando um mapa de todos os caminhos primeiro e depois enumerá-los. Para scripts simples de compilação / utilidade (versus servidores Web de alto desempenho), você pode usar a versão de sincronização sem causar nenhum dano.


1
Deve substituir a linha walkSyncde a walk(filePath, callback);parawalkSync(filePath, callback);
MIDE11

3
Mas você ainda está usando o fs.statSync, que bloqueia, na versão assíncrona. Você não deveria usar o fs.stat?
precisa

Isso é realmente útil e esse método é recursivo. Obrigado!
Pouco Roys

35

No Nó v10.10.0, é possível usar a nova withFileTypesopção para fs.readdire fs.readdirSyncem combinação com a dirent.isDirectory()função para filtrar por nomes de arquivos em um diretório. É assim:

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

A matriz retornada está no formato:

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

Documentos para a classe fs.Dirent


7
Até agora, essa é a melhor resposta aqui!
Alex Ivasyuv 01/05/19

2
é isso que as pessoas estão procurando em 2020 - devem ser "afixadas"
Val Redchenko 15/02

1
Melhor resposta 2020!
Yves Lange

26

Usando promessas com o ES7

Uso assíncrono com mz / fs

O mzmódulo fornece versões promissificadas da biblioteca de nós principais. Usá-los é simples. Primeiro instale a biblioteca ...

npm install mz

Então...

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

Como alternativa, você pode escrevê-los em funções assíncronas no ES7:

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

Atualização para listagem recursiva

Alguns dos usuários especificaram o desejo de ver uma listagem recursiva (embora não esteja na pergunta) ... Use fs-promise. É um invólucro fino por aí mz.

npm install fs-promise;

então...

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

5
fs.walk é removido fs-promessa, uma vez que ele não suportada por fs ( github.com/kevinbeaty/fs-promise/issues/28 )
adnan

20

Dependências.

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

Definição.

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

Uso.

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

Observe que isso fileListé otimista demais. Para algo sério, adicione algum tratamento de erro.


1
Eu adicionei um excludeDirsargumento de matriz também. Ele muda o suficiente para que você possa editá-lo (se quiser). Caso contrário, vou adicioná-lo em uma resposta diferente. gist.github.com/AlecTaylor/f3f221b4fb86b4375650
AT

1
@ AT Nice! Você deve postar sua própria resposta, pois é uma extensão útil. Vamos manter este sem características.
Hunan Rostomyan

19

versão não recursiva

Você não diz que deseja fazê-lo recursivamente, portanto, presumo que você só precise de filhos diretos do diretório.

Código de amostra:

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

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

10

Carregar fs:

const fs = require('fs');

Leia arquivos assíncronos :

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

Sincronização de arquivos de leitura :

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

10

se alguém ainda procurar por isso, eu faço o seguinte:

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

e seu trabalho é muito bom para mim


Funcionou muito bem para mim e é recursivo. Lembre-se de que a sintaxe de importação ainda está atrás de um sinalizador no Node, você pode ter que seguir o caminho antigo: const fs = require ('fs');
Mjsarfatti

@ Josh Funciona como charme. No entanto, tendo um pouco de dificuldade para entender como o [...files, ...getAllFiles(name)]ou [...files, name]funciona. Um pouco de explicação seria muito útil :)
Md Mazedul Islam Khan

1
@MdMazedulIslamKhan O ...usado aqui é chamado de sintaxe de propagação. O que basicamente faz é pegar todos os objetos dentro da matriz e 'espalhá-la' na nova matriz. Nesse caso, todas as entradas dentro da filesmatriz são adicionadas ao retorno, juntamente com todos os valores retornados da chamada recursiva. Você pode consultar a sintaxe de propagação aqui: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…
T90

8

Obtenha sortednomes de arquivos. Você pode filtrar os resultados com base em uma específica extension, como '.txt', '.jpg'e assim por diante.

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

6

Partindo da sua pergunta, estou assumindo que você não deseja nomes de diretórios, apenas arquivos.

Exemplo:

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

Se você deseja apenas uma matriz dos caminhos de arquivos, use 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'))

retorna:

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

Os créditos vão para https://gist.github.com/lovasoa/8691344#gistcomment-2927279


5

Aqui está uma versão recursiva assíncrona.

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

4
Adquira o hábito de adicionar ponto e vírgula no final de suas declarações. Você não pode reduzir o código de outra forma. No entanto, obrigado pela tão necessária contribuição assíncrona.
precisa saber é o seguinte

2
HAHAHAHA isso não faz parte da especificação, apenas uma pessoa aleatória chamando seu estilo de linting preferido de "standardjs". O ponto e vírgula é uma boa prática, especialmente em Javascript, para manter a clareza do código. Caso contrário, você e sua equipe devem memorizar as regras de inserção automática de ponto e vírgula , e eu sei que pelo menos o desenvolvedor JS comum em que trabalho não é tão diligente.
user2867288

@ user2867288 Mas como o ASI existe, podemos usá-lo, não? Uso eslint e mais bonito para formatar meu código ao salvar regularmente e a inserção de ponto e vírgula é um problema.
douira 18/01

5

Adotou a abordagem geral de @ Hunan-Rostomyan, tornou um pouco mais conciso e acrescentou um excludeDirsargumento. Seria trivial estender includeDirs, basta seguir o mesmo padrão:

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

Exemplo de uso:

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

Eu tenho uma pasta principal: scss, e dentro dela outra pasta: themes, mas a lista final me fornece todos os diretórios, não apenas os diretórios sem excluir o diretório, o que está acontecendo?
precisa saber é o seguinte

Só funciona bem com '.' diretório de pastas, com os demais diretórios, não funciona.
precisa saber é o seguinte

5

Sai da caixa

Caso você deseje um objeto com a estrutura de diretórios pronta para uso, recomendo que você verifique a árvore de diretórios .

Digamos que você tenha essa estrutura:

photos
   june
   └── windsurf.jpg
└── january
    ├── ski.png
    └── snowboard.jpg
const dirTree = require("directory-tree");
const tree = dirTree("/path/to/photos");

Retornará:

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

Objeto personalizado

Caso contrário, se você deseja criar um objeto de árvore de diretórios com suas configurações personalizadas , consulte o seguinte snippet. Um exemplo ao vivo é visível nesta caixa de código .

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

Então você pode simplesmente fazer:

// another-file.js 

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

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

3

Esta é uma solução TypeScript, opcionalmente recursiva, opcionalmente de log de erros e assíncrona. Você pode especificar uma expressão regular para os nomes de arquivo que deseja encontrar.

Eu usei fs-extra, porque é uma melhoria fácil do super set 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
}

1

Isso funcionará e armazenará o resultado no arquivo test.txt, que estará presente no mesmo diretório

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

1

Recentemente, criei uma ferramenta para isso que faz exatamente isso ... Ele busca um diretório de forma assíncrona e retorna uma lista de itens. Você pode obter diretórios, arquivos ou ambos, com as pastas sendo as primeiras. Você também pode paginar os dados caso não deseje buscar a pasta inteira.

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

Este é o link, espero que ajude alguém!


0

Apenas um alerta: se você planeja executar operações em cada arquivo em um diretório, tente o vinyl-fs (usado pelo gulp , o sistema de criação de streaming).


0

Eu criei um módulo de nó para automatizar esta tarefa: mddir

Uso

nó mddir "../relative/path/"

Para instalar: npm install mddir -g

Para gerar descontos para o diretório atual: mddir

Para gerar para qualquer caminho absoluto: mddir / absolute / path

Para gerar um caminho relativo: mddir ~ / Documents / Whatever.

O arquivo md é gerado no seu diretório de trabalho.

Atualmente ignora as pastas node_modules e .git.

Solução de problemas

Se você receber o erro 'node \ r: não existe esse arquivo ou diretório', o problema é que o sistema operacional utiliza diferentes terminações de linha e o mddir não pode analisá-las sem definir explicitamente o estilo de final de linha como Unix. Isso geralmente afeta o Windows, mas também algumas versões do Linux. A definição das terminações da linha no estilo Unix deve ser realizada na pasta bin global mddir npm.

Correção de terminações de linha

Obtenha o caminho da pasta npm bin com:

npm config get prefix

CD nessa pasta

instalação de fermentação dos2unix

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

Isso converte as terminações de linha em Unix em vez de Dos

Em seguida, execute normalmente com: node mddir "../relative/path/".

Exemplo de estrutura de arquivo de remarcação gerada '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

0

Use o módulo de npm conteúdo da lista . Ele lê o conteúdo e o sub-conteúdo do diretório especificado e retorna a lista de caminhos de arquivos e pastas.

const list = require('list-contents');

list("./dist",(o)=>{
  if(o.error) throw o.error;
   console.log('Folders: ', o.dirs);
   console.log('Files: ', o.files);
});

-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);
        }
    }
}
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.