Odczytywanie wszystkich plików w katalogu, przechowywanie ich w obiektach i wysyłanie obiektu


91

Nie wiem, czy jest to możliwe, ale proszę bardzo. A praca z callbackami sprawia, że ​​jest to jeszcze trudniejsze.

Mam katalog z plikami html, które chcę odesłać do klienta w fragmentach obiektów z node.js i socket.io.

Wszystkie moje pliki znajdują się w / tmpl

Więc gniazdo musi odczytać wszystkie pliki w / tmpl.

dla każdego pliku musi przechowywać dane w obiekcie z nazwą pliku jako kluczem i zawartością jako wartością.

  var data;
  // this is wrong because it has to loop trough all files.
  fs.readFile(__dirname + '/tmpl/filename.html', 'utf8', function(err, html){
      if(err) throw err;
      //filename must be without .html at the end
      data['filename'] = html;
  });
  socket.emit('init', {data: data});

Ostateczne wywołanie zwrotne również jest nieprawidłowe. Musi zostać wywołany, gdy wszystkie pliki w katalogu są gotowe.

Ale ja nie wiem jak stworzyć kod, ktoś wie czy to jest możliwe?


4
Jeśli dostęp synchroniczny jest prawidłowy, możesz pominąć procedurę obsługi zdarzeń przy użyciu (blokowanie) readfileSynci readdirSyncmetod. nodejs.org/docs/v0.4.8/api/fs.html#fs.readdirSync
— rjz

Ok, nie wiedziałem o readdir, to może być pomocne. A jakie są wady blokowania. Myślałem, że głównym celem node.js jest to, że nie blokuje? Dlaczego możemy nagle zablokować.
— Saif Bechan

W przypadku wywołań zwrotnych asynchronicznych przeczytaj to: stackoverflow.com/questions/18983138/… Jest wiele błędnych odpowiedzi, ale niektóre są poprawne. Jeden z nich używa liczników.
— Vanuan

Odpowiedzi:


169

Tak więc są trzy części. Czytanie, przechowywanie i wysyłanie.

Oto część do czytania:

var fs = require('fs');

function readFiles(dirname, onFileContent, onError) {
  fs.readdir(dirname, function(err, filenames) {
    if (err) {
      onError(err);
      return;
    }
    filenames.forEach(function(filename) {
      fs.readFile(dirname + filename, 'utf-8', function(err, content) {
        if (err) {
          onError(err);
          return;
        }
        onFileContent(filename, content);
      });
    });
  });
}

Oto część do przechowywania:

var data = {};
readFiles('dirname/', function(filename, content) {
  data[filename] = content;
}, function(err) {
  throw err;
});

Część wysyłkowa należy do Ciebie. Możesz wysłać je pojedynczo lub po zakończeniu czytania.

Jeśli chcesz wysłać pliki po zakończeniu czytania, powinieneś albo użyć synchronizowanych wersji fsfunkcji, albo użyć obietnic. Asynchroniczne wywołania zwrotne nie są dobrym stylem.

Dodatkowo zapytałeś o usunięcie rozszerzenia. Powinieneś kolejno zadawać pytania. Nikt nie napisze kompletnego rozwiązania tylko dla Ciebie.


Dzięki, myślę, że to wykorzystam. Ale jedno, czy możesz wyjaśnić, co to 0===--crobi.
— Saif Bechan

1
Możesz zapisać to jako dwie linie c--i to if (c===0)to samo. Po prostu zmniejsza csię 1i sprawdza, czy osiągnął zero
— dusić

Ale zawsze będzie to 0, czy nie? Dodajesz 1 w foreach i tym samym usuwasz 1, więc zawsze pozostaje 0, czy się mylę? Czy czek nie musi być if(c===files.length), coś takiego.
— Saif Bechan

5
Ze względu na asynchroniczną naturę pętla foreach najprawdopodobniej kończy się przed readFilezwróceniem pierwszego kodu HTML, więc cpowinna xnatychmiast wzrosnąć do (liczby plików), a następnie zmniejszyć, gdy
— kod

