il modulo di indicizzazione dei file profondi del nodo non può andare in profondità [chiuso]

Question

il modulo di indicizzazione dei file profondi del nodo non può andare in profondità [chiuso]

#1 da (-2 voti)

-1

Sto cercando di creare un indicizzatore di file per node.js. Il programma dovrebbe indicizzare file e cartelle in un array e anche controllare all'interno delle cartelle e aggiungere tutte le sottocartelle e i file

Ho scritto:

fs.readdir(__dirname,index);

function index(err,data){
 for (i in data){
        if(fs.statSync(data[i]).isDirectory()){
            j.folders.push(path.resolve(data[i]));
            fs.readdir(data[i],index);
        }
        else{
            j.files.push(path.resolve(data[i]));
        }
    } 
}

... questo codice, ma quando passa all'interno di una cartella dà traceback e si ferma nell'esecuzione. qui la mia domanda è come indicizzo i file e risolvo questo problema.

ps. per favore non commentare sulla passeggiata, voglio scrivere il mio modulo.

javascript directory-structure node.js io indexing

posta nikoss 09.05.2015 - 20:16

fonte

1 risposta

Leggi altre domande sui tag javascript directory-structure node.js io indexing

Modulo di registrazione con verifica dell'e-mail Come denominare il pacchetto e le loro classi di facciata?

score -2 · Accepted Answer

Un problema con readdir è che passa solo il nome file, senza il percorso completo, alla variabile dati nella funzione indice. Diciamo che stai chiamando lo script da C: \ main. I contenuti di C: \ main sono

C: \ principale C: \ Main \ cartella1 C: \ main \ folder1 \ subDir1

Quando il tuo programma entra folder1 e legge subDir1 , proverà a chiamare readdir con data[i] = 'subDir1' . Ma poiché la directory di lavoro corrente non è cambiata, che è ancora C:\main , readdir aggiunge questo al suo argomento path, risultando in C:\main\subDir1 , che non esiste.

Per gestire questo, possiamo tenere traccia della directory che è stata inviata a readdir, che è asincrona. Ciò significa che la directory deve essere definita nella funzione di callback prima di essere invocata.

var fs = require('fs');
var path = require('path');
var files = [];
var folders = [];

indexDir(__dirname);


function indexDir(d) {fs.readdir(d, function (err,data){
 for (i in data){
        console.log(path.join(d, data[i]));
        if(fs.statSync(path.join(d, data[i])).isDirectory()){
            folders.push(path.resolve(path.join(d, data[i])));
            indexDir(path.join(d, data[i]));
        }
        else{
            files.push(path.resolve(path.join(d, data[i])));
        }
    }
})}

Se vogliamo vedere i risultati una volta che la directory è stata completamente attraversata, potrebbe essere più semplice usare readdirSync, poiché è sincrono e bloccherà fino a quando tutte le directory non saranno state visitate. Altrimenti, se vogliamo mantenere le cose asincrone, possiamo chiamare un'altra funzione quando tutto è fatto tenendo traccia del numero di chiamate asincrone.

var fs = require('fs');
var path = require('path');
var files = [];
var folders = [];
var calls = 0;
indexDir(__dirname);

function indexDir(d) {
 calls++;
 fs.readdir(d, function (err,data){
   calls--;
   for (i in data){
          if(fs.statSync(path.join(d, data[i])).isDirectory()){
              folders.push(path.resolve(path.join(d, data[i])));
              indexDir(path.join(d, data[i]));
          }
          else{
              files.push(path.resolve(path.join(d, data[i])));
          }
      }
   if (calls == 0){
     present();
   }
 })}


function present(){
 for (i in files){
        console.log(files[i]);
    }
 for (i in folders){
        console.log(folders[i]);
    }
 }