Parsing de TXT : lecture ligne par ligne, expressions régulières et exemples multi-langages

Le fichier texte (.txt) est le format le plus « libre » qui soit : il n'a ni schéma, ni grammaire, ni standard. Ce qu'il contient dépend entièrement de celui qui l'a créé. Ce peut être une simple liste, un export de données à colonnes de largeur fixe, une extraction avec un séparateur non standard ou du texte brut. Le parsing de TXT n'est donc pas une affaire de bibliothèque dédiée à un format, mais la capacité à décortiquer une structure arbitraire à la main. Cet article fait partie de notre panorama du parsing de documents.

Commencez par déterminer ce qu'il y a dedans

Avant d'écrire du code, il faut comprendre la nature du fichier. S'il s'agit de lignes d'un même type (un enregistrement par ligne), une lecture ligne par ligne avec analyse de chaque ligne suffit. Si les valeurs sont séparées par un caractère constant — tabulation, point-virgule, barre verticale — vous avez en réalité affaire à un CSV avec un séparateur non standard, et mieux vaut utiliser un lecteur CSV qui gérera correctement les guillemets. Si en revanche c'est du texte brut sans structure apparente, on passe aux expressions régulières pour extraire les fragments voulus par motif.

Vérifiez aussi l'encodage (les textes français hérités sont souvent en windows-1252 ou latin-1) et le caractère de fin de ligne : dans les fichiers issus de Windows c'est \r\n, sous Unix \n. La plupart des langages lisent correctement les deux, mais le \r résiduel doit parfois être retiré à la main.

Lecture ligne par ligne

Python

Un fichier est un itérateur de lignes : la lecture ligne par ligne est naturelle et économe en mémoire, même pour des fichiers de plusieurs gigaoctets.

with open("data.txt", encoding="utf-8") as f:
    for line in f:
        line = line.strip()          # on retire espaces et fin de ligne
        if not line:                 # on saute les lignes vides
            continue
        print(line)

JavaScript / Node.js

Pour ne pas charger un gros fichier en entier, on le lit en flux ligne par ligne avec le module 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)
        }
    }
}

Extraction de données par expressions régulières

Quand les valeurs utiles sont « noyées » dans le texte, on les extrait par motif. Supposons que le fichier contienne des lignes du type [2026-06-01] Commande #1042 : 3490 EUR et qu'il faille récupérer la date, le numéro de commande et le montant.

import re

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

La même approche en JavaScript :

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

Les expressions régulières sont l'outil principal pour analyser du texte non structuré, et il vaut mieux garder sous la main un testeur interactif (par exemple regex101) pour mettre au point le motif sur des lignes réelles. Gardez leurs limites en tête : on ne parse pas avec des regex des formats imbriqués comme XML ou HTML — il faut là de vrais parseurs. Mais pour du texte plat traité ligne à ligne, c'est le choix idéal.

Données à colonnes de largeur fixe

Les systèmes anciens et les exports de mainframes produisent souvent du texte où les colonnes sont définies non par un séparateur mais par la position des caractères : les 10 premiers caractères pour la référence, les 30 suivants pour le nom, et ainsi de suite. Ce format s'analyse par découpage de la chaîne à indices fixes.

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 cas particulier mais essentiel : les logs

Le type de fichier TXT le plus courant à analyser en pratique, ce sont les journaux de serveurs et d'applications. Les logs n'ont pas de standard commun, mais au sein d'une même source le format de ligne est stable, ce qui permet d'appliquer les mêmes techniques — lecture ligne par ligne plus expressions régulières — avec leurs subtilités propres : enregistrements multilignes, rotation, volumes en gigaoctets. Un article dédié traite du parsing de logs.

Si vous recevez régulièrement des exports texte à la structure non standard ou « flottante » et qu'il faut les transformer en tableaux propres, nous mettons en place un parsing adapté à votre format avec livraison du résultat en CSV, Excel ou directement en base.