1
Och, to jest jakaś głęboka logika, niezła. Muszę się wiele nauczyć o node. Dzięki za pomoc!
— Saif Bechan

16

To jest nowoczesna Promisewersja poprzedniej, wykorzystująca Promise.allpodejście do rozwiązywania wszystkich obietnic po przeczytaniu wszystkich plików:

/**
 * Promise all
 * @author Loreto Parisi (loretoparisi at gmail dot com)
 */
function promiseAllP(items, block) {
    var promises = [];
    items.forEach(function(item,index) {
        promises.push( function(item,i) {
            return new Promise(function(resolve, reject) {
                return block.apply(this,[item,index,resolve,reject]);
            });
        }(item,index))
    });
    return Promise.all(promises);
} //promiseAll

/**
 * read files
 * @param dirname string
 * @return Promise
 * @author Loreto Parisi (loretoparisi at gmail dot com)
 * @see http://stackoverflow.com/questions/10049557/reading-all-files-in-a-directory-store-them-in-objects-and-send-the-object
 */
function readFiles(dirname) {
    return new Promise((resolve, reject) => {
        fs.readdir(dirname, function(err, filenames) {
            if (err) return reject(err);
            promiseAllP(filenames,
            (filename,index,resolve,reject) =>  {
                fs.readFile(path.resolve(dirname, filename), 'utf-8', function(err, content) {
                    if (err) return reject(err);
                    return resolve({filename: filename, contents: content});
                });
            })
            .then(results => {
                return resolve(results);
            })
            .catch(error => {
                return reject(error);
            });
        });
  });
}

Jak tego użyć:

Tak proste, jak zrobienie:

readFiles( EMAIL_ROOT + '/' + folder)
.then(files => {
    console.log( "loaded ", files.length );
    files.forEach( (item, index) => {
        console.log( "item",index, "size ", item.contents.length);
    });
})
.catch( error => {
    console.log( error );
});

Załóżmy, że masz inną listę folderów, którą możesz również iterować po tej liście, ponieważ wewnętrzna obietnica. Wszystkie rozwiążą każdy z nich asynchronicznie:

var folders=['spam','ham'];
folders.forEach( folder => {
    readFiles( EMAIL_ROOT + '/' + folder)
    .then(files => {
        console.log( "loaded ", files.length );
        files.forEach( (item, index) => {
            console.log( "item",index, "size ", item.contents.length);
        });
    })
    .catch( error => {
        console.log( error );
    });
});

Jak to działa

promiseAllCzyni magię. To zajmuje blok funkcyjny podpisu function(item,index,resolve,reject), gdzie itemjest obecny element w tablicy, indexjej pozycja w tablicy, a resolvei rejectte Promisefunkcje zwrotne. Każda obietnica zostanie umieszczona w tablicy na bieżąco indexi z prądem itemjako argumentami poprzez anonimowe wywołanie funkcji:

promises.push( function(item,i) {
        return new Promise(function(resolve, reject) {
            return block.apply(this,[item,index,resolve,reject]);
        });
    }(item,index))

Wtedy wszystkie obietnice zostaną rozwiązane:

return Promise.all(promises);

1
Świetny kod Loreto, ale dlaczego nie użyć return block(item,index,resolve,reject);zamiast return block.apply(this,[item,index,resolve,reject]);, myślę, applyże utrudnia zrozumienie - czy istnieje korzyść, której nie jestem świadomy?
— Wskaźnik NULL

1
@NULLpointer thanks. Jedną z zalet zastosowania metody apply jest to, że można używać tablic do przekazywania argumentów, a ponadto można przekazać kontekst, w którym zdefiniowane są zmienne, takie jak self.apply (someObjContext, [arg1, arg2]). W tym konkretnym przypadku tak naprawdę tego nie potrzebujesz, ale jeśli jesteś w bibliotece ten kontekst obiektu może coś innego ...
— loretoparisi

10

Dla wszystkich poniższych przykładów musisz zaimportować moduły FS i path :

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

Czytaj pliki asynchronicznie

