Leer un archivo línea por línea en Node.js

Introducción

En Ciencias de la Computación, un archivo es un recurso que se utiliza para registrar datos discretamente en el dispositivo de almacenamiento de una computadora. Node.js no anula esto de ninguna manera y funciona con cualquier cosa que se considere un archivo en su sistema de archivos.

La lectura de archivos y recursos tiene muchos usos:

• Estadísticas, análisis e informes
• Machine Learning
• Manejo de registros o archivos de texto grandes

A veces, estos archivos pueden ser absurdamente grandes, con gigabytes o terabytes almacenados, y leerlos en su totalidad es ineficaz.

Poder leer un archivo línea por línea nos da la capacidad de buscar solo la información relevante y detener la búsqueda una vez que hayamos encontrado lo que estamos buscando. También nos permite dividir los datos en partes lógicas, como si el archivo tuviera formato CSV.

Readline (desde v0.12 en adelante)

Node.js tiene el módulo nativo para leer archivos que nos permite leer línea por línea. Se agregó en 2015 y está destinado a leer de cualquier Readable transmitir una línea a la vez.

Este hecho la convierte en una opción versátil, adecuada no solo para archivos sino incluso para entradas de línea de comando como process.stdin. La documentación sobre readline se pudo encontrar el módulo Aquí.

Como readline es un módulo nativo. No tienes que usar npm a cualquier otro administrador de paquetes para agregarlo, solo require:

const readline = require('readline');

¡y listo!

Como el readline El método debe ser provisto con una secuencia, primero tenemos que crearlo usando otro módulo nativo – fs:

const fs = require('fs');

El siguiente paso es crear el objeto que leerá de la secuencia usando createInterface() función:

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

Asegúrate de sustituir /path/to/file con la ruta real a un archivo en su sistema de archivos.

Una vez realizada la preparación, la lectura de un archivo línea por línea e imprimir su contenido en la consola se puede realizar de la siguiente manera:

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

Aquí esencialmente estamos diciendo que siempre que el line evento ocurre en el readInterface debería llamar a nuestra función y pasarle el contenido leído de la secuencia. En nuestro caso, no queremos complicar demasiado las cosas y simplemente imprimirlo en la consola.

Lector de línea

Después de una explicación detallada de cómo puede leer un archivo línea por línea usando el módulo nativo Node.js, echemos un vistazo a una versión más corta usando el código abierto lector de línea módulo de npm.

Como es un módulo no nativo, debemos asegurarnos de haber inicializado el proyecto npm de manera adecuada con npm init y luego instalarlo:

$ npm install --save line-reader

Esto instalará la dependencia y la agregará al package.json archivo.

Una vez hecho esto, leer un archivo línea por línea es similar al ejemplo anterior solo sin crear una readInterface en el medio:

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

lineReader.eachLine('/path/to/file', function(line) {
    console.log(line);
});

Una característica bastante útil aquí es dejar de leer cuando alguna condición se vuelve verdadera. Esto se logra simplemente regresando false desde la función de devolución de llamada.

Por ejemplo, podríamos leer un archivo línea por línea hasta que encontremos una línea que contenga la palabra «DETENER»:

lineReader.eachLine('path/to/file', function(line) {
    console.log(line);
    if (line.includes('STOP') {
        return false; // stop reading
    }
});

Hay un enfoque ligeramente diferente, que utiliza dos devoluciones de llamada anidadas y una sintaxis que puede parecer más natural para los desarrolladores de Java:

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

Aquí, estamos usando el open() función, que no nos proporciona las líneas de un archivo al instante, sino que nos da una reader. Tiene su propio conjunto de funciones como hasNextLine() y nextLine() lo que nos permite tener un poco más de control sobre el proceso de lectura de un archivo línea por línea en Node.js.

N-readlines

El módulo npm proporciona una sintaxis diferente n-readlines:

Vamos a instalarlo:

$ npm install --save n-readlines

Y lo requieres:

const lineByLine = require('n-readlines');

Para poder leer desde un archivo, debemos crear un nuevo objeto, proporcionando una ruta a nuestro archivo como argumento:

const liner = new lineByLine('/path/to/file');

Obtener las líneas del archivo se realiza llamando al next función:

let line;
 
while (line = liner.next()) {
    console.log(line);
}

Una función interesante del n-readlines el módulo es reset(). Restablece el puntero e inicia el proceso de lectura desde el principio del archivo.

Nota: Funciona solo si no se llega al final.

Errores comunes

Un error común al leer un archivo línea por línea en Node.js es leer el archivo completo en la memoria y luego dividir su contenido por saltos de línea.

Aquí hay un ejemplo incorrecto que podría sobrecargar su sistema si le proporciona un archivo lo suficientemente grande:

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

A primera vista, parece que el resultado es el mismo para este enfoque y para los anteriores y, de hecho, funciona bien para archivos pequeños. Pero adelante, intente trabajar con uno grande. Definitivamente no es algo que quiera ver en su sistema de producción.

Conclusión

Hay varias formas de leer un archivo línea por línea en Node.js, y la selección del enfoque apropiado es completamente una decisión del programador.

Debe pensar en el tamaño de los archivos que planea procesar, los requisitos de rendimiento, el estilo del código y los módulos que ya están en el proyecto. Asegúrese de probar en algunos casos de esquina, como archivos enormes, vacíos o inexistentes, y estará listo para usar cualquiera de los ejemplos proporcionados.