Lire un fichier ligne par ligne, dans node.js?

Depuis Node.js v0.12 et comme de Node.js v4.0.0, il est stable readline module de base. Voici la façon la plus simple de lire les lignes d'un fichier, sans modules externes:

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 (comme de Nœud v0.12 ou plus tard), même si il n'y a pas de finale \n.

Mise à JOUR: cet exemple a été ajouté à un Nœud de l'API documentation officielle.

Vous n'avez pas à open le fichier, mais au lieu de cela, vous devez créer un ReadStream.

fs.createReadStream

Puis passer que les flux de Lazy

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

Vous pouvez toujours passer votre propre ligne de lecteur. J'ai pas comparé cet extrait, mais il correctement divise le flux entrant de morceaux en lignes sans le caractère nul '\n'

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

Je suis venu avec cette lorsque vous travaillez sur un rapide journal de l'analyse de script que nécessaire pour accumuler des données pendant le journal d'analyse et j'ai pensé qu'il serait sympa d'essayer de faire cela à l'aide de js et nœud au lieu de l'aide de perl, bash.

De toute façon, j'ai le sentiment que les petites nodejs le script doit être autonome et ne pas dépendre des modules tiers, donc après la lecture de toutes les réponses à cette question, chacun à l'aide de divers modules pour gérer la ligne de l'analyse, une 13 SLOC natif de nodejs solution pourrait être d'intérêt .

Je me suis retrouvé avec un énorme, énorme fuite de mémoire à l'aide de Paresseux pour lire ligne par ligne en essayant de les traiter ensuite de ces lignes et de les écrire dans un autre flux en raison de la manière de vidange/mettre en pause/reprendre dans le fonctionnement du nœud (voir: http://elegantcode.com/2011/04/06/taking-baby-steps-with-node-js-pumping-data-between-streams/ (j'adore ce mec d'ailleurs)). Je n'ai pas regardé d'assez près Paresseux pour comprendre exactement pourquoi, mais je ne pouvais pas interrompre ma lecture de flux afin de permettre une vidange sans Paresseux de quitter.

J'ai écrit le code pour traiter de très gros fichiers csv en xml docs, vous pouvez voir le code ici: https://github.com/j03m/node-csv2xml

Si vous exécutez les révisions précédentes avec Lazy ligne il ya des fuites. La dernière révision n'y a pas de fuite du tout, et vous pouvez probablement utiliser comme base pour un lecteur/processeur. Si j'ai quelques trucs là.

Edit: je suppose que je dois aussi préciser que mon code avec Lazy a bien fonctionné jusqu'à ce que j'ai trouvé moi-même écrit assez gros fragments xml qui drainent/mettre en pause/reprendre, car une nécessité. Pour de plus petits morceaux, il était beau.

Puisque l'envoi de ma réponse, j'ai trouvé que split est un très facile à utiliser nœud module de lecture de ligne dans un fichier; Qui accepte des paramètres facultatifs.

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

Ne l'ai pas testé sur de très gros fichiers. Laissez-nous savoir si vous le faites.

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

Mise à jour en 2019

Un impressionnant exemple est déjà posté sur officiel Nodejs documentation. ici

Cela nécessite la dernière Nodejs est 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();

Générateur de ligne de lecteur: 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());
}
});
});

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 est venu avec la solution ci-dessus
regarde similaires pour les autres, mais est asynchrone et peut lire des fichiers volumineux très rapidement

Espère que cette aide

Une autre solution consiste à exécuter la logique séquentielle via exécuteur nsynjs. Il lit le fichier ligne par ligne à l'aide du nœud readline module, et il n'utilise pas de promesses ou de la récursivité, donc ne pas aller à l'échec sur de gros fichiers. Voici comment le code ressemble à ceci:

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

Code ci-dessus est basée sur ce exampe: https://github.com/amaksr/nsynjs/blob/master/examples/node-readline/index.js

Alors vous devriez probablement utiliser la readline module de la réponse sommet suggère, readline semble être orienté vers des interfaces de ligne de commande plutôt que de la ligne de lecture. Il est également un peu plus opaque concernant la mise en mémoire tampon. (Quelqu'un qui a besoin d'un streaming ligne orientée lecteur sera probablement souhaitez modifier la taille du buffer). La readline module est ~1000 lignes, tout cela, avec des statistiques et de 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 même version plus courte, sans les stats, à 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);
});
}
}

J'envelopper l'ensemble de la logique du quotidien de la ligne de traitement en tant que mnp module: ligne-kit
https://www.npmjs.com/package/line-kit

JS:

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

J'ai regardé à travers toutes les réponses ci-dessus, tous d'entre eux utilisent la bibliothèque tierce pour le résoudre. C'est avoir une solution simple dans le Nœud de l'API. e.g

const fs= require('fs')
let stream = fs.createReadStream('<filename>', { autoClose: true })
stream.on('data', chunk => {
let row = chunk.toString('ascii')
}))