Читання всіх файлів у каталозі, зберігання їх у об’єктах та надсилання об’єкта


91

Я не знаю, чи можливо це, але тут йдеться. А робота зі зворотними викликами ще більше ускладнює.

У мене є каталог із файлами html, який я хочу відправити назад клієнту в фрагментах об’єктів з node.js та socket.io.

Усі мої файли знаходяться в / tmpl

Отже, сокет повинен прочитати всі файли в / tmpl.

для кожного файлу він повинен зберігати дані в об’єкті з іменем файлу як ключем, а вміст як значення.

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

Остаточний зворотний дзвінок також помилковий. Його потрібно викликати, коли всі файли в каталозі закінчені.

Але я не знаю, як створити код, хтось знає, чи це можливо?


4
Якщо синхронний доступ нормальний, ви можете пропустити обробник подій, використовуючи (блокування) readfileSyncта readdirSyncметоди. nodejs.org/docs/v0.4.8/api/fs.html#fs.readdirSync
— rjz

Гаразд, я не знав про readdir, це може бути корисно. І в чому мінуси блокування. Я думав, що вся суть node.js у тому, що він не блокується? Чому ми можемо раптово заблокувати?
— Сайф Бечан,

Для асинхронних зворотних викликів прочитайте це: stackoverflow.com/questions/18983138/... Є багато неправильних відповідей, але деякі є правильними. Один з них використовує лічильники.
— Вануан

Відповіді:


169

Отже, є три частини. Читання, зберігання та надсилання.

Ось частина для читання:

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

Ось частина зберігання:

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

Частина відправлення залежить від вас. Можливо, ви захочете надіслати їх по одному або після завершення читання.

Якщо ви хочете надіслати файли після завершення читання, вам слід скористатися синхронізованими версіями fsфункцій або використовувати обіцянки. Асинхронні зворотні дзвінки не є хорошим стилем.

Крім того, ви запитали про зачищення розширення. Ви повинні продовжувати запитання по одному. Ніхто не напише повного рішення лише для вас.


Дякую, я думаю, що скористаюся цим. Одне, ти можеш пояснити, що 0===--cробить.
— Сайф Бечан,

1
Ви можете написати це у два рядки, c--і тоді if (c===0)це однаково. Це просто декрементируется cвід 1і перевіряє , є чи він досяг нуля
— stewe

Але завжди буде 0, чи ні? Ви додаєте 1 у foreach, а в тому ж foreach ви видаляєте 1, тому він завжди залишається 0, або я помиляюся? Чи не повинен бути чек if(c===files.length), щось подібне.
— Сайф Бечан,

5
Через асинхронну природу цикл foreach, швидше за все, закінчується до readFileповернення першого html, тому cслід негайно перейти до x(кількість файлів), а потім зменшити, коли html надійде з диска (що набагато пізніше)
— stewe

1
О, це там якась глибока логіка, приємна. Треба багато дізнатись про вузол. Дякую за допомогу!
— Сайф Бечан,

16

Це сучасна Promiseверсія попередньої, що використовує Promise.allпідхід для вирішення всіх обіцянок, коли всі файли прочитані:

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

Як користуватися ним:

Так само просто, як і робити:

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

Припустимо, що у вас є інший список папок, ви також можете переглядати цей список, оскільки внутрішній promis.all вирішить кожну з них асинхронно:

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

Як це працює

promiseAllРобить магію. Він приймає функціональний блок підпису function(item,index,resolve,reject), де itemзнаходиться поточний елемент у масиві, indexйого позиція в масиві resolveта rejectфункції Promiseзворотного виклику. Кожна обіцянка буде висунута в масив у поточному indexі з поточним itemяк аргументи через анонімний виклик функції:

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

1
Чудовий код Loreto, але чому б не використовувати його return block(item,index,resolve,reject);замість return block.apply(this,[item,index,resolve,reject]);, я думаю, applyце ускладнює розуміння - чи є користь, про яку я не знаю?
— покажчик NULL

1
@NULLpointer дякую. Однією з переваг застосунку є те, що ви можете використовувати масиви для передачі аргументів, а більше - передавати контекст, де змінні визначаються як self.apply (someObjContext, [arg1, arg2]). У цьому конкретному випадку він вам насправді не потрібен, але якщо ви перебуваєте в бібліотеці, контекст цього об’єкта, можливо, щось інше ...
— loretoparisi

10

Для всіх прикладів нижче потрібно імпортувати fs та модулі шляху :

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

Читати файли асинхронно

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

Використання:

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

Читання файлів синхронно, зберігання в масиві, природне сортування

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

Використання:

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

Читати файли асинхронно, використовуючи обіцянку

Більше інформації про promisify у цій статті .

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

Використання:

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

Примітка: поверніться undefinedдо папок, якщо ви хочете, ви можете їх відфільтрувати:

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

5

Ви така ледача, як я, і любите модуль npm : D, тоді перевірте це.

npm встановити node-dir

приклад для читання файлів:

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

Якщо у вас Node.js 8 або пізнішої версії, ви можете використовувати новий util.promisify. (Я позначаю як необов’язкові частини коду, пов’язані з переформатуванням як об’єкт, про що вимагав оригінальний пост.)

  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

Ще одна версія із сучасним методом Promise. Коротше, ніж інші відповіді на основі 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));

приємно та чітко! Спасибі @Paul
— Chaos Legion

1

Щоб код працював гладко в різних середовищах, path.resolve можна використовувати там, де маніпулюють шляхом. Ось код, який працює краще.

Частина для читання:

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

Зберігання частини:

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

1

Я щойно написав це, і мені це виглядає більш чисто:

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

Ви можете змінити responseформат відповідно до своїх потреб. responseФормат з цього коду буде виглядати наступним чином :

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

Хто хоче спробувати з генераторами?

Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.