Node.js: conta il numero di righe in un file

Question

I file di testo di grandi dimensioni sono compresi tra 30MB e 10GB. Come posso contare il numero di righe in un file usando Node.js?

ho queste limitazioni:

• L'intero file non ha bisogno di essere scritto nella memoria
• Un processo figlio non è tenuto a svolgere il compito

Answer 1

senza di noi ing wc:

var i; 
var count = 0; 
require('fs').createReadStream(process.argv[2]) 
    .on('data', function(chunk) { 
    for (i=0; i < chunk.length; ++i) 
     if (chunk[i] == 10) count++; 
    }) 
    .on('end', function() { 
    console.log(count); 
    }); 

è più lento, ma non così tanto ci si potrebbe aspettare - 0.6s per 140M + di file compreso il tempo di caricamento node.js & avvio

>time node countlines.js video.mp4 
619643 

real 0m0.614s 
user 0m0.489s 
sys 0m0.132s 

>time wc -l video.mp4 
619643 video.mp4 
real 0m0.133s 
user 0m0.108s 
sys 0m0.024s 

>wc -c video.mp4 
144681406 video.mp4 

Answer 2

Si potrebbe fare questo come suggeriscono i commenti utilizzando la soluzione wc

var exec = require('child_process').exec; 

exec('wc /path/to/file', function (error, results) { 
    console.log(results); 
}); 

Answer 3

dal iojs 1.5.0 c'è Buffer#indexOf() metodo , usandolo per confrontare con la risposta di Andrey Sidorov:

ubuntu@server:~$ wc logs 
    7342500 27548750 427155000 logs 
ubuntu@server:~$ time wc -l logs 
7342500 logs 

real 0m0.180s 
user 0m0.088s 
sys 0m0.084s 
ubuntu@server:~$ nvm use node 
Now using node v0.12.1 
ubuntu@server:~$ time node countlines.js logs 
7342500 

real 0m2.559s 
user 0m2.200s 
sys 0m0.340s 
ubuntu@server:~$ nvm use iojs 
Now using node iojs-v1.6.2 
ubuntu@server:~$ time iojs countlines2.js logs 
7342500 

real 0m1.363s 
user 0m0.920s 
sys 0m0.424s 
ubuntu@server:~$ cat countlines.js 
var i; 
var count = 0; 
require('fs').createReadStream(process.argv[2]) 
    .on('data', function(chunk) { 
    for (i=0; i < chunk.length; ++i) 
     if (chunk[i] == 10) count++; 
    }) 
    .on('end', function() { 
    console.log(count); 
    }); 
ubuntu@server:~$ cat countlines2.js 
var i; 
var count = 0; 
require('fs').createReadStream(process.argv[2]) 
    .on('data', function(chunk) { 
    var index = -1; 
    while((index = chunk.indexOf(10, index + 1)) > -1) count++ 
    }) 
    .on('end', function() { 
    console.log(count); 
    }); 
ubuntu@server:~$ 

Answer 4

Ecco un altro modo senza così tanto nidificazione.

var fs = require('fs'); 
filePath = process.argv[2]; 
fileBuffer = fs.readFileSync(filePath); 
to_string = fileBuffer.toString(); 
split_lines = to_string.split("\n"); 
console.log(split_lines.length-1); 

Answer 5

è possibile utilizzare anche indexOf():

var index = -1; 
var count = 0; 
while ((index = chunk.indexOf(10, index + 1)) > -1) count++; 

Answer 6

var fs=require('fs'); 
filename=process.argv[2]; 
var data=fs.readFileSync(filename); 
var res=data.toString().split('\n').length; 
console.log(res-1);` 

Answer 7

C'è un modulo NPM chiamato count-lines-in-file. L'ho usato per file piccoli (< righe) e ha funzionato benissimo finora.

Answer 8

Possiamo usare indexOf di lasciare che il VM trovare i ritorni a capo:

function countFileLines(filePath){ 
    return new Promise((resolve, reject) => { 
    let lineCount = 0; 
    fs.createReadStream(filePath) 
    .on("data", (buffer) => { 
     let idx = -1; 
     lineCount--; // Because the loop will run once for idx=-1 
     do { 
     idx = buffer.indexOf(10, idx+1); 
     lineCount++; 
     } while (idx !== -1); 
    }).on("end",() => { 
     resolve(lineCount); 
    }).on("error", reject); 
    }); 
}; 

Cosa questa soluzione non è che si trova la posizione del primo ritorno a capo usando .indexOf. Incrementa lineCount, quindi trova la posizione successiva. Il secondo parametro su .indexOf indica dove iniziare a cercare le nuove linee. In questo modo stiamo saltando su grandi blocchi del buffer. Il ciclo while verrà eseguito una volta per ogni nuova riga, più una.

Stiamo facendo in modo che il runtime del nodo esegua la ricerca che è implementato a un livello inferiore e dovrebbe essere più veloce.

Sul mio sistema questo è circa il doppio della velocità di un ciclo for sulla lunghezza del buffer su un file di grandi dimensioni (111 MB).