Node.js: Cuente el número de líneas en un archivo

Question

Tengo archivos de texto grandes, que oscilan entre 30MB y 10GB. ¿Cómo puedo contar el número de líneas en un archivo usando Node.js?

tengo estas limitaciones:

• El archivo completo no necesita ser escrito en la memoria
• Un proceso hijo no está obligado a realizar la tarea

Answer 1

solución sin nosotros 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); 
    }); 

es más lento, pero no tanto se podría esperar - 0,6 s para 140M + archivo incluyendo el tiempo de carga Node.js & inicio

>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

Se podría hacer esto como los comentarios sugieren usar wc

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

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

Answer 3

desde iojs 1.5.0 no es Buffer#indexOf() método , usándolo para compararlo con la respuesta de 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

Aquí hay otra forma de anidar.

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

También puede usar 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

Hay un módulo de NPM llamada count-lines-in-file. Lo he estado usando para archivos pequeños (< 1000 líneas) y hasta ahora ha funcionado muy bien.

Answer 8

Podemos utilizar indexOf dejar que la máquina virtual encontrar las nuevas líneas:

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

Lo que esto hace es que la solución se encuentra la posición de la primera línea nueva usando .indexOf. Incrementa lineCount, luego encuentra la siguiente posición. El segundo parámetro para .indexOf indica dónde comenzar a buscar nuevas líneas. De esta forma saltamos sobre grandes porciones del buffer. El ciclo while se ejecutará una vez por cada nueva línea, más uno.

Estamos dejando que el tiempo de ejecución del nodo haga la búsqueda para nosotros, que se implementa en un nivel inferior y debe ser más rápido.

En mi sistema, esto es aproximadamente el doble de rápido que ejecutar un bucle for sobre la longitud del búfer en un archivo grande (111 MB).