function readFiles(dir, processFile) {
  // read directory
  fs.readdir(dir, (error, fileNames) => {
    if (error) throw error;

    fileNames.forEach(filename => {
      // get current file name
      const name = path.parse(filename).name;
      // get current file extension
      const ext = path.parse(filename).ext;
      // get current file path
      const filepath = path.resolve(dir, filename);

      // get information about the file
      fs.stat(filepath, function(error, stat) {
        if (error) throw error;

        // check if the current path is a file or a folder
        const isFile = stat.isFile();

        // exclude folders
        if (isFile) {
          // callback, do something with the file
          processFile(filepath, name, ext, stat);
        }
      });
    });
  });
}

Stosowanie:

// use an absolute path to the folder where files are located
readFiles('absolute/path/to/directory/', (filepath, name, ext, stat) => {
  console.log('file path:', filepath);
  console.log('file name:', name);
  console.log('file extension:', ext);
  console.log('file information:', stat);
});

Czytaj pliki synchronicznie, przechowuj w tablicy, naturalne sortowanie

/**
 * @description Read files synchronously from a folder, with natural sorting
 * @param {String} dir Absolute path to directory
 * @returns {Object[]} List of object, each object represent a file
 * structured like so: `{ filepath, name, ext, stat }`
 */
function readFilesSync(dir) {
  const files = [];

  fs.readdirSync(dir).forEach(filename => {
    const name = path.parse(filename).name;
    const ext = path.parse(filename).ext;
    const filepath = path.resolve(dir, filename);
    const stat = fs.statSync(filepath);
    const isFile = stat.isFile();

    if (isFile) files.push({ filepath, name, ext, stat });
  });

  files.sort((a, b) => {
    // natural sort alphanumeric strings
    // https://stackoverflow.com/a/38641281
    return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: 'base' });
  });

  return files;
}

Stosowanie:

// return an array list of objects
// each object represent a file
const files = readFilesSync('absolute/path/to/directory/');

Czytaj pliki asynchronicznie przy użyciu obietnicy

Więcej informacji na temat promisify w tym artykule .

const { promisify } = require('util');

const readdir_promise = promisify(fs.readdir);
const stat_promise = promisify(fs.stat);

function readFilesAsync(dir) {
  return readdir_promise(dir, { encoding: 'utf8' })
    .then(filenames => {
      const files = getFiles(dir, filenames);

      return Promise.all(files);
    })
    .catch(err => console.error(err));
}

function getFiles(dir, filenames) {
  return filenames.map(filename => {
    const name = path.parse(filename).name;
    const ext = path.parse(filename).ext;
    const filepath = path.resolve(dir, filename);

    return stat({ name, ext, filepath });
  });
}

function stat({ name, ext, filepath }) {
  return stat_promise(filepath)
    .then(stat => {
      const isFile = stat.isFile();

      if (isFile) return { name, ext, filepath, stat };
    })
    .catch(err => console.error(err));
}

Stosowanie:

readFiles('absolute/path/to/directory/')
  // return an array list of objects
  // each object is a file
  // with those properties: { name, ext, filepath, stat }
  .then(files => console.log(files))
  .catch(err => console.log(err));

Uwaga: wróć undefineddo folderów, jeśli chcesz, możesz je odfiltrować:

readFiles('absolute/path/to/directory/')
  .then(files => files.filter(file => file !== undefined))
  .catch(err => console.log(err));

5

Czy jesteś leniwym człowiekiem jak ja i kochasz moduł npm : D to sprawdź to.

npm zainstaluj node-dir

przykład do czytania plików:

var dir = require('node-dir');

dir.readFiles(__dirname,
    function(err, content, next) {
        if (err) throw err;
        console.log('content:', content);  // get content of files
        next();
    },
    function(err, files){
        if (err) throw err;
        console.log('finished reading files:', files); // get filepath 
   });    

4

