Compteur de commentaires du code
Mesurez la part d'un fichier source qui explique plutôt qu'elle n'exécute : un extrait de six lignes avec trois lignes de commentaire et trois de code donne un rapport de 1 et 50 % de commentaires. Les marqueurs entre guillemets ne comptent pas. Gratuit dans votre navigateur.
- Gratuit
- Fonctionne dans votre navigateur
- Sans inscription
- Vos données restent sur votre appareil
Lancer gratuitement
Exemple résolu
- Langue
- Javascript
- Total de lignes
- 6
- Lignes vides
- 1
- Lignes de commentaire
- 3
- Lignes de code
- 3
Le compteur de lignes de commentaires mesure la part d’un fichier source consacrée aux explications plutôt qu’au code exécutable. Collez votre source, choisissez le langage ou utilisez la détection automatique : vous obtenez les nombres de lignes commentées, codées, vides et mixtes, ainsi que le rapport commentaires-code. Ce résultat constitue un indicateur synthétique de densité documentaire pour les revues, la planification de la maintenance, les tableaux de qualité et les audits de dépôts. L’analyse lexicale est déterministe, ignore les marqueurs placés dans des chaînes et indique toujours le langage retenu.
Interprétez la mesure sans en faire un objectif
La densité des commentaires est utile lorsqu’elle ouvre une discussion, pas lorsqu’elle devient une note universelle. Ce compteur divise le nombre de lignes commentées par celui des lignes de code et exprime aussi les commentaires en pourcentage des observations. Une ligne contenant du code suivi d’un commentaire appartient aux deux catégories ; le nombre distinct de lignes mixtes rend ce chevauchement visible.
Les lignes vides n’appartiennent à aucune catégorie. Ces définitions rendent les mesures successives comparables, sans prétendre qu’un plus grand nombre de commentaires améliore toujours un logiciel. Une petite fonction peut être suffisamment claire grâce à ses noms et ses tests, tandis qu’un protocole complexe exigera peut-être des explications détaillées sur ses invariants.
Comparez des fichiers de rôles, de langages et de maturités proches. Repérez les variations étonnantes : disparition d’explications dans un sous-système complexe, en-têtes trompeurs dans du code généré ou hausse provoquée par du code désactivé laissé en commentaire. Croisez ce résultat avec la complexité, la couverture, les modifications et le jugement des spécialistes.
La mesure indique où regarder ; elle ne juge ni la justesse, ni la nécessité, ni l’utilité d’un commentaire.
Choisissez le langage et maîtrisez les règles de comptage
Sélectionnez le langage source dès que vous le connaissez, car les délimiteurs varient. La famille C emploie la double barre pour les commentaires de ligne et des blocs entre barre et astérisque ; Python et les scripts shell utilisent le croisillon ; SQL associe le double tiret aux blocs, et HTML possède ses propres délimiteurs de balisage. Le mode automatique examine des motifs courants et renvoie le langage déduit afin que ce choix reste visible.
L’analyseur suit les blocs sur plusieurs lignes et ignore les faux marqueurs dans les chaînes entre apostrophes, guillemets ou accents graves. Chaque ligne physique est classée selon qu’elle contient du code, un commentaire, les deux ou aucun. Un bloc multiligne ajoute donc autant de lignes commentées que de lignes physiques occupées.
Un commentaire après une instruction augmente les comptes du code, des commentaires et des lignes mixtes. Cette analyse lexicale est rapide et déterministe, mais ne remplace pas un compilateur. Les chaînes brutes particulières, langages incorporés, astuces de préprocesseur et littéraux documentaires peuvent nécessiter un langage explicite ou un analyseur spécialisé si une classification sémantique exacte est indispensable.
Exploitez le résultat dans les revues et la maintenance
Pour une revue ponctuelle, lancez le compteur avant et après la modification et examinez les écarts importants plutôt que d’imposer un seuil fixe. Une baisse du rapport dans un algorithme devenu plus complexe peut signaler que ses hypothèses ou cas limites méritent une explication. Une hausse peut correspondre à une documentation saine, mais aussi à du code neutralisé qui devrait être supprimé et conservé dans l’historique.
À l’échelle d’un dépôt, stockez les nombres avec l’identifiant du commit, le langage, le chemin et l’état de génération du fichier. Regroupez uniquement des éléments comparables : configuration, tests, clients générés et logique applicative n’ont pas les mêmes besoins documentaires. Considérez ce nombre comme un indice de priorité : combinez-le à la fréquence des modifications pour repérer les fichiers souvent changés mais peu expliqués, ou à la complexité pour guider les relecteurs.
Lisez toujours les commentaires eux-mêmes avant de conclure sur la maintenabilité.
Cas d’usage
Contrôler les changements documentaires
Comparez la densité avant et après une modification, puis étudiez les écarts inattendus des fichiers complexes.
Créer un tableau de qualité
Enregistrez des nombres et rapports stables avec la complexité, les modifications et la couverture des tests.
Prioriser la maintenance
Repérez les modules souvent modifiés qui fournissent très peu de contexte explicatif.
Questions fréquentes
Qu’est-ce que le rapport commentaires-code ?
Il s’agit du nombre de lignes commentées divisé par le nombre de lignes de code, arrondi à six décimales.
Comment comptez-vous une ligne mêlant code et commentaire ?
Elle compte une fois comme code, une fois comme commentaire et une fois dans le champ distinct des lignes mixtes.
Les lignes vides modifient-elles le rapport ?
Non. Elles sont présentées séparément et exclues des deux termes du rapport.
Que se passe-t-il si le fichier ne contient que des commentaires ?
Le rapport est omis, car une division par zéro n’a aucun résultat fini ; les nombres individuels restent disponibles.
La détection automatique du langage est-elle exacte ?
Non. Elle applique des règles prudentes fondées sur des motifs et affiche son choix. Sélectionnez explicitement le langage lorsque la précision est essentielle.
L’outil évalue-t-il la qualité des commentaires ?
Non. Il mesure la densité des lignes physiques, pas la justesse, l’actualité ou l’utilité des commentaires.
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/dev/count-comments \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"// Convert a value\nfunction double(value) {\n return value * 2; // arithmetic\n}"}'const res = await fetch("https://api.kit.forhosting.com/dev/count-comments", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "// Convert a value\nfunction double(value) {\n return value * 2; // arithmetic\n}"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/count-comments",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "// Convert a value\nfunction double(value) {\n return value * 2; // arithmetic\n}"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/count-comments", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"// Convert a value\\nfunction double(value) {\\n return value * 2; // arithmetic\\n}"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"// Convert a value\nfunction double(value) {\n return value * 2; // arithmetic\n}"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/count-comments", 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
{
"text": "// Convert a value\nfunction double(value) {\n return value * 2; // arithmetic\n}"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.count_comments",
"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.
Limites
max_mb | 5 |
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
Exploitez le résultat dans les revues et la maintenance
La sortie JSON stable alimente les tableaux de qualité et rapports d’intégration continue, tandis que l’exécution dans le navigateur permet un contrôle rapide et privé. L’automatisation par API coûte $0.002 par requête.