Skip to content

Comparer deux textes — Diff

Comparez deux textes instantanément dans votre navigateur. Vue côte à côte, surlignage mot à mot, export en diff unifié, options pour ignorer casse/espaces/lignes vides. 100 % navigateur — aucun upload.

Sans pistage Fonctionne dans le navigateur Gratuit
Toute la comparaison s'exécute localement dans votre navigateur. Votre texte ne quitte jamais cet appareil.
Options à ignorer
Relu pour parité avec la sortie de `diff -u`, correction du LCS intra-ligne et accessibilité (rôles ARIA, annonces de changement pour lecteurs d'écran, gestion RTL/LTR). — Équipe Outils Texte de Go-Tools · 21 mai 2026

Qu'est-ce qu'un diff de texte ?

Le diff de texte est une comparaison structurée de deux documents textuels qui trouve le plus petit ensemble d'insertions et de suppressions transformant l'un en l'autre. La sortie rend le changement visible : vert pour les lignes ajoutées, rouge pour les lignes supprimées, en côte à côte ou en patch unifié (le format `---/+++/@@` utilisé par `git`, GitHub et la commande Unix `patch`).

Sous le capot, tout diff moderne repose sur un algorithme de plus longue sous-séquence commune (LCS). L'article d'Eugene Myers de 1986 en O((N+M)D) est l'implémentation canonique efficace ; la programmation dynamique classique (utilisée ici, avec rognage du préfixe/suffixe commun) est plus simple et fonctionne parfaitement pour les entrées web typiques. Une fois les lignes alignées, les paires suppression + ajout voisines passent par un second LCS au niveau des jetons pour que le rendu ne surligne que les mots ayant réellement changé à l'intérieur d'une ligne — ce que les relecteurs appellent diff intra-ligne ou au mot près.

Pourquoi ne pas simplement comparer les chaînes caractère par caractère ? Parce que les éditions sont rarement à plat : insérer une ligne au milieu d'un fichier de 200 lignes décale toutes les lignes en dessous. Un `===` naïf déclarerait les 199 lignes différentes. LCS dit la vérité : une ligne ajoutée, 199 inchangées.

Cet outil exécute toute la comparaison dans votre navigateur. Aucun upload, aucun fichier temporaire, aucun log. Sûr pour le code propriétaire, les contrats annotés, les logs privés, tout ce que vous seriez mal à l'aise de coller dans un serveur tiers. Besoin de comparer du JSON à la place ? Utilisez le JSON Diff structurel pour que l'ordre des clés et les espaces cessent d'être du bruit. Comparer deux configs en YAML ou CSV ? Convertissez d'abord avec YAML vers JSON ou JSON vers CSV, puis comparez avec le bon outil pour le format.

// Two strings that look 'mostly the same' but a naïve check disagrees
const a = 'hello world';
const b = 'hello, world!';

// Character equality
a === b; // false — but only 3 characters actually changed.

// LCS-style diff (this tool, at line + word granularity)
// → 1 line modified, inline highlight: 'hello[, ]world[!]'
// → unified patch:
//   --- original
//   +++ modified
//   @@ -1 +1 @@
//   -hello world
//   +hello, world!

Fonctionnalités clés

Côte à côte + Unifié

Basculez entre la vue visuelle à deux colonnes (pour la relecture humaine) et le format patch unifié canonique (pour `git apply`, les outils de revue de code, les rapports de bug).

Surlignage au mot près

Quand deux lignes sont appariées comme modifiées, seuls les jetons changés portent un fond coloré. Votre œil trouve l'édition instantanément au lieu de scanner 80 caractères.

Ignorer casse / espaces / lignes vides

Quatre bascules indépendantes : casse, tous les espaces, espaces finaux uniquement, lignes vides. Reproduit `git diff -i -w -b` en deux clics.

Export en diff unifié

Copiez un patch `---/+++/@@` propre avec trois lignes de contexte. Se colle directement dans un commentaire de PR, un rapport de bug ou `patch -p1`.

100 % navigateur

Les entrées ne quittent jamais votre appareil. Aucun upload, aucune analytique sur le texte. Fonctionne hors ligne une fois la page chargée. Sûr pour le code propriétaire et la prose confidentielle.

Unicode + RTL

Découpe les jetons sur les frontières de mot Unicode. Arabe, hébreu, CJK se comparent proprement ; les variantes de fin de ligne (CRLF, LF, CR) sont toutes normalisées.

Exemples

Revue de code — un renommage de variable

function getUser(id) {
  const u = db.users.find(x => x.id === id);
  return u;
}
function getUser(userId) {
  const u = db.users.find(x => x.id === userId);
  return u;
}

La vue côte à côte met en évidence chaque ligne contenant le renommage, tandis que le diff au mot près estompe les jetons inchangés pour que le relecteur voie exactement quel identifiant a changé.

Modification de contrat — une clause ajoutée

1. The service is provided as-is.
2. Either party may terminate with 30 days notice.
3. Disputes are resolved in California courts.
1. The service is provided as-is.
2. Either party may terminate with 30 days notice.
2a. Termination notice must be in writing.
3. Disputes are resolved in California courts.

Une seule clause insérée (ligne 2a) est la seule différence. Les lignes de contexte autour restent propres — pratique pour relire un contrat ou un document de politique en mode « track changes ».

Analyse de logs — temps de requête modifié

GET /api/users 200 14ms
POST /api/orders 201 88ms
GET /api/orders/42 200 21ms
GET /api/users 200 14ms
POST /api/orders 201 4200ms
GET /api/orders/42 500 21ms

Deux lignes changent. Le surlignage inline montre la dérive de latence 88ms → 4200ms et le code de statut 200 → 500. Une chronologie d'incident toute trouvée.

Espaces en fin de ligne — option « Ignorer les espaces finaux »

  margin: 0;  
  padding: 0;
  border: none;
  margin: 0;
  padding: 0;
  border: none;

Sans l'option, la ligne 1 signale une différence (espaces finaux). Activez « Ignorer les espaces / tabulations finaux » et le diff tombe à zéro — la même astuce que `git diff -b`.

Comment utiliser

  1. 1

    Collez les deux versions

    Texte original à gauche, texte modifié à droite. Le diff en direct s'affiche pendant que vous tapez ; les entrées volumineuses (>200 Ko combinées) basculent sur un bouton Diff manuel.

  2. 2

    Activez les options à ignorer dont vous avez besoin

    Ignorer la casse, ignorer tous les espaces, ignorer les espaces finaux ou ignorer les lignes vides — chaque option est indépendante et persistante entre les visites.

  3. 3

    Lisez le diff ou récupérez le patch

    Côte à côte pour la relecture humaine, Unifié pour le format patch `---/+++/@@`. « Copier le diff unifié » envoie un patch propre dans votre presse-papier pour une revue de code ou un `patch -p1`.

Pièges courants du diff

Tout le fichier « changé » après une copie Windows ↔ Unix

Si vous collez depuis Notepad sous Windows dans un original édité sous Unix, chaque ligne montrera des différences \r. Activez « Ignorer les espaces / tabulations finaux » pour faire taire les caractères CR.

✗ Incorrect
Diff: 200 modifications (all because of trailing \r)
✓ Correct
Ignore trailing spaces / tabs → 2 real changes

Diff d'indentation qui hurle

Reformater tabulations ↔ espaces explose les diffs ligne par ligne. « Ignorer tous les espaces » ramène le diff aux vrais changements sémantiques.

✗ Incorrect
Diff: 87 modifications (all are indent changes)
✓ Correct
Ignore all whitespace → 4 actual changes

Paragraphes identiques signalés à cause d'une ligne vide

Ajouter ou retirer une seule ligne vide dans de la prose peut désaligner toute une région. « Ignorer les lignes vides » règle ça sans toucher au contenu.

✗ Incorrect
Diff: paragraph 2 'completely changed' (one blank line moved)
✓ Correct
Ignore blank lines → no changes in paragraph 2

Le diff dit « identique » mais les fichiers diffèrent

Presque toujours une option « Ignorer » de casse ou d'espace laissée activée d'une session précédente. Ouvrez le panneau « Options à ignorer » — toutes les bascules y sont visibles. Désactivez-les toutes pour une comparaison byte-strict.

✗ Incorrect
0 differences shown, but `cmp` says the files differ
✓ Correct
Disable all Ignore options → real diff appears

Du JSON collé qui semble « tout changé »

Le diff de texte traite l'ordre des clés comme significatif ; pas JSON. Pour des payloads JSON, utilisez l'outil dédié JSON Diff — il ignore l'ordre des clés et respecte la stricteté des types.

✗ Incorrect
Text diff on JSON: 100% of lines changed (just a key reorder)
✓ Correct
<a href="/fr/tools/json-diff">JSON Diff</a>: 0 differences

Avertissement de diff tronqué ignoré

Au-delà de 5 000 lignes par côté, l'entrée est tronquée. Si l'avertissement s'affiche, passez en ligne de commande `diff -u file1 file2` ou `git diff --no-index` — les deux streament et gèrent des gigaoctets.

✗ Incorrect
Pasted a 20,000-line log — only first 5,000 lines diffed
✓ Correct
`diff -u a.log b.log` in terminal handles full file

Cas d'usage courants

Extrait de revue de code
Déposez deux versions d'une fonction dans les panneaux pour repérer d'un coup d'œil un renommage, une branche supprimée ou une nouvelle clause de garde. Le surlignage au mot près est plus rapide que de scanner le diff GitHub pour un changement d'une ligne.
Annotation de contrat / politique
Collez le contrat d'hier face à la révision d'aujourd'hui. Les clauses insérées ressortent ; les paragraphes inchangés se replient en gris. Exportez le patch unifié pour la trace de revue juridique.
Investigation de chronologie de logs
Comparez la tranche de logs pré-incident d'un SRE à la tranche pendant l'incident. Latence, code de statut et dérive de fréquence ressortent immédiatement sans `awk`.
Révision de prose / brouillon
Collez un brouillon et la version de votre éditeur. Le diff au mot près montre exactement quelles phrases ont été réécrites — précieux pour accepter ou rejeter les changements un par un.
Revue de traduction
Comparez une ancienne traduction à une re-traduction pour vérifier que la nouvelle copie préserve sens, structure et placeholders. Activez « Ignorer les espaces finaux » pour faire taire le bruit que les traducteurs introduisent souvent.
Audit de fichier .env / config
Comparez deux fichiers `.env`, `docker-compose.yaml` ou rc shell. Avec « Ignorer les lignes vides » activé, le diff se concentre sur les différences fonctionnelles plutôt que sur le bruit de formatage.

Détails techniques

LCS avec rognage préfixe/suffixe
Les lignes communes en début et fin sont retirées avant d'exécuter le LCS par programmation dynamique. Un diff « deux configs de 2 000 lignes avec une seule ligne changée » se réduit à une table DP de 1×1 et s'affiche en moins d'une milliseconde.
Diff intra-ligne au niveau des jetons
Les hunks voisins suppression + ajout sont appariés et tokenisés via des runs Unicode mot/non-mot/espace. Une seconde passe LCS produit les segments verts/rouges qui rendent les lignes modifiées lisibles.
Diff unifié = compatible git/patch
La sortie suit le format `---/+++/@@ -L,C +L,C @@` défini pour GNU patch et utilisé par Git, GitHub et tous les outils de revue de code. Appliquez avec `pbpaste | patch -p0`.
Plafond d'entrée à 5 000 lignes par côté
Au-delà du plafond, le diff tronque et avertit. Pour des entrées de plusieurs Mo, utilisez `diff -u` en ligne de commande ou `git diff --no-index` — ils streament et gèrent des gigaoctets.

Bonnes pratiques

Choisissez les options à ignorer avant de lire
Le bruit lié aux espaces finaux, CRLF et casse noie le signal. Activez les bonnes options en premier ; le diff devient beaucoup plus lisible et vous arrêtez de vous entraîner à survoler les « faux » changements.
Unifié pour partager, Côte à côte pour relire
Les colonnes visuelles sont pour vos yeux. Les patchs unifiés sont pour les terminaux des autres. Un diff unifié copié s'insère dans un message Slack, un commentaire Jira ou `patch -p1` sans traduction.
Vérifiez avec le % de similarité
Si deux fichiers sont « presque identiques » mais que le score de similarité est de 30 %, vous avez un problème de fins de ligne ou d'espaces. Activez « Ignorer tous les espaces » et revérifiez avant de lire le diff.

Questions fréquentes

Le texte que je colle est-il envoyé à votre serveur ?
Non. Chaque comparaison s'exécute en JavaScript dans votre navigateur. Votre texte n'est ni uploadé, ni journalisé, ni stocké sur disque, ni envoyé à un tiers. Seules vos préférences d'interface (mode d'affichage et options « Ignorer ») sont enregistrées dans localStorage pour que la page s'en souvienne lors de votre prochaine visite — jamais le texte. Vous pouvez le vérifier en ouvrant DevTools → Réseau : aucune requête ne part quand vous cliquez sur Diff.
Quelle différence entre diff de texte et diff JSON ?
Le diff de texte compare ligne par ligne — parfait pour la prose, le code, les logs, les contrats, les fichiers de configuration. JSON Diff comprend le modèle de données JSON : l'ordre des clés est indifférent, les types sont stricts, les tableaux peuvent être appariés par clé. Si vous collez du JSON dans un diff de texte, les réorganisations de clés et les différences d'espaces seront signalées comme des changements ; JSON Diff les ignore. Utilisez le diff de texte pour le contenu non structuré, JSON Diff pour les réponses d'API et les configurations.
Comment ignorer les espaces, la casse ou les lignes vides ?
Cliquez sur le panneau « Options à ignorer » au-dessus du diff. « Ignorer la casse » rend A et a équivalents. « Ignorer tous les espaces » écrase chaque espace, tabulation et saut de ligne avant comparaison. « Ignorer les espaces / tabulations finaux » ne supprime que les espaces en fin de ligne — comportement standard de `git diff -b`. « Ignorer les lignes vides » supprime les lignes vides ou ne contenant que des espaces avant le diff. Chaque option est indépendante et est conservée entre les visites.
Qu'est-ce qu'un diff unifié (et quand le copier) ?
Un diff unifié est le format texte `---/+++/@@` utilisé par `patch`, `git apply`, les PR GitHub et la plupart des outils de revue de code. Cliquez sur « Copier le diff unifié » pour obtenir un patch avec trois lignes de contexte autour de chaque changement — collez-le dans un rapport de bug, un commentaire de revue de code ou une commande `patch -p1`, et il s'applique proprement. La vue côte à côte est pour les humains, le diff unifié est pour les machines (et les relecteurs qui pensent comme des machines).
Pourquoi le diff montre-t-il des lignes entières modifiées alors que je n'ai changé qu'un mot ?
Ce n'est pas le cas — regardez de plus près. La ligne complète est surlignée parce que quelque chose y a changé, mais à l'intérieur du surlignage seuls les jetons modifiés portent le fond vif (vert pour les ajouts, rouge barré pour les suppressions). C'est le diff au mot près intra-ligne : le contexte reste lisible, votre œil se pose sur l'édition exacte. Si deux lignes consécutives ont été modifiées, les deux affichent le surlignage inline.
Comment sont gérées les fins de ligne CRLF vs LF ?
Les deux sont reconnues. Le diff découpe sur \r\n, \n et le \r seul, donc Windows CRLF, Unix LF et l'ancien Mac CR s'alignent correctement. Si vous voulez signaler spécifiquement les changements de fin de ligne, laissez « Ignorer les espaces / tabulations finaux » désactivée — le \r apparaîtra comme un caractère final. Pour éliminer complètement le bruit lié aux fins de ligne, activez « Ignorer tous les espaces ».
Quelle taille les deux entrées peuvent-elles atteindre ?
Le diff tourne sur le thread principal, donc la limite pratique est d'environ 5 000 lignes ou 1 Mo par côté ; au-delà nous tronquons et affichons un avertissement. Le diff en direct se désactive au-delà de 200 Ko combinés et bascule sur un bouton Diff manuel. Pour des fichiers de plusieurs Mo, utilisez `diff -u` en ligne de commande ou `git diff --no-index` — ils streament et gèrent des gigaoctets.
Et pour comparer du code ? L'outil connaît-il mon langage ?
Le diff est agnostique du langage : il voit des lignes et des jetons, pas de la syntaxe. C'est un atout pour les extraits de revue, les modifications de configuration et les patchs collés. Si vous voulez un diff sémantique (fonction renommée à travers les fichiers, niveau AST), utilisez git, la vue PR de GitHub ou un outil de diff structurel dédié. Pour 90 % des situations de revue de code — examiner une fonction, comparer deux extraits — un diff ligne + mot est exactement ce qu'il vous faut.
Pourquoi une seule modification apparaît parfois comme une ligne supprimée plus une ligne ajoutée ?
Quand une trop grande partie d'une ligne a changé pour que le surlignage au mot près soit utile, le diff la signale en lignes séparées suppression + ajout pour garder la structure claire. La même heuristique donne une sortie lisible pour les réécritures de prose et les blocs de code réécrits plutôt qu'édités. Passez en vue Unifiée pour voir la classique paire `-`/`+` utilisée dans les patchs.
Comment le pourcentage de similarité est-il calculé ?
C'est le nombre de lignes inchangées (après application des options « Ignorer ») divisé par le plus grand des deux nombres de lignes, plafonné à 100 %. Deux entrées identiques font 100 %. Ajouter une nouvelle ligne à un fichier de 100 lignes donne 99 %. Remplacer toutes les lignes donne 0 %. Utile pour juger rapidement « est-ce une petite modification ou une réécriture complète » avant même de lire le diff.
Puis-je partager un diff avec un collègue ?
Oui, de deux manières. (1) Cliquez sur « Copier le diff unifié » et collez le patch dans un chat, Slack ou un commentaire de PR — n'importe qui avec un terminal peut faire `patch < clip`. (2) Faites une capture d'écran du panneau côte à côte pour une revue visuelle. Nous ne fournissons délibérément pas de bouton « partager par URL » : cela nécessiterait d'uploader votre texte, ce que nous ne faisons pas.
Le diff gère-t-il les langues de droite à gauche comme l'arabe ou l'hébreu ?
Oui pour le contenu textuel — les lignes et les jetons sont Unicode-aware. L'interface utilise des directions CSS logiques, donc en locale RTL la gouttière et les colonnes de lignes basculent naturellement. À l'intérieur d'une cellule de diff la direction du texte suit le contenu, donc les chaînes arabes et hébraïques s'affichent correctement tandis que les marqueurs +/- restent alignés sur la gouttière.