Comparez deux codes : lignes ajoutées et supprimées
Voyez précisément ce qui a changé entre deux versions d’un fichier : réécrire return a + b en deux nouvelles lignes donne 2 ajoutées, 1 supprimée et 3 inchangées, avec les anciens et nouveaux numéros de ligne et la vue diff classique. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Comparez deux versions d’un fichier source et obtenez un relevé déterministe, ligne par ligne, de chaque changement. Le résultat identifie toutes les lignes ajoutées, supprimées et inchangées, fournit les anciens et nouveaux numéros de ligne lorsqu’ils s’appliquent et produit une vue unifiée familière pour les journaux ou les écrans de révision. Le traitement convient à tout langage de programmation textuel et n’interprète pas la syntaxe, n’exécute pas le code, ne consulte aucun dépôt et ne modifie aucune version. Il constitue ainsi un composant compact et prévisible pour les outils de développement, les plateformes pédagogiques, les contrôles de migration et les processus automatisés de révision.
Fournissez les deux versions du code
L’une des versions peut être vide, ce qui représente naturellement un fichier nouvellement créé ou entièrement supprimé, mais les deux ne peuvent pas l’être simultanément puisqu’il n’y aurait alors rien de pertinent à comparer. Les fins de ligne sont normalisées avant la comparaison : un texte Windows en CRLF et un texte Unix en LF peuvent donc être rapprochés sans que chaque ligne soit signalée comme modifiée. La comparaison est volontairement indépendante du langage.
JavaScript, Python, Go, Rust, fichiers de configuration, modèles, SQL et autres textes organisés par lignes obéissent aux mêmes règles. Après normalisation des sauts, les lignes sont comparées exactement. Espaces, tabulations, casse, ponctuation et commentaires restent significatifs, car ces détails peuvent modifier le comportement d’un programme.
Fournissez le texte complet plutôt qu’un correctif. Le résultat n’évalue jamais le code et ne résout aucune importation : vous pouvez donc comparer des extraits non fiables comme du simple texte. Pour préserver une consommation prévisible des ressources, chaque version est limitée à 2,000 lignes ; découpez les fichiers générés exceptionnellement volumineux avant l’envoi.
Lisez les changements structurés et la vue unifiée
La réponse comprend un indicateur identical, un résumé, un tableau structuré de lignes et un texte de style unifié. Le résumé dénombre les lignes ajoutées, supprimées et inchangées. Chaque enregistrement structuré comporte un type et son texte exact.
Les champs sans objet sont omis, ce qui simplifie les traitements ultérieurs par rapport à des valeurs null. Une ligne modifiée est représentée par une suppression et un ajout, conformément à la sémantique fondamentale des outils traditionnels de comparaison par ligne. La sortie couvre tout le fichier fourni au lieu de répartir les zones éloignées dans plusieurs blocs de contexte.
Ce choix facilite l’analyse et garantit que la liste structurée et la vue textuelle décrivent exactement la même séquence.
Exploitez une sortie déterministe dans vos processus
L’algorithme recherche une sous-séquence commune ordonnée, ce qui permet de reconnaître insertions et suppressions même lorsque les numéros de ligne se décalent. Les lignes dupliquées sont traitées selon leur position et leur ordre, et non comme si le fichier était un ensemble. Lorsque plusieurs alignements sont valides, l’implémentation applique une règle de départage stable : les mêmes entrées produisent donc toujours la même sortie.
Utilisez le tableau structuré pour construire une vue côte à côte, compter les types de changement, annoter les numéros de ligne ou appliquer une règle. Cette capacité ne propose ni rapprochement syntaxique, ni détection des renommages, ni surlignage par jeton, ni résolution de conflit de fusion, ni accès au dépôt. Ces fonctions exigent des analyseurs de langage ou le contexte d’un gestionnaire de versions.
Ici, le modèle limité aux lignes assure un comportement transparent, sans réseau, et un résultat reproductible localement à partir des deux mêmes chaînes.
Cas d’usage
Créez une vue de révision du code
Affichez les lignes ajoutées, supprimées et inchangées sous forme structurée, avec les bons numéros anciens et nouveaux.
Contrôlez les changements du code généré
Comparez la sortie de deux exécutions et conservez un relevé déterministe de style unifié dans les journaux de build.
Expliquez la révision d’un exercice
Montrez précisément aux élèves quelles lignes source ont été insérées ou supprimées, sans exécuter leur code.
Questions fréquentes
Quel est le prix d’une comparaison ?
L’expérience dans le navigateur peut exécuter localement la même logique déterministe.
Quels langages de programmation sont acceptés ?
Tout langage textuel est accepté, car la comparaison porte sur les lignes et ne dépend pas de la syntaxe.
Les changements limités aux espaces sont-ils signalés ?
Oui. Les espaces et tabulations sont significatifs ; une ligne dont l’espacement change apparaît donc comme supprimée et ajoutée.
Une version peut-elle être vide ?
Oui. Une version vide représente un fichier nouveau ou supprimé. Une erreur survient uniquement lorsque les deux versions sont vides.
Le résultat suit-il le format diff unifié ?
Il fournit des marqueurs de fichier, un en-tête de plage et les préfixes habituels, ainsi que des enregistrements structurés. Il s’agit d’une vue unifiée du fichier entier, et non de plusieurs blocs de contexte condensés.
Outils associés
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/dev2/diff-two-code-files \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"original_code":"function greet(name) {\n return `Hello, ${name}`;\n}\n","revised_code":"function greet(name = \"world\") {\n return `Hello, ${name}!`;\n}\n"}'const res = await fetch("https://api.kit.forhosting.com/dev2/diff-two-code-files", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"original_code": "function greet(name) {\n return `Hello, ${name}`;\n}\n",
"revised_code": "function greet(name = \"world\") {\n return `Hello, ${name}!`;\n}\n"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev2/diff-two-code-files",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"original_code": "function greet(name) {\n return `Hello, ${name}`;\n}\n",
"revised_code": "function greet(name = \"world\") {\n return `Hello, ${name}!`;\n}\n"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/diff-two-code-files", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"original_code":"function greet(name) {\\n return `Hello, ${name}`;\\n}\\n","revised_code":"function greet(name = \\"world\\") {\\n return `Hello, ${name}!`;\\n}\\n"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"original_code":"function greet(name) {\n return `Hello, ${name}`;\n}\n","revised_code":"function greet(name = \"world\") {\n return `Hello, ${name}!`;\n}\n"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/diff-two-code-files", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"original_code": "function greet(name) {\n return `Hello, ${name}`;\n}\n",
"revised_code": "function greet(name = \"world\") {\n return `Hello, ${name}!`;\n}\n"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev2.diff_two_code_files",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |
Notes techniques
Fournissez les deux versions du code
Placez l’ancien texte source dans original_code et le nouveau dans revised_code.
Lisez les changements structurés et la vue unifiée
Les enregistrements inchangés incluent old_line et new_line, puisque la ligne existe dans les deux versions. Ceux qui sont supprimés incluent old_line, tandis que les ajouts incluent new_line. Le champ unified_diff commence par les marqueurs des fichiers original et révisé, puis affiche un en-tête de plage et des lignes préfixées : une espace signifie inchangé, un signe moins indique une suppression et un signe plus indique un ajout.
Exploitez une sortie déterministe dans vos processus
Utilisez unified_diff pour rédiger une entrée de journal lisible, joindre un artefact compact à une tâche ou alimenter un outil qui comprend les préfixes habituels.