Lire un fichier une ligne à la fois dans node.js?

J'essaie de lire un gros fichier une ligne à la fois. J'ai trouvé une question sur Quora qui traitait du sujet, mais il me manque quelques connexions pour que tout cela s'emboîte.

 var Lazy=require("lazy");
 new Lazy(process.stdin)
     .lines
     .forEach(
          function(line) { 
              console.log(line.toString()); 
          }
 );
 process.stdin.resume();

Le peu que je voudrais comprendre, c'est comment je pourrais lire une ligne à la fois à partir d'un fichier au lieu de STDIN comme dans cet exemple.

J'ai essayé:

 fs.open('./VeryBigFile.csv', 'r', '0666', Process);

 function Process(err, fd) {
    if (err) throw err;
    // DO lazy read 
 }

mais ça ne marche pas. Je sais que dans un pincement je pourrais revenir à utiliser quelque chose comme PHP, mais je voudrais comprendre cela.

Je ne pense pas que l'autre réponse fonctionnerait car le fichier est beaucoup plus volumineux que le serveur sur lequel je l'exécute dispose de mémoire.

Depuis Node.js v0.12 et à partir de Node.js v4.0.0, il existe un module de base readline stable . Voici la manière la plus simple de lire des lignes d'un fichier, sans aucun module externe:

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

async function processLineByLine() {
  const fileStream = fs.createReadStream('input.txt');

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });
  // Note: we use the crlfDelay option to recognize all instances of CR LF
  // ('\r\n') in input.txt as a single line break.

  for await (const line of rl) {
    // Each line in input.txt will be successively available here as `line`.
    console.log(`Line from file: ${line}`);
  }
}

processLineByLine();

Ou bien:

var lineReader = require('readline').createInterface({
  input: require('fs').createReadStream('file.in')
});

lineReader.on('line', function (line) {
  console.log('Line from file:', line);
});

La dernière ligne est lue correctement (à partir de Node v0.12 ou ultérieure), même s'il n'y a pas de final \n.

MISE À JOUR : cet exemple a été ajouté à la documentation officielle de l'API de Node .

Pour une opération aussi simple, il ne devrait pas y avoir de dépendance vis-à-vis des modules tiers. Allez-y doucement.

var fs = require('fs'),
    readline = require('readline');

var rd = readline.createInterface({
    input: fs.createReadStream('/path/to/file'),
    output: process.stdout,
    console: false
});

rd.on('line', function(line) {
    console.log(line);
});

Vous n'avez pas besoin opendu fichier, mais à la place, vous devez créer un fichier ReadStream.

fs.createReadStream

Passez ensuite ce flux à Lazy

il y a un très joli module pour lire un fichier ligne par ligne, ça s'appelle lecteur de ligne

avec elle, vous écrivez simplement:

var lineReader = require('line-reader');

lineReader.eachLine('file.txt', function(line, last) {
  console.log(line);
  // do whatever you want with line...
  if(last){
    // or check if it's the last one
  }
});

vous pouvez même itérer le fichier avec une interface "style java", si vous avez besoin de plus de contrôle:

lineReader.open('file.txt', function(reader) {
  if (reader.hasNextLine()) {
    reader.nextLine(function(line) {
      console.log(line);
    });
  }
});

require('fs').readFileSync('file.txt', 'utf-8').split(/\r?\n/).forEach(function(line){
  console.log(line);
})

Mise à jour en 2019

Un exemple impressionnant est déjà publié sur la documentation officielle de Nodejs. ici

Cela nécessite que le dernier Nodejs soit installé sur votre machine. > 11,4

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

async function processLineByLine() {
  const fileStream = fs.createReadStream('input.txt');

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });
  // Note: we use the crlfDelay option to recognize all instances of CR LF
  // ('\r\n') in input.txt as a single line break.

  for await (const line of rl) {
    // Each line in input.txt will be successively available here as `line`.
    console.log(`Line from file: ${line}`);
  }
}

processLineByLine();

Ancien sujet, mais cela fonctionne:

var rl = readline.createInterface({
      input : fs.createReadStream('/path/file.txt'),
      output: process.stdout,
      terminal: false
})
rl.on('line',function(line){
     console.log(line) //or parse line
})