Jeśli masz Node.js 8 lub nowszy, możesz użyć nowego pliku util.promisify. (Oznaczam jako opcjonalne części kodu, które mają związek z ponownym formatowaniem jako obiekt, o który prosił oryginalny post).

  const fs = require('fs');
  const { promisify } = require('util');

  let files; // optional
  promisify(fs.readdir)(directory).then((filenames) => {
    files = filenames; // optional
    return Promise.all(filenames.map((filename) => {
      return promisify(fs.readFile)(directory + filename, {encoding: 'utf8'});
    }));
  }).then((strArr) => {
    // optional:
    const data = {};
    strArr.forEach((str, i) => {
      data[files[i]] = str;
    });
    // send data here
  }).catch((err) => {
    console.log(err);
  });

3

Kolejna wersja z nowoczesną metodą Promise. Jest krótszy, niż inne odpowiedzi oparte na Promise:

const readFiles = (dirname) => {

  const readDirPr = new Promise( (resolve, reject) => {
    fs.readdir(dirname, 
      (err, filenames) => (err) ? reject(err) : resolve(filenames))
  });

  return readDirPr.then( filenames => Promise.all(filenames.map((filename) => {
      return new Promise ( (resolve, reject) => {
        fs.readFile(dirname + filename, 'utf-8',
          (err, content) => (err) ? reject(err) : resolve(content));
      })
    })).catch( error => Promise.reject(error)))
};

readFiles(sourceFolder)
  .then( allContents => {

    // handle success treatment

  }, error => console.log(error));

ładne i rześkie! Dzięki @Paul
— Chaos Legion

1

Aby kod działał płynnie w różnych środowiskach, path.resolve może być używany w miejscach, w których manipuluje się ścieżką. Oto kod, który działa lepiej.

Część do czytania:

var fs = require('fs');

function readFiles(dirname, onFileContent, onError) {
  fs.readdir(dirname, function(err, filenames) {
    if (err) {
      onError(err);
      return;
    }
    filenames.forEach(function(filename) {
      fs.readFile(path.resolve(dirname, filename), 'utf-8', function(err, content) {
        if (err) {
          onError(err);
          return;
        }
        onFileContent(filename, content);
      });
    });
  });
}

Przechowywanie części:

var data = {};
readFiles(path.resolve(__dirname, 'dirname/'), function(filename, content) {
  data[filename] = content;
}, function(error) {
  throw err;
});

1

Właśnie napisałem to i wydaje mi się to bardziej przejrzyste:

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

const readdir = util.promisify(fs.readdir);
const readFile = util.promisify(fs.readFile);

const readFiles = async dirname => {
    try {
        const filenames = await readdir(dirname);
        console.log({ filenames });
        const files_promise = filenames.map(filename => {
            return readFile(dirname + filename, 'utf-8');
        });
        const response = await Promise.all(files_promise);
        //console.log({ response })
        //return response
        return filenames.reduce((accumlater, filename, currentIndex) => {
            const content = response[currentIndex];
            accumlater[filename] = {
                content,
            };
            return accumlater;
        }, {});
    } catch (error) {
        console.error(error);
    }
};

const main = async () => {

    const response = await readFiles(
        './folder-name',
    );
    console.log({ response });
};

Możesz zmodyfikować responseformat zgodnie ze swoimi potrzebami. responseFormat z tego kodu będzie wyglądać następująco:

{
   "filename-01":{
      "content":"This is the sample content of the file"
   },
   "filename-02":{
      "content":"This is the sample content of the file"
   }
}


0

async / await

const { promisify } = require("util")
const directory = path.join(__dirname, "/tmpl")
const pathnames = promisify(fs.readdir)(directory)

try {
  async function emitData(directory) {
    let filenames = await pathnames
    var ob = {}
    const data = filenames.map(async function(filename, i) {
      if (filename.includes(".")) {
        var storedFile = promisify(fs.readFile)(directory + `\\${filename}`, {
          encoding: "utf8",
        })
        ob[filename.replace(".js", "")] = await storedFile
        socket.emit("init", { data: ob })
      }
      return ob
    })
  }

  emitData(directory)
} catch (err) {
  console.log(err)
}

Kto chce spróbować z generatorami?

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.