Calculatrice de complexité cyclomatique
L'API de complexité cyclomatique calcule la métrique de McCabe à partir de la structure d'un graphe de flot de contrôle : vous fournissez le nombre d'arêtes, le nombre de nœuds et le nombre de composantes connexes, et elle renvoie la complexité cyclomatique M = E − N + 2P, le nombre minimal de chemins linéairement indépendants à travers le code et une borne inférieure des cas de test nécessaires pour une couverture complète des branches. Aucun code source à téléverser, aucun analyseur à configurer : seulement trois comptages du graphe que vous avez déjà, et un nombre déterministe en retour, calculé de la même façon dans votre navigateur et sur notre edge.
Lancer gratuitement
Ce que mesure la complexité cyclomatique
La complexité cyclomatique, introduite par Thomas McCabe en 1976, compte le nombre de chemins linéairement indépendants dans le graphe de flot de contrôle d'un programme. Chaque point de décision — un if, une boucle while, une branche case, une expression conditionnelle — ajoute un chemin, de sorte que la métrique reflète la difficulté à tester et à raisonner sur un morceau de code. Une valeur de 1 signifie un code linéaire, sans aucune branche. Une valeur de 10 est le seuil largement cité au-delà duquel un module commence à demander une division. Le nombre est une propriété du graphe, pas du langage : une fois le graphe de flot de contrôle d'une fonction dessiné, sa complexité est fixée, et cette calculatrice de complexité cyclomatique l'évalue directement à partir des trois comptages du graphe. Comme l'entrée se limite aux arêtes, aux nœuds et aux composantes, elle fonctionne pour le pseudocode, les organigrammes et les graphes exportés de n'importe quel outil d'analyse statique, sans avoir à partager le code source lui-même.
La formule M = E − N + 2P
La métrique se calcule comme M = E − N + 2P, où E est le nombre d'arêtes du graphe de flot de contrôle, N le nombre de nœuds et P le nombre de composantes connexes. Pour un seul programme ou une seule fonction, le graphe forme une seule composante connexe, donc P = 1 et la formule se réduit à M = E − N + 2. Quand vous analysez plusieurs fonctions déconnectées à la fois — par exemple les graphes d'appel de trois modules distincts dessinés dans un même diagramme — P compte chaque morceau déconnecté et le terme +2P garde le résultat cohérent avec la somme des complexités des parties. L'endpoint renvoie aussi decision_points, défini comme M − 1, qui correspond au nombre de prédicats d'un programme structuré dont le graphe a été mesuré. Les trois entrées doivent être des entiers positifs ; l'appel rejette les fractions, le zéro, les comptages négatifs et les valeurs non numériques, car de tels comptages ne peuvent pas décrire un graphe de flot de contrôle réel et les accepter en silence masquerait une erreur de mesure en amont.
Comment utiliser ce nombre en pratique
La complexité indique le nombre minimal de cas de test nécessaires pour parcourir chaque chemin indépendant, et les équipes l'utilisent donc comme plancher de couverture dans la planification des tests : une fonction avec M = 7 ne peut pas être entièrement testée en branches avec trois tests, si ingénieux soient-ils. Elle alimente aussi la politique de revue de code — beaucoup d'organisations signalent toute fonction dont la complexité dépasse une limite convenue — et le suivi de la dette technique, où la somme ou le maximum sur une base de code est surveillé version après version. Cette API est l'étape arithmétique de ce flux de travail : comptez les arêtes, les nœuds et les composantes depuis votre analyseur ou votre diagramme, envoyez-les et obtenez la même valeur à chaque fois, car le calcul est entièrement déterministe, sans arrondi ni heuristique. Elle s'exécute sur notre edge mondial à $0.002 par requête, et le même code s'exécute gratuitement dans votre navigateur sur cette page : vous pouvez vérifier un chiffre à la main et ne payer que lorsque vous automatisez le contrôle dans un pipeline.
Cas d’usage
Fixer un plancher de couverture de tests
Transformez les comptages du graphe de votre analyseur statique en nombre minimal de cas de test pour couvrir chaque chemin indépendant d'une fonction.
Imposer un budget de complexité en CI
Faites échouer un build quand la complexité cyclomatique d'un module franchit le seuil convenu par l'équipe, calculée à partir des arêtes, nœuds et composantes.
Vérifier des réponses de devoirs et d'examens
Vérifiez le résultat d'un exercice de génie logiciel qui demande le nombre de McCabe à partir d'un organigramme, avec la formule affichée dans la réponse.
Questions fréquentes
Combien cela coûte-t-il ?
$0.002 par requête. C'est aussi gratuit dans votre navigateur sur cette page — le même code calcule les deux.
Quelle formule est utilisée ?
La formule originale de McCabe, M = E − N + 2P, où E désigne les arêtes, N les nœuds et P les composantes connexes. Pour un seul programme, P = 1, donc E − N + 2.
Pourquoi mes données sont-elles rejetées ?
Les arêtes, les nœuds et les composantes doivent être des entiers positifs. Le zéro, les nombres négatifs, les fractions et les valeurs non numériques ne peuvent pas décrire un graphe de flot de contrôle réel et sont rejetés comme entrée invalide.
Qu'est-ce que le champ decision_points ?
C'est M − 1 : le nombre de nœuds prédicats (de décision) d'un programme structuré dont le graphe a cette complexité. C'est une commodité pour les équipes qui comptent les if et les boucles plutôt que les arêtes.
Dois-je envoyer du code source ?
Non. L'entrée se compose de trois comptages du graphe de flot de contrôle, donc le code propriétaire ne quitte jamais votre analyseur — seuls les totaux d'arêtes, de nœuds et de composantes voyagent.
Le résultat est-il déterministe ?
Oui. C'est une arithmétique entière exacte, sans arrondi, aléa ni appel externe : les mêmes trois comptages renvoient toujours la même complexité.
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/math/cyclomatic-complexity \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"edges":9,"nodes":8,"components":1}'const res = await fetch("https://api.kit.forhosting.com/math/cyclomatic-complexity", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"edges": 9,
"nodes": 8,
"components": 1
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/math/cyclomatic-complexity",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"edges": 9,
"nodes": 8,
"components": 1
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/math/cyclomatic-complexity", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"edges":9,"nodes":8,"components":1}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"edges":9,"nodes":8,"components":1}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/math/cyclomatic-complexity", 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
{
"edges": 9,
"nodes": 8,
"components": 1
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "math.cyclomatic_complexity",
"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. |