Facile. Pas besoin de module externe.

Vous pouvez toujours rouler votre propre lecteur de ligne. Je n'ai pas encore testé cet extrait, mais il divise correctement le flux entrant de morceaux en lignes sans le "\ n" de fin

var last = "";

process.stdin.on('data', function(chunk) {
    var lines, i;

    lines = (last+chunk).split("\n");
    for(i = 0; i < lines.length - 1; i++) {
        console.log("line: " + lines[i]);
    }
    last = lines[i];
});

process.stdin.on('end', function() {
    console.log("line: " + last);
});

process.stdin.resume();

J'ai trouvé cela lorsque je travaillais sur un script d'analyse de journal rapide qui devait accumuler des données pendant l'analyse de journal et je pensais que ce serait bien d'essayer de le faire en utilisant js et node au lieu d'utiliser perl ou bash.

Quoi qu'il en soit, je pense que les petits scripts nodejs devraient être autonomes et ne pas s'appuyer sur des modules tiers.Ainsi, après avoir lu toutes les réponses à cette question, chacun utilisant différents modules pour gérer l'analyse de ligne, une solution native 13 SLOC nodejs pourrait être intéressante.

Avec le module porteur :

var carrier = require('carrier');

process.stdin.resume();
carrier.carry(process.stdin, function(line) {
    console.log('got one line: ' + line);
});

Je me suis retrouvé avec une fuite de mémoire massive et massive en utilisant Lazy pour lire ligne par ligne lorsque j'essayais de traiter ces lignes et de les écrire dans un autre flux en raison de la façon dont drain / pause / resume dans le nœud fonctionne (voir: http: // elegcode .com / 2011/04/06 / prendre-pas-de-bébé-avec-noeud-js-pomper-les-données-entre-flux / (j'adore ce mec en passant)). Je n'ai pas regardé assez attentivement Lazy pour comprendre exactement pourquoi, mais je n'ai pas pu mettre en pause mon flux de lecture pour permettre un drain sans quitter Lazy.

J'ai écrit le code pour traiter des fichiers csv massifs en documents xml, vous pouvez voir le code ici: https://github.com/j03m/node-csv2xml

Si vous exécutez les révisions précédentes avec la ligne Lazy, cela fuit. La dernière révision ne fuit pas du tout et vous pouvez probablement l'utiliser comme base pour un lecteur / processeur. Bien que j'aie des trucs personnalisés là-dedans.

Edit: Je suppose que je devrais également noter que mon code avec Lazy a bien fonctionné jusqu'à ce que je me retrouve à écrire des fragments xml suffisamment grands qui drainent / s'arrêtent / reprennent à cause d'une nécessité. Pour les petits morceaux, c'était bien.

Éditer:

Utilisez un flux de transformation .

Avec un BufferedReader, vous pouvez lire des lignes.

new BufferedReader ("lorem ipsum", { encoding: "utf8" })
    .on ("error", function (error){
        console.log ("error: " + error);
    })
    .on ("line", function (line){
        console.log ("line: " + line);
    })
    .on ("end", function (){
        console.log ("EOF");
    })
    .read ();

Depuis la publication de ma réponse d'origine, j'ai découvert que split est un module de nœud très facile à utiliser pour la lecture de ligne dans un fichier; Qui accepte également des paramètres facultatifs.

var split = require('split');
fs.createReadStream(file)
    .pipe(split())
    .on('data', function (line) {
      //each chunk now is a seperate line! 
    });

N'ont pas été testés sur de très gros fichiers. Faites-nous savoir si vous le faites.

J'étais frustré par l'absence d'une solution complète pour cela, alors j'ai mis en place ma propre tentative ( git / npm ). Liste des fonctionnalités copiées-collées:

• Traitement de ligne interactif (basé sur le rappel, pas de chargement de tout le fichier dans la RAM)
• Facultativement, renvoyez toutes les lignes dans un tableau (mode détaillé ou brut)
• Interrompez le streaming de manière interactive ou effectuez un traitement de type carte / filtre
• Détectez toute convention de nouvelle ligne (PC / Mac / Linux)
• Traitement eof / last line correct
• Gestion correcte des caractères UTF-8 multi-octets
• Récupérer les informations de décalage et de longueur d'octet par ligne
• Accès aléatoire, à l'aide de décalages basés sur des lignes ou des octets
• Mappez automatiquement les informations de décalage de ligne pour accélérer l'accès aléatoire
• Zéro dépendances
• Les tests

NIH? Tu décides :-)

function createLineReader(fileName){
    var EM = require("events").EventEmitter
    var ev = new EM()
    var stream = require("fs").createReadStream(fileName)
    var remainder = null;
    stream.on("data",function(data){
        if(remainder != null){//append newly received data chunk
            var tmp = new Buffer(remainder.length+data.length)
            remainder.copy(tmp)
            data.copy(tmp,remainder.length)
            data = tmp;
        }
        var start = 0;
        for(var i=0; i<data.length; i++){
            if(data[i] == 10){ //\n new line
                var line = data.slice(start,i)
                ev.emit("line", line)
                start = i+1;
            }
        }
        if(start<data.length){
            remainder = data.slice(start);
        }else{
            remainder = null;
        }
    })

    stream.on("end",function(){
        if(null!=remainder) ev.emit("line",remainder)
    })

    return ev
}


//---------main---------------
fileName = process.argv[2]

lineReader = createLineReader(fileName)
lineReader.on("line",function(line){
    console.log(line.toString())
    //console.log("++++++++++++++++++++")
})

Je voulais aborder ce même problème, essentiellement ce que serait en Perl:

while (<>) {
    process_line($_);
}

Mon cas d'utilisation était juste un script autonome, pas un serveur, donc synchrone était bien. Ce sont mes critères:

• Le code synchrone minimal qui pourrait être réutilisé dans de nombreux projets.
• Aucune limite sur la taille du fichier ou le nombre de lignes.
• Aucune limite sur la longueur des lignes.
• Capable de gérer Unicode complet en UTF-8, y compris les caractères au-delà du BMP.
• Capable de gérer les terminaisons de ligne * nix et Windows (un Mac à l'ancienne n'est pas nécessaire pour moi).
• Caractère (s) de fin de ligne à inclure dans les lignes.
• Capable de gérer la dernière ligne avec ou sans caractères de fin de ligne.
• N'utilisez aucune bibliothèque externe non incluse dans la distribution node.js.

C'est un projet pour moi d'avoir une idée du code de type de script de bas niveau dans node.js et de décider de sa viabilité en remplacement d'autres langages de script comme Perl.

Après un effort surprenant et quelques faux départs, voici le code que j'ai trouvé. C'est assez rapide mais moins trivial que ce à quoi je m'attendais: (forkez-le sur GitHub)

var fs            = require('fs'),
    StringDecoder = require('string_decoder').StringDecoder,
    util          = require('util');

function lineByLine(fd) {
  var blob = '';
  var blobStart = 0;
  var blobEnd = 0;

  var decoder = new StringDecoder('utf8');

  var CHUNK_SIZE = 16384;
  var chunk = new Buffer(CHUNK_SIZE);

  var eolPos = -1;
  var lastChunk = false;

  var moreLines = true;
  var readMore = true;

  // each line
  while (moreLines) {

    readMore = true;
    // append more chunks from the file onto the end of our blob of text until we have an EOL or EOF
    while (readMore) {

      // do we have a whole line? (with LF)
      eolPos = blob.indexOf('\n', blobStart);

      if (eolPos !== -1) {
        blobEnd = eolPos;
        readMore = false;

      // do we have the last line? (no LF)
      } else if (lastChunk) {
        blobEnd = blob.length;
        readMore = false;

      // otherwise read more
      } else {
        var bytesRead = fs.readSync(fd, chunk, 0, CHUNK_SIZE, null);

        lastChunk = bytesRead !== CHUNK_SIZE;

        blob += decoder.write(chunk.slice(0, bytesRead));
      }
    }

    if (blobStart < blob.length) {
      processLine(blob.substring(blobStart, blobEnd + 1));

      blobStart = blobEnd + 1;

      if (blobStart >= CHUNK_SIZE) {
        // blobStart is in characters, CHUNK_SIZE is in octets
        var freeable = blobStart / CHUNK_SIZE;

        // keep blob from growing indefinitely, not as deterministic as I'd like
        blob = blob.substring(CHUNK_SIZE);
        blobStart -= CHUNK_SIZE;
        blobEnd -= CHUNK_SIZE;
      }
    } else {
      moreLines = false;
    }
  }
}

Il pourrait probablement être nettoyé davantage, c'était le résultat d'essais et d'erreurs.

Dans la plupart des cas, cela devrait suffire:

const fs = require("fs")

fs.readFile('./file', 'utf-8', (err, file) => {
  const lines = file.split('\n')

  for (let line of lines)
    console.log(line)
});

Lecteur de ligne basé sur générateur: https://github.com/neurosnap/gen-readlines

var fs = require('fs');
var readlines = require('gen-readlines');

fs.open('./file.txt', 'r', function(err, fd) {
  if (err) throw err;
  fs.fstat(fd, function(err, stats) {
    if (err) throw err;

    for (var line of readlines(fd, stats.size)) {
      console.log(line.toString());
    }

  });
});

Si vous voulez lire un fichier ligne par ligne et l'écrire dans un autre:

var fs = require('fs');
var readline = require('readline');
var Stream = require('stream');

function readFileLineByLine(inputFile, outputFile) {

   var instream = fs.createReadStream(inputFile);
   var outstream = new Stream();
   outstream.readable = true;
   outstream.writable = true;

   var rl = readline.createInterface({
      input: instream,
      output: outstream,
      terminal: false
   });

   rl.on('line', function (line) {
        fs.appendFileSync(outputFile, line + '\n');
   });
};

var fs = require('fs');

function readfile(name,online,onend,encoding) {
    var bufsize = 1024;
    var buffer = new Buffer(bufsize);
    var bufread = 0;
    var fd = fs.openSync(name,'r');
    var position = 0;
    var eof = false;
    var data = "";
    var lines = 0;

    encoding = encoding || "utf8";

    function readbuf() {
        bufread = fs.readSync(fd,buffer,0,bufsize,position);
        position += bufread;
        eof = bufread ? false : true;
        data += buffer.toString(encoding,0,bufread);
    }

    function getLine() {
        var nl = data.indexOf("\r"), hasnl = nl !== -1;
        if (!hasnl && eof) return fs.closeSync(fd), online(data,++lines), onend(lines); 
        if (!hasnl && !eof) readbuf(), nl = data.indexOf("\r"), hasnl = nl !== -1;
        if (!hasnl) return process.nextTick(getLine);
        var line = data.substr(0,nl);
        data = data.substr(nl+1);
        if (data[0] === "\n") data = data.substr(1);
        online(line,++lines);
        process.nextTick(getLine);
    }
    getLine();
}

J'ai eu le même problème et j'ai trouvé la solution ci-dessus qui ressemble à d'autres, mais est aSync et peut lire des fichiers volumineux très rapidement

Espère que cela aide

J'ai un petit module qui le fait bien et qui est utilisé par un certain nombre d'autres projets npm readline Notez que dans le nœud v10, il y a un module natif readline, j'ai donc republié mon module en ligne par ligne https://www.npmjs.com/package/ ligne par ligne

si vous ne souhaitez pas utiliser le module, la fonction est très simple:

var fs = require('fs'),
EventEmitter = require('events').EventEmitter,
util = require('util'),
newlines = [
  13, // \r
  10  // \n
];
var readLine = module.exports = function(file, opts) {
if (!(this instanceof readLine)) return new readLine(file);

EventEmitter.call(this);
opts = opts || {};
var self = this,
  line = [],
  lineCount = 0,
  emit = function(line, count) {
    self.emit('line', new Buffer(line).toString(), count);
  };
  this.input = fs.createReadStream(file);
  this.input.on('open', function(fd) {
    self.emit('open', fd);
  })
  .on('data', function(data) {
   for (var i = 0; i < data.length; i++) {
    if (0 <= newlines.indexOf(data[i])) { // Newline char was found.
      lineCount++;
      if (line.length) emit(line, lineCount);
      line = []; // Empty buffer.
     } else {
      line.push(data[i]); // Buffer new line data.
     }
   }
 }).on('error', function(err) {
   self.emit('error', err);
 }).on('end', function() {
  // Emit last line if anything left over since EOF won't trigger it.
  if (line.length){
     lineCount++;
     emit(line, lineCount);
  }
  self.emit('end');
 }).on('close', function() {
   self.emit('close');
 });
};
util.inherits(readLine, EventEmitter);

Une autre solution consiste à exécuter la logique via l'exécuteur séquentiel nsynjs . Il lit les fichiers ligne par ligne à l'aide du module de lecture en ligne du nœud, et il n'utilise pas de promesses ou de récursivité, donc n'échouera pas sur les fichiers volumineux. Voici à quoi ressemblera le code:

var nsynjs = require('nsynjs');
var textFile = require('./wrappers/nodeReadline').textFile; // this file is part of nsynjs

function process(textFile) {

    var fh = new textFile();
    fh.open('path/to/file');
    var s;
    while (typeof(s = fh.readLine(nsynjsCtx).data) != 'undefined')
        console.log(s);
    fh.close();
}

var ctx = nsynjs.run(process,{},textFile,function () {
    console.log('done');
});

Le code ci-dessus est basé sur cet exemple: https://github.com/amaksr/nsynjs/blob/master/examples/node-readline/index.js

Deux questions que nous devons nous poser lors de telles opérations sont:

1. Quelle est la quantité de mémoire utilisée pour l'exécuter?
2. La consommation de mémoire augmente-t-elle considérablement avec la taille du fichier?

Des solutions comme require('fs').readFileSync()charge tout le fichier en mémoire. Cela signifie que la quantité de mémoire requise pour effectuer des opérations sera presque équivalente à la taille du fichier. Nous devons les éviter pour tout ce qui dépasse50mbs

Nous pouvons facilement suivre la quantité de mémoire utilisée par une fonction en plaçant ces lignes de code après l'invocation de la fonction:

    const used = process.memoryUsage().heapUsed / 1024 / 1024;
    console.log(
      `The script uses approximately ${Math.round(used * 100) / 100} MB`
    );

En ce moment , la meilleure façon de lire certaines lignes à partir d' un fichier volumineux utilise du nœud de readline . La documentation a des exemples étonnants .

Bien que nous n'ayons pas besoin d'un module tiers pour le faire. Mais, si vous écrivez un code d'entreprise, vous devez gérer de nombreux cas marginaux. J'ai dû écrire un module très léger appelé Apick File Storage pour gérer tous ces cas extrêmes.

Module de stockage de fichiers Apick: https://www.npmjs.com/package/apickfs Documentation: https://github.com/apickjs/apickFS#readme

Exemple de fichier: https://1drv.ms/t/s!AtkMCsWInsSZiGptXYAFjalXOpUx

Exemple: installer le module

npm i apickfs

// import module
const apickFileStorage = require('apickfs');

//invoke readByLineNumbers() method
apickFileStorage
  .readByLineNumbers(path.join(__dirname), 'big.txt', [163845])
  .then(d => {
    console.log(d);
  })
  .catch(e => {
    console.log(e);
  });

Cette méthode a été testée avec succès jusqu'à 4 Go de fichiers denses.

big.text est un fichier texte dense avec 163 845 lignes et est de 124 Mo. Le script pour lire 10 lignes différentes de ce fichier utilise environ 4,63 Mo de mémoire seulement. Et il analyse gratuitement le JSON valide en objets ou tableaux. 🥳 Génial !!

Nous pouvons lire une seule ligne du fichier ou des centaines de lignes du fichier avec très peu de consommation de mémoire.

j'utilise ceci:

function emitLines(stream, re){
    re = re && /\n/;
    var buffer = '';

    stream.on('data', stream_data);
    stream.on('end', stream_end);

    function stream_data(data){
        buffer += data;
        flush();
    }//stream_data

    function stream_end(){
        if(buffer) stream.emmit('line', buffer);
    }//stream_end


    function flush(){
        var re = /\n/;
        var match;
        while(match = re.exec(buffer)){
            var index = match.index + match[0].length;
            stream.emit('line', buffer.substring(0, index));
            buffer = buffer.substring(index);
            re.lastIndex = 0;
        }
    }//flush

}//emitLines

utilisez cette fonction sur un flux et écoutez les événements de ligne qui seront émis.

gr-

Bien que vous deviez probablement utiliser le readlinemodule comme le suggère la réponse du haut, il readlinesemble être orienté vers les interfaces de ligne de commande plutôt que vers la lecture de ligne. Il est également un peu plus opaque en ce qui concerne la mise en mémoire tampon. (Quiconque a besoin d'un lecteur orienté ligne de streaming voudra probablement modifier la taille des tampons). Le module readline fait ~ 1000 lignes alors que celui-ci, avec statistiques et tests, est de 34.

const EventEmitter = require('events').EventEmitter;
class LineReader extends EventEmitter{
    constructor(f, delim='\n'){
        super();
        this.totalChars = 0;
        this.totalLines = 0;
        this.leftover = '';

        f.on('data', (chunk)=>{
            this.totalChars += chunk.length;
            let lines = chunk.split(delim);
            if (lines.length === 1){
                this.leftover += chunk;
                return;
            }
            lines[0] = this.leftover + lines[0];
            this.leftover = lines[lines.length-1];
            if (this.leftover) lines.pop();
            this.totalLines += lines.length;
            for (let l of lines) this.onLine(l);
        });
        // f.on('error', ()=>{});
        f.on('end', ()=>{console.log('chars', this.totalChars, 'lines', this.totalLines)});
    }
    onLine(l){
        this.emit('line', l);
    }
}
//Command line test
const f = require('fs').createReadStream(process.argv[2], 'utf8');
const delim = process.argv[3];
const lineReader = new LineReader(f, delim);
lineReader.on('line', (line)=> console.log(line));

Voici une version encore plus courte, sans les statistiques, à 19 lignes:

class LineReader extends require('events').EventEmitter{
    constructor(f, delim='\n'){
        super();
        this.leftover = '';
        f.on('data', (chunk)=>{
            let lines = chunk.split(delim);
            if (lines.length === 1){
                this.leftover += chunk;
                return;
            }
            lines[0] = this.leftover + lines[0];
            this.leftover = lines[lines.length-1];
            if (this.leftover) 
                lines.pop();
            for (let l of lines)
                this.emit('line', l);
        });
    }
}

const fs = require("fs")

fs.readFile('./file', 'utf-8', (err, data) => {
var innerContent;
    console.log("Asynchronous read: " + data.toString());
    const lines = data.toString().split('\n')
    for (let line of lines)
        innerContent += line + '<br>';


});

J'enveloppe toute la logique du traitement de ligne quotidien comme un module npm: kit de ligne https://www.npmjs.com/package/line-kit

// example
var count = 0
require('line-kit')(require('fs').createReadStream('/etc/issue'),
                    (line) => { count++; },
                    () => {console.log(`seen ${count} lines`)})

J'utilise ci-dessous le code des lignes de lecture après avoir vérifié que ce n'est pas un répertoire et qu'il n'est pas inclus dans la liste des fichiers n'a pas besoin d'être vérifié.

(function () {
  var fs = require('fs');
  var glob = require('glob-fs')();
  var path = require('path');
  var result = 0;
  var exclude = ['LICENSE',
    path.join('e2e', 'util', 'db-ca', 'someother-file'),
    path.join('src', 'favicon.ico')];
  var files = [];
  files = glob.readdirSync('**');

  var allFiles = [];

  var patternString = [
    'trade',
    'order',
    'market',
    'securities'
  ];

  files.map((file) => {
    try {
      if (!fs.lstatSync(file).isDirectory() && exclude.indexOf(file) === -1) {
        fs.readFileSync(file).toString().split(/\r?\n/).forEach(function(line){
          patternString.map((pattern) => {
            if (line.indexOf(pattern) !== -1) {
              console.log(file + ' contain `' + pattern + '` in in line "' + line +'";');
              result = 1;
            }
          });
        });
      }
    } catch (e) {
      console.log('Error:', e.stack);
    }
  });
  process.exit(result);

})();

J'ai regardé toutes les réponses ci-dessus, toutes utilisent une bibliothèque tierce pour le résoudre. C'est une solution simple dans l'API de Node. par exemple

const fs= require('fs')

let stream = fs.createReadStream('<filename>', { autoClose: true })

stream.on('data', chunk => {
    let row = chunk.toString('ascii')
}))