Diff Checker & Comparaison de Texte : Guide Complet avec Exemples de Code

Un diff checker est un outil essentiel pour chaque developpeur, redacteur et administrateur systeme. Que vous ayez besoin de comparer deux fichiers, revoir des modifications de code ou trouver les differences entre deux textes, comprendre les algorithmes de diff vous rendra considerablement plus productif. Ce guide complet couvre tout, des algorithmes de text diff aux exemples de code en Git, JavaScript, Python et Bash.

Essayez notre outil gratuit de comparaison de texte en ligne.

Qu'est-ce qu'un Diff Checker ?

Un diff checker (ou outil de comparaison de texte) est un logiciel qui prend deux textes ou fichiers et identifie les differences entre eux. La sortie, appelee "diff" ou "patch", montre quelles lignes ont ete ajoutees, supprimees ou modifiees. Le concept est ne avec la commande diff Unix creee par Douglas McIlroy en 1974.

Un diff checker resout le probleme de repondre a : "Qu'est-ce qui a change entre la version A et la version B ?" L'algorithme de diff doit trouver l'ensemble minimal d'editions (insertions et suppressions) qui transforme le texte A en texte B. Ceci est base sur l'algorithme de la Plus Longue Sous-sequence Commune (LCS).

Les outils de diff en ligne modernes offrent la coloration syntaxique, la detection de differences au niveau des caracteres, les vues cote a cote et en ligne, les options d'ignorer les espaces, et meme des capacites de diff semantique.

Comment fonctionnent les algorithmes de diff

La base de chaque diff checker est l'algorithme de la Plus Longue Sous-sequence Commune (LCS). Il trouve la plus longue sequence d'elements apparaissant dans le meme ordre dans les deux entrees.

L'algorithme LCS classique a une complexite O(n*m). L'algorithme de Myers (1986) trouve le script d'edition le plus court en O(n*d), ou d est le nombre de differences. C'est l'algorithme utilise par Git.

L'algorithme de Myers explore un graphe d'operations d'edition, trouvant le chemin le plus court entre le debut et la fin des deux textes de maniere optimale.

Diff ligne par ligne vs caractere par caractere : La plupart des outils comparent d'abord au niveau des lignes, puis effectuent un diff caractere par caractere dans les lignes modifiees pour une meilleure lisibilite.

Types de sortie Diff

Il existe plusieurs formats standard pour afficher les resultats de diff :

Diff unifie : Le format le plus courant, utilise par git diff. Montre les changements avec les prefixes + et -, avec des marqueurs @@.

Diff cote a cote : Affiche le texte original et modifie dans deux colonnes adjacentes. Tres populaire dans les outils graphiques et les plateformes de revue de code.

Diff en ligne : Montre les versions anciennes et nouvelles entrelacees dans une seule colonne, avec un code couleur (rouge/vert).

Diff contextuel : Un format plus ancien utilisant ! pour marquer les lignes modifiees avec des sections *** et ---.

Diff par mots : Compare des mots individuels plutot que des lignes entieres. Git le supporte avec git diff --word-diff.

Cas d'utilisation courants

La verification de diff et la comparaison de texte sont essentielles dans de nombreux workflows :

Revue de code : Chaque pull request est fondamentalement un diff. Les developpeurs examinent le diff pour comprendre les changements et verifier la qualite du code.

Gestion de versions de documents : Les redacteurs et juristes comparent frequemment deux fichiers pour suivre les modifications entre les revisions.

Modifications de fichiers de configuration : Les administrateurs comparent les fichiers de configuration avant et apres les changements pour verifier que seules les modifications prevues ont ete effectuees.

Comparaison de reponses API : Les developpeurs comparent les reponses JSON ou XML entre les environnements pour identifier les changements inattendus.

Resolution de conflits de fusion : Comprendre le diff est essentiel pour resoudre correctement les conflits Git sans perdre de travail.

Exemples de code Diff

Commandes Git Diff

Git dispose du diff checker integre le plus puissant. Voici les commandes git diff essentielles :

# ===== Basic git diff commands =====

# Compare working directory with staging area (unstaged changes)
git diff

# Compare staging area with last commit (staged changes)
git diff --staged
# or equivalently:
git diff --cached

# Compare working directory with last commit (all changes)
git diff HEAD

# Compare two specific commits
git diff abc1234 def5678

# Compare current branch with another branch
git diff main..feature-branch

# Compare a specific file between commits
git diff HEAD~3 HEAD -- src/app.js

# ===== Advanced git diff options =====

# Word-level diff (great for prose and documentation)
git diff --word-diff
# Output: [-old word-]{+new word+}

# Word diff with color only (no markers)
git diff --word-diff=color

# Show only file names that changed
git diff --name-only HEAD~5

# Show file names with change status (Added/Modified/Deleted)
git diff --name-status main..feature

# Show diff statistics (insertions/deletions per file)
git diff --stat
# Output:
#  src/app.js    | 15 +++++++++------
#  src/utils.js  |  8 +++++---
#  2 files changed, 14 insertions(+), 9 deletions(-)

# One-line summary of changes
git diff --shortstat
# Output: 2 files changed, 14 insertions(+), 9 deletions(-)

# Ignore whitespace changes
git diff -w
# or: git diff --ignore-all-space

# Ignore blank line changes
git diff --ignore-blank-lines

# Show diff with 10 lines of context (default is 3)
git diff -U10

# Generate a patch file
git diff > my-changes.patch

# Apply a patch file
git apply my-changes.patch

# Check if a patch applies cleanly (dry run)
git apply --check my-changes.patch

JavaScript Text Diff (package npm diff)

Le package npm diff est la bibliotheque JavaScript la plus populaire pour calculer les differences de texte :

// npm install diff
const Diff = require('diff');

const oldText = `function greet(name) {
  console.log("Hello, " + name);
  return true;
}`;

const newText = `function greet(name, greeting) {
  console.log(greeting + ", " + name + "!");
  return true;
}`;

// ===== Line-by-line diff =====
const lineDiff = Diff.diffLines(oldText, newText);
lineDiff.forEach(part => {
  const prefix = part.added ? '+' : part.removed ? '-' : ' ';
  const lines = part.value.split('\n').filter(l => l);
  lines.forEach(line => console.log(prefix + ' ' + line));
});
// Output:
// - function greet(name) {
// + function greet(name, greeting) {
// -   console.log("Hello, " + name);
// +   console.log(greeting + ", " + name + "!");
//     return true;
//   }

// ===== Character-level diff =====
const charDiff = Diff.diffChars('hello world', 'hello there');
charDiff.forEach(part => {
  const color = part.added ? '\x1b[32m' : part.removed ? '\x1b[31m' : '';
  process.stdout.write(color + part.value + '\x1b[0m');
});
// Highlights exact character changes

// ===== Word-level diff =====
const wordDiff = Diff.diffWords(
  'The quick brown fox jumps over the lazy dog',
  'The slow brown fox leaps over the tired dog'
);
wordDiff.forEach(part => {
  if (part.added) console.log('[+] ' + part.value);
  else if (part.removed) console.log('[-] ' + part.value);
});

// ===== Generate unified patch =====
const patch = Diff.createPatch(
  'greeting.js',  // filename
  oldText,         // old content
  newText,         // new content
  'original',      // old header
  'modified'       // new header
);
console.log(patch);
// Output: standard unified diff format

// ===== Apply a patch =====
const applied = Diff.applyPatch(oldText, patch);
console.log(applied === newText); // true

// ===== Structured patch for multiple files =====
const structuredPatch = Diff.structuredPatch(
  'old/file.js', 'new/file.js',
  oldText, newText, '', ''
);
console.log(JSON.stringify(structuredPatch.hunks, null, 2));

Python Diff (module difflib)

Python inclut le puissant module difflib dans sa bibliotheque standard pour comparer des sequences :

import difflib

old_text = """function greet(name) {
  console.log("Hello, " + name);
  return true;
}""".splitlines(keepends=True)

new_text = """function greet(name, greeting) {
  console.log(greeting + ", " + name + "!");
  return true;
}""".splitlines(keepends=True)

# ===== Unified diff (most common format) =====
diff = difflib.unified_diff(
    old_text, new_text,
    fromfile='greeting.js.orig',
    tofile='greeting.js',
    lineterm=''
)
print('\n'.join(diff))
# Output:
# --- greeting.js.orig
# +++ greeting.js
# @@ -1,4 +1,4 @@
# -function greet(name) {
# -  console.log("Hello, " + name);
# +function greet(name, greeting) {
# +  console.log(greeting + ", " + name + "!");
#    return true;
#  }

# ===== Context diff (older format) =====
ctx_diff = difflib.context_diff(
    old_text, new_text,
    fromfile='original', tofile='modified'
)
print('\n'.join(ctx_diff))

# ===== HTML visual diff report =====
d = difflib.HtmlDiff()
html = d.make_file(
    old_text, new_text,
    fromdesc='Original',
    todesc='Modified',
    context=True,  # show only changed sections
    numlines=3     # lines of context
)
with open('diff_report.html', 'w') as f:
    f.write(html)

# ===== SequenceMatcher for similarity ratio =====
seq = difflib.SequenceMatcher(None,
    ''.join(old_text), ''.join(new_text))
print(f"Similarity ratio: {seq.ratio():.2%}")
# Output: Similarity ratio: 72.41%

# ===== Get matching blocks =====
for block in seq.get_matching_blocks():
    print(f"  a[{block.a}:{block.a+block.size}] == "
          f"b[{block.b}:{block.b+block.size}] "
          f"(size={block.size})")

# ===== Get opcodes (edit operations) =====
for op, i1, i2, j1, j2 in seq.get_opcodes():
    print(f"  {op:8s} a[{i1}:{i2}] b[{j1}:{j2}]")
# Output:
#   equal    a[0:0] b[0:0]
#   replace  a[0:28] b[0:38]
#   equal    a[28:50] b[38:60]

# ===== Compare two files =====
with open('file1.txt') as f1, open('file2.txt') as f2:
    diff = difflib.unified_diff(
        f1.readlines(), f2.readlines(),
        fromfile='file1.txt', tofile='file2.txt'
    )
    print('\n'.join(diff))

Bash / Linux Diff

Linux et macOS fournissent plusieurs outils en ligne de commande pour la comparaison de texte :

# ===== Basic diff command =====

# Compare two files (default output format)
diff file1.txt file2.txt

# Unified diff format (most readable)
diff -u file1.txt file2.txt
# Output:
# --- file1.txt  2024-01-15 10:30:00
# +++ file2.txt  2024-01-15 11:45:00
# @@ -1,4 +1,4 @@
# -old line 1
# +new line 1
#  unchanged line

# Side-by-side comparison
diff -y file1.txt file2.txt
# or with specific width:
diff -y -W 120 file1.txt file2.txt

# Show only lines that differ (with side-by-side)
diff -y --suppress-common-lines file1.txt file2.txt

# Ignore case differences
diff -i file1.txt file2.txt

# Ignore all whitespace
diff -w file1.txt file2.txt

# Ignore blank lines
diff -B file1.txt file2.txt

# Recursive directory comparison
diff -r dir1/ dir2/

# Brief output (just report if files differ)
diff -q file1.txt file2.txt
# Output: Files file1.txt and file2.txt differ

# ===== Enhanced diff tools =====

# colordiff: colorized diff output
# Install: apt install colordiff / brew install colordiff
colordiff -u file1.txt file2.txt

# vimdiff: side-by-side in Vim editor
vimdiff file1.txt file2.txt

# sdiff: interactive side-by-side merge
sdiff file1.txt file2.txt

# ===== Practical examples =====

# Compare command output
diff <(ls dir1/) <(ls dir2/)

# Compare sorted files
diff <(sort file1.txt) <(sort file2.txt)

# Compare remote file with local file
diff <(curl -s https://example.com/config.yml) local-config.yml

# Generate a patch file
diff -u original.txt modified.txt > changes.patch

# Apply a patch
patch original.txt < changes.patch

# Dry run (check if patch applies cleanly)
patch --dry-run original.txt < changes.patch

# Reverse a patch
patch -R original.txt < changes.patch

# Compare two strings directly
diff <(echo "hello world") <(echo "hello there")

Comment lire la sortie Diff

Comprendre la sortie diff est une competence fondamentale. Voici le format diff unifie :

En-tetes de fichier : Le diff commence par --- a/file.txt (original) et +++ b/file.txt (modifie).

En-tetes de bloc : Les lignes @@ indiquent l'emplacement des changements avec le format @@ -debut,nombre +debut,nombre @@.

Lignes modifiees : Les lignes - (rouge) ont ete supprimees, les lignes + (vert) ont ete ajoutees. Les lignes sans prefixe sont du contexte.

# Example: reading a unified diff

diff --git a/src/config.js b/src/config.js
index 8a3b5c1..f29d4e2 100644
--- a/src/config.js                    ← original file
+++ b/src/config.js                    ← modified file
@@ -12,8 +12,9 @@ const defaults = {      ← hunk header: line 12, 8→9 lines
   timeout: 3000,                       ← context (unchanged)
   retries: 3,                          ← context (unchanged)
-  baseUrl: 'http://localhost:3000',    ← REMOVED (red)
-  debug: false,                        ← REMOVED (red)
+  baseUrl: 'https://api.example.com', ← ADDED (green)
+  debug: true,                         ← ADDED (green)
+  verbose: true,                       ← ADDED (green, new line)
   headers: {                           ← context (unchanged)
     'Content-Type': 'application/json' ← context (unchanged)
   }                                    ← context (unchanged)

Fichiers patch : Un diff peut etre sauvegarde en .patch et applique avec git apply ou patch -p1.

Statistiques : Utilisez git diff --stat pour un resume des changements par fichier.

# git diff --stat output example:
 src/config.js     | 5 +++--
 src/app.js        | 12 ++++++------
 tests/config.test | 28 ++++++++++++++++++++++++++++
 3 files changed, 37 insertions(+), 8 deletions(-)

# The bar shows the ratio of additions (+) to deletions (-)
# Longer bars = more changes in that file

Comparaison des meilleurs outils Diff

Voici les meilleurs outils diff disponibles :

DevToolBox Text Diff (En ligne) : Notre outil gratuit offre une comparaison cote a cote instantanee avec coloration syntaxique et diff au niveau des caracteres.

VS Code Diff integre : VS Code inclut un excellent editeur diff avec vues en ligne et cote a cote.

Beyond Compare : Outil commercial avec fusion trois voies et synchronisation de dossiers.

Meld : Outil libre de diff visuel pour Linux, macOS et Windows.

WinMerge : Outil libre de diff pour Windows avec integration shell.

Commande diff (Unix) : L'outil diff original en ligne de commande, rapide et scriptable.

Questions frequemment posees

Comment comparer deux fichiers texte en ligne ?

Collez le contenu de chaque fichier dans un outil diff en ligne comme notre Text Diff Checker gratuit. L'outil mettra en evidence les lignes ajoutees (vert), supprimees (rouge) et le contexte inchange. La plupart des outils supportent les vues cote a cote et en ligne.

Que signifient + et - dans la sortie diff ?

Dans le format diff unifie, les lignes commencant par + indiquent du contenu ajoute, et les lignes commencant par - indiquent du contenu supprime. Les lignes sans prefixe sont du contexte inchange. Les marqueurs @@ montrent les numeros de ligne.

Comment fonctionne git diff ?

Git diff utilise l'algorithme de Myers pour trouver l'ensemble minimal de changements entre deux versions. Sans arguments, il compare le repertoire de travail avec l'index. git diff --staged compare l'index avec HEAD. La sortie est en format diff unifie.

Maitriser le diff est une competence fondamentale pour les developpeurs et administrateurs. Utilisez notre outil gratuit pour une comparaison instantanee.

Comparez deux textes instantanement avec notre outil Diff Checker gratuit.