Parsing di TXT: lettura riga per riga, espressioni regolari ed esempi in vari linguaggi

Il file di testo (.txt) è il formato più «libero» che esista: non ha schema, né grammatica, né standard. Che cosa ci sia dentro lo decide interamente chi ha creato il file. Può essere una lista semplice, un’esportazione di dati con colonne a larghezza fissa, un’estrazione con un separatore non standard o, direttamente, testo continuo. Per questo il parsing di TXT non consiste nel trovare una libreria per il formato, ma nel saper smontare a mano una struttura arbitraria. L’articolo fa parte della nostra panoramica sul parsing di documenti.

Prima determina che cosa c’è dentro

Prima di scrivere codice bisogna capire la natura del file. Se sono righe dello stesso tipo (un record per riga), bastano la lettura riga per riga e l’analisi di ciascuna. Se i valori sono separati da un carattere costante — tabulazione, punto e virgola, barra verticale — quello che hai davanti è, in sostanza, un CSV con separatore non standard, e la cosa giusta è usare un lettore CSV, che gestirà correttamente le virgolette. Se invece è testo continuo senza struttura evidente, entrano in gioco le espressioni regolari, con cui estrai i frammenti che ti servono in base a un pattern.

Vale la pena controllare a parte la codifica (il testo in italiano arriva spesso in windows-1252 e non in UTF-8) e il carattere di fine riga: nei file provenienti da Windows è \r\n, in Unix \n. La maggior parte dei linguaggi legge le righe correttamente in entrambi i casi, ma il \r «in coda» a volte va tolto a mano.

Lettura riga per riga

Python

Un file è un iteratore di righe, quindi leggerlo riga per riga è naturale ed economico in memoria anche con file da gigabyte.

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        line = line.strip()          # togliamo spazi e salto di riga
        if not line:                 # saltiamo le righe vuote
            continue
        print(line)

JavaScript / Node.js

Per non caricare per intero un file grande, in Node lo si legge in streaming, riga per riga, con il modulo 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)
        }
    }
}

Estrazione dei dati con le espressioni regolari

Quando i valori sono «incastonati» nel testo, si estraggono con un pattern. Supponiamo che il file contenga righe del tipo [2026-06-01] Ordine #1042: 3490 EUR e che servano la data, il numero d’ordine e l’importo.

import re

pattern = re.compile(r"\[(\d{4}-\d{2}-\d{2})\] Ordine #(\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)

Lo stesso approccio in JavaScript:

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

Le espressioni regolari sono lo strumento principale per smontare testo non strutturato, e conviene tenere a portata di mano un tester interattivo (per esempio regex101) per mettere a punto il pattern su righe reali. L’importante è ricordarne i limiti: con le regex non si analizzano formati annidati come XML o HTML — lì servono parser completi. Per il testo piatto organizzato per righe, invece, sono la scelta ideale.

Dati con colonne a larghezza fissa

I sistemi datati e le esportazioni dai mainframe restituiscono spesso testo in cui le colonne non sono definite da un separatore ma dalla posizione dei caratteri: i primi 10 caratteri sono il codice articolo, i 30 successivi il nome, e così via. Questo formato si smonta con slice della riga su indici fissi.

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 particolare ma importantissimo: i log

Il tipo di file TXT che più spesso capita di analizzare nella pratica sono i registri di server e applicazioni. Anche se i log non hanno uno standard comune, all’interno di una stessa fonte il formato della riga è stabile, il che permette di applicare le stesse tecniche — lettura riga per riga più espressioni regolari — ma con alcune particolarità: voci multilinea, rotazione, volumi da gigabyte. A questo è dedicato l’articolo a parte sul parsing di log.

Se ricevi regolarmente esportazioni di testo con una struttura non standard o «ballerina» e vanno trasformate in tabelle pulite, configureremo il parsing per il tuo formato e consegneremo il risultato in CSV, Excel o direttamente nel tuo database.