Parseo de TXT: lectura línea a línea, expresiones regulares y ejemplos en varios lenguajes

El archivo de texto (.txt) es el formato más «libre» que existe: no tiene esquema, ni gramática, ni estándar. Lo que hay dentro lo decide por completo quien creó el archivo. Puede ser una lista simple, una exportación de datos con columnas de ancho fijo, una descarga con un separador no estándar o, directamente, texto corrido. Por eso el parseo de TXT no consiste en encontrar una biblioteca para el formato, sino en saber desmontar a mano una estructura arbitraria. El artículo forma parte de nuestro panorama del parseo de documentos.

Primero determine qué hay dentro

Antes de escribir código hay que entender el carácter del archivo. Si son líneas de un mismo tipo (un registro por línea), basta con la lectura línea a línea y el análisis de cada una. Si los valores van separados por un carácter constante — tabulación, punto y coma, barra vertical —, lo que tiene delante es, en esencia, un CSV con separador no estándar, y lo correcto es usar un lector de CSV, que tratará bien las comillas. Y si es texto corrido sin estructura evidente, entran en juego las expresiones regulares, con las que se extraen los fragmentos necesarios según un patrón.

Conviene comprobar aparte la codificación (el texto en español llega a menudo en windows-1252 y no en UTF-8) y el carácter de salto de línea: en los archivos procedentes de Windows es \r\n, en Unix \n. La mayoría de los lenguajes leen las líneas correctamente en ambos casos, pero el \r «de cola» a veces hay que quitarlo a mano.

Lectura línea a línea

Python

Un archivo es un iterador de líneas, así que leerlo línea a línea resulta natural y económico en memoria incluso con archivos de gigabytes.

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        line = line.strip()          # quitamos espacios y el salto de línea
        if not line:                 # omitimos las líneas vacías
            continue
        print(line)

JavaScript / Node.js

Para no cargar entero un archivo grande, en Node se lee en flujo, línea a línea, con el módulo readline.

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

const rl = readline.createInterface({
  input: fs.createReadStream("data.txt", "utf-8"),
});

rl.on("line", (line) => {
  const clean = line.trim();
  if (clean) console.log(clean);
});

Go

package main

import (
    "bufio"
    "fmt"
    "os"
    "strings"
)

func main() {
    f, _ := os.Open("data.txt")
    defer f.Close()

    sc := bufio.NewScanner(f)
    for sc.Scan() {
        line := strings.TrimSpace(sc.Text())
        if line != "" {
            fmt.Println(line)
        }
    }
}

Extracción de datos con expresiones regulares

Cuando los valores están «incrustados» en el texto, se sacan con un patrón. Supongamos que el archivo contiene líneas del tipo [2026-06-01] Pedido #1042: 3490 EUR y hay que extraer la fecha, el número de pedido y el importe.

import re

pattern = re.compile(r"\[(\d{4}-\d{2}-\d{2})\] Pedido #(\d+): (\d+) EUR")

with open("orders.txt", encoding="utf-8") as f:
    for line in f:
        m = pattern.search(line)
        if m:
            date, order_id, amount = m.groups()
            print(date, order_id, amount)

El mismo enfoque en JavaScript:

const re = /\[(\d{4}-\d{2}-\d{2})\] Pedido #(\d+): (\d+) EUR/;
const m = line.match(re);
if (m) {
  const [, date, orderId, amount] = m;
  console.log(date, orderId, amount);
}

Las expresiones regulares son la herramienta principal para desmontar texto sin estructura, y conviene tener a mano algún probador interactivo (por ejemplo, regex101) para depurar el patrón sobre líneas reales. Eso sí, hay que recordar sus límites: con regex no se analizan formatos anidados como XML o HTML — ahí hacen falta parsers completos. Para el texto plano organizado por líneas, en cambio, son la elección ideal.

Datos con columnas de ancho fijo

Los sistemas antiguos y las descargas de mainframes entregan a menudo texto en el que las columnas no las define un separador, sino la posición de los caracteres: los 10 primeros caracteres son la referencia, los 30 siguientes el nombre, y así sucesivamente. Ese formato se desmonta con cortes de la línea por índices fijos.

with open("fixed.txt", encoding="utf-8") as f:
    for line in f:
        sku   = line[0:10].strip()
        name  = line[10:40].strip()
        price = line[40:50].strip()
        print(sku, name, price)

Un caso particular pero importantísimo: los logs

El tipo de archivo TXT que más toca desmontar en la práctica son los registros de servidores y aplicaciones. Aunque los logs no tienen un estándar común, dentro de una misma fuente el formato de la línea es estable, lo que permite aplicarles las mismas técnicas — lectura línea a línea más expresiones regulares —, aunque con matices propios: entradas multilínea, rotación, volúmenes de gigabytes. A ello está dedicado el artículo aparte sobre el parseo de logs.

Si recibe con regularidad descargas de texto con una estructura no estándar o «flotante» y hay que convertirlas en tablas limpias, configuraremos el parseo para su formato y entregaremos el resultado en CSV, Excel o directamente en su base de datos.