ForHosting KIT · Outils pour développeurs

Comparateur de textes ligne par ligne

Le comparateur de différences confronte un texte original à sa version révisée et présente le résultat dans l’ordre de lecture.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Chaque ligne est signalée comme ajoutée, supprimée ou inchangée, avec le numéro qui lui correspond dans chaque version. Vous pouvez ainsi relire des modifications, contrôler des fichiers générés, valider une configuration et comprendre précisément ce qui distingue deux versions. La comparaison est déterministe, ne sollicite aucun réseau et traite uniformément les fins de ligne Windows, Mac classique et Unix.

Préparez les deux versions pour une comparaison pertinente

Placez la version antérieure dans le champ du texte original et la version ultérieure dans celui du texte révisé. Le comparateur examine des lignes complètes : la ponctuation, les majuscules, les espaces et chaque autre caractère comptent. Dès qu’un caractère change, la ligne apparaît comme une suppression suivie d’un ajout. Ce choix respecte la logique d’une révision ligne par ligne sans laisser croire que deux lignes différentes sont restées identiques. Les fins de ligne sont normalisées avant la comparaison. Vous pouvez donc confronter du contenu provenant de Windows, d’Unix ou d’un ancien Mac sans créer de faux écarts dus aux seules conventions de retour chariot. Les lignes vides situées dans un document gardent leur sens et peuvent être ajoutées, supprimées ou inchangées. Lorsqu’un document se termine par un saut de ligne, la dernière ligne vide participe également à la comparaison. Pour faciliter la lecture, évitez de mêler une refonte générale de la mise en forme à des changements de fond : une remise en forme étendue produit naturellement davantage d’écarts, même si les idées restent proches.

Interprétez les états, les numéros de ligne et le résumé

Le résultat suit l’ordre nécessaire pour reconstituer le passage de la version originale à la version révisée. Une entrée inchangée indique l’ancien et le nouveau numéro, puisque cette ligne exacte existe dans les deux textes. Une suppression ne comporte que son ancien numéro, tandis qu’un ajout ne comporte que le nouveau. Ces champs absents le sont volontairement : une ligne ajoutée n’a pas d’emplacement dans l’ancien document et une ligne supprimée n’en a pas dans le nouveau. Les totaux du résumé donnent une mesure rapide de la révision, tandis que la liste détaillée justifie chaque total. L’indicateur d’identité n’est vrai qu’en l’absence de tout ajout et de toute suppression. Des lignes répétées peuvent parfois admettre plusieurs alignements mathématiquement valides. Pour garantir une sortie stable, le comparateur applique une règle de départage fixe et privilégie la suppression lorsque deux alignements conservent autant de lignes inchangées. Les mêmes entrées produisent donc toujours la même séquence, ce qui convient aux tests et aux procédures de révision automatisées.

Exploitez les différences dans vos contrôles et automatisations

Une comparaison par ligne est particulièrement utile lorsque la structure compte : code source, configuration, notes de version, listes, politiques, consignes et relevés exportés en sont des exemples courants. Lors d’une relecture humaine, commencez par le résumé, puis examinez chaque couple de suppression et d’ajout dans son contexte. Dans une automatisation, consultez l’indicateur d’identité pour décider rapidement et conservez le détail si vous avez besoin d’une piste d’audit ou d’un rapport explicatif. L’outil ne juge pas si une modification est correcte, ne fusionne pas des changements concurrents et ne calcule pas de similarité sémantique. Il expose les relations textuelles exactes afin qu’une personne ou une autre règle déterministe puisse trancher. Les deux entrées sont limitées pour garantir une exécution prévisible, et la comparaison se déroule entièrement en mémoire sans service externe. Une utilisation de l’API coûte $0.002. Pour traiter de nombreux fichiers, comparez-les deux par deux et conservez leurs noms ou identifiants de version dans votre propre flux, car cette capacité reçoit du texte et non les métadonnées d’un dépôt. Pour les contenus sensibles, respectez les règles de conservation et de transport du canal choisi.

Cas d’usage

Contrôler une configuration modifiée

Confrontez l’ancienne configuration à la proposition pour retrouver chaque ligne précisément ajoutée ou supprimée par la mise à jour.

Valider un résultat généré

Comparez un manifeste, un rapport ou un fragment de code nouvellement produit à une version de référence dans un processus automatisé.

Expliquer la révision d’un document

Constituez un relevé structuré des changements apportés à des politiques, notes de version, consignes ou autres documents organisés en lignes.

Questions fréquentes

Que signifie chaque état ?

Inchangée signifie que la ligne exacte figure dans l’alignement retenu des deux versions. Supprimée indique qu’elle n’existe que dans l’original, et ajoutée qu’elle n’existe que dans la révision.

Les mots d’une ligne modifiée sont-ils comparés ?

Non. La comparaison porte volontairement sur des lignes entières. Une ligne modifiée apparaît comme une suppression puis un ajout, ce qui fournit un relevé exact et sans ambiguïté.

Des formats de fin de ligne différents créent-ils un écart ?

Non. Les fins de ligne Windows, Unix et Mac classique sont normalisées avant la comparaison.

Comment les lignes identiques répétées sont-elles alignées ?

L’algorithme conserve une plus longue suite commune de lignes et applique un départage stable privilégiant la suppression lorsque plusieurs alignements se valent.

Puis-je employer le résultat dans des tests automatisés ?

Oui. L’algorithme n’utilise ni réseau, ni hasard, ni valeur liée au temps ; des entrées identiques donnent donc toujours le même JSON.

Combien coûte une requête API ?

Chaque requête API coûte $0.002. La version pour navigateur peut exécuter localement la même comparaison déterministe.

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

POSThttps://api.kit.forhosting.com/str/diff-lines

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/str/diff-lines \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"before_text":"Apples\nBananas\nCherries","after_text":"Apples\nBlueberries\nCherries"}'

const res = await fetch("https://api.kit.forhosting.com/str/diff-lines", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "before_text": "Apples\nBananas\nCherries",
    "after_text": "Apples\nBlueberries\nCherries"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/str/diff-lines",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "before_text": "Apples\nBananas\nCherries",
    "after_text": "Apples\nBlueberries\nCherries"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/diff-lines", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"before_text":"Apples\\nBananas\\nCherries","after_text":"Apples\\nBlueberries\\nCherries"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"before_text":"Apples\nBananas\nCherries","after_text":"Apples\nBlueberries\nCherries"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/diff-lines", 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

{
  "before_text": "Apples\nBananas\nCherries",
  "after_text": "Apples\nBlueberries\nCherries"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "str.diff_lines",
  "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

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

Limites

`max_chars_per_text`	200000
`max_lines_per_text`	1000

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.

Consulter la documentation complète du KIT →