ForHosting KIT · Outils pour développeurs

Calculateur de distance d’édition de Levenshtein

Ce calculateur mesure l’écart entre deux chaînes par le nombre minimal d’insertions, de suppressions et de substitutions d’un caractère permettant de transformer la première en seconde.

● BetaGratuit · dans votre navigateur

Lancer gratuitement Voir l’API

Utilisez-le depuis WebAPIE-mailTelegramApp bientôt

Saisissez une source et une cible pour obtenir la distance et leurs longueurs. Le calcul est déterministe, sensible à la casse et aux espaces, et compatible Unicode ; vous pouvez ainsi valider un algorithme, comparer des saisies et construire un rapprochement de texte reproductible.

Ce que mesure la distance de Levenshtein

La distance de Levenshtein résume la comparaison par un entier. Zéro indique des chaînes identiques ; un signifie qu’une insertion, suppression ou substitution suffit. Les valeurs supérieures donnent le nombre minimal d’opérations. Ainsi, passer de <code>kitten</code> à <code>sitting</code> demande 3 modifications : 2 substitutions et 1 insertion. La mesure tient compte de l’ordre et reste symétrique lorsque vous inversez source et cible. Il s’agit d’un décompte absolu, et non d’un pourcentage. Une distance de 3 peut donc être forte pour un code court mais faible pour un paragraphe. Les deux longueurs fournies avec le résultat vous permettent de l’interpréter selon ce contexte.

Traitement exact des caractères

Les chaînes sont comparées sans nettoyage implicite. Majuscules, minuscules, espaces et ponctuation restent distincts, et aucune normalisation Unicode n’est appliquée. Les caractères sont parcourus comme points de code Unicode : un emoji courant vaut donc un caractère plutôt que deux moitiés UTF-16. Un symbole visuel composé peut néanmoins contenir plusieurs points. Si votre application doit rapprocher des graphies visuellement équivalentes, normalisez les deux entrées selon une règle explicite. L’algorithme de programmation dynamique ne conserve que deux lignes de calcul, ce qui limite la mémoire à la taille de la chaîne la plus courte. Chaque entrée est plafonnée à 5,000 points de code afin de borner le coût quadratique.

Bien exploiter le résultat

Cette distance aide à classer des correspondances approximatives, repérer des fautes et tester une transformation. Un moteur de recherche peut l’ajouter à ses signaux de correction ; un flux de données peut soumettre des noms proches à une vérification ; un test peut imposer un budget précis de modifications. N’appliquez pas le même seuil partout. Une distance de 2 peut être plausible dans un nom long mais désigner un autre code lorsqu’il est court. Tenez compte de la longueur, de la langue et du risque d’un faux rapprochement. Toutes les opérations ont le même poids : la mesure ignore la proximité des touches et ne compte pas une transposition comme une seule édition. Utilisez-la comme référence transparente, complétée par les règles de votre domaine.

Cas d’usage

Contrôler des suggestions orthographiques

Classez les corrections selon le minimum d’éditions entre la saisie et chaque terme connu.

Repérer des doublons probables

Comparez noms, libellés ou références et faites vérifier les rapprochements avant toute fusion.

Tester une transformation textuelle

Vérifiez une distance exacte entre valeur initiale et résultat dans des tests déterministes.

Questions fréquentes

Quelles opérations valent une édition ?

Insérer, supprimer ou remplacer un caractère compte chaque fois pour une édition.

La casse est-elle prise en compte ?

Oui. Uniformisez les deux entrées au préalable si vous souhaitez l’ignorer.

Les espaces modifient-ils la distance ?

Oui. Espaces, tabulations et retours à la ligne sont conservés exactement.

Comment Unicode et les emoji sont-ils comptés ?

Le calcul emploie les points de code Unicode ; un symbole composé peut toutefois en contenir plusieurs.

S’agit-il de Damerau-Levenshtein ?

Non. L’échange de deux caractères voisins n’est pas une opération unique ici.

Quel est le prix d’une requête API ?

Chaque requête API coûte $0.002. La version navigateur s’exécute localement sans requête payante.

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/dev/levenshtein

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/dev/levenshtein \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"source":"kitten","target":"sitting"}'

const res = await fetch("https://api.kit.forhosting.com/dev/levenshtein", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.KIT_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    "source": "kitten",
    "target": "sitting"
  })
});
const { task_id } = await res.json();

import os, requests

res = requests.post(
    "https://api.kit.forhosting.com/dev/levenshtein",
    headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
    json={
    "source": "kitten",
    "target": "sitting"
},
)
task_id = res.json()["task_id"]

<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/levenshtein", false, stream_context_create([
  "http" => [
    "method"  => "POST",
    "header"  => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
    "content" => '{"source":"kitten","target":"sitting"}',
  ],
]));
$task = json_decode($res, true);

body := bytes.NewBufferString(`{"source":"kitten","target":"sitting"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/levenshtein", 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

{
  "source": "kitten",
  "target": "sitting"
}

Exemple de réponse

{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.levenshtein",
  "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 5000

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 →