Parsing de TXT: leitura linha a linha, expressões regulares e exemplos em várias linguagens

O arquivo de texto (.txt) é o formato mais «livre» que existe: não tem esquema, nem gramática, nem padrão. O que há dentro é decidido inteiramente por quem criou o arquivo. Pode ser uma lista simples, uma exportação de dados com colunas de largura fixa, um despejo com um separador fora do padrão ou, simplesmente, texto corrido. Por isso o parsing de TXT não consiste em encontrar uma biblioteca para o formato, e sim em saber desmontar à mão uma estrutura arbitrária. O artigo faz parte do nosso panorama do parsing de documentos.

Primeiro determine o que há dentro

Antes de escrever código, é preciso entender o caráter do arquivo. Se são linhas de um mesmo tipo (um registro por linha), basta a leitura linha a linha e a análise de cada uma. Se os valores são separados por um caractere constante — tabulação, ponto e vírgula, barra vertical —, o que você tem diante de si é, na essência, um CSV com separador fora do padrão, e o correto é usar um leitor de CSV, que tratará bem as aspas. E se é texto corrido sem estrutura evidente, entram em cena as expressões regulares, com as quais se extraem os trechos necessários conforme um padrão.

Convém verificar à parte a codificação (o texto em português chega muitas vezes em windows-1252, e não em UTF-8) e o caractere de quebra de linha: nos arquivos vindos do Windows é \r\n, no Unix, \n. A maioria das linguagens lê as linhas corretamente nos dois casos, mas o \r «pendurado» no fim às vezes precisa ser removido à mão.

Leitura linha a linha

Python

Um arquivo é um iterador de linhas, então lê-lo linha a linha é natural e econômico em memória, mesmo com arquivos de gigabytes.

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        line = line.strip()          # removemos espaços e a quebra de linha
        if not line:                 # pulamos as linhas vazias
            continue
        print(line)

JavaScript / Node.js

Para não carregar inteiro um arquivo grande, no Node a leitura é feita em fluxo, linha a linha, com o 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)
        }
    }
}

Extração de dados com expressões regulares

Quando os valores estão «incrustados» no texto, eles são retirados com um padrão. Suponhamos que o arquivo contenha linhas do tipo [2026-06-01] Pedido #1042: 3490 EUR e seja preciso extrair a data, o número do pedido e o valor.

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)

A mesma abordagem em 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);
}

As expressões regulares são a ferramenta principal para desmontar texto sem estrutura, e vale a pena ter à mão algum testador interativo (por exemplo, o regex101) para depurar o padrão sobre linhas reais. Isso sim, é preciso lembrar seus limites: com regex não se analisam formatos aninhados como XML ou HTML — ali são necessários parsers completos. Para o texto plano organizado por linhas, em contrapartida, elas são a escolha ideal.

Dados com colunas de largura fixa

Os sistemas antigos e os despejos de mainframes entregam com frequência texto em que as colunas não são definidas por um separador, mas pela posição dos caracteres: os 10 primeiros caracteres são o código, os 30 seguintes o nome, e assim por diante. Esse formato se desmonta com cortes da linha por índices fixos.

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)

Um caso particular, mas importantíssimo: os logs

O tipo de arquivo TXT que mais se desmonta na prática são os registros de servidores e aplicações. Embora os logs não tenham um padrão comum, dentro de uma mesma fonte o formato da linha é estável, o que permite aplicar a eles as mesmas técnicas — leitura linha a linha mais expressões regulares —, ainda que com nuances próprias: entradas multilinha, rotação, volumes de gigabytes. A isso é dedicado o artigo à parte sobre o parsing de logs.

Se você recebe com regularidade despejos de texto com uma estrutura fora do padrão ou «flutuante» e é preciso convertê-los em tabelas limpas, configuramos o parsing para o seu formato e entregamos o resultado em CSV, Excel ou diretamente no seu banco de dados.