Détecter la casse : camelCase, snake_case et plus
Les conventions de nommage rendent les identifiants et les libellés prévisibles, mais un texte incohérent peut se glisser dans le code source, la configuration, les importations et le contenu généré.
Lancer gratuitement
Ce détecteur examine exactement les caractères que vous fournissez et indique s’ils suivent camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, Train-Case, dot.case, path/case, Title Case, Sentence case ou une forme simple en majuscules ou minuscules. La correspondance est stricte et déterministe : une même entrée produit toujours le même résultat, tandis qu’un texte ambigu ou irrégulier est clairement signalé comme mixte.
Comprenez ce que le détecteur vérifie
Le détecteur compare l’intégralité de votre saisie à un ensemble défini de modèles de nommage. Il ne se contente pas de compter les majuscules ou de rechercher un séparateur. En camelCase, le texte doit commencer par des minuscules et contenir au moins une frontière de mot marquée par une majuscule. PascalCase commence par une majuscule et joint les mots suivants sans séparateur. Les styles snake, constant, kebab, dot et path exigent au moins deux segments non vides, séparés uniformément par des tirets bas, des tirets, des points ou des barres obliques. Le texte séparé par des espaces est évalué comme Title Case, Sentence case, mots minuscules ou mots majuscules. Un résultat positif comprend le style reconnu et une brève explication. Si la ponctuation, des séparateurs incohérents, des majuscules inattendues ou des espaces extérieurs empêchent une correspondance exacte, le résultat devient mixte au lieu de proposer une supposition trompeuse. Ce comportement strict est précieux pour la validation, car il distingue une convention réellement respectée d’un texte qui lui ressemble seulement. Les chiffres sont admis dans de nombreux segments d’identifiant ; une entrée vide ou une valeur non textuelle est rejetée comme invalide plutôt que classée.
Validez les conventions par une détection exacte
Une étiquette de style est particulièrement utile lorsqu’elle s’intègre à un contrôle qualité reproductible. Envoyez un identifiant issu d’un formulaire, d’un pipeline de données, d’un générateur de code ou d’un audit de nommage, puis comparez le style retourné à la convention attendue par votre projet. Par exemple, une politique de champs d’API peut imposer snake_case, tandis que des propriétés JavaScript peuvent exiger camelCase. Un résultat mixte indique que la saisie mérite un examen, mais le détecteur ne la réécrit volontairement pas. Séparer détection et conversion empêche un contrôle automatique de modifier silencieusement des noms publics, des colonnes de base de données ou des clés déjà référencées. La réponse contient aussi un booléen de reconnaissance qui simplifie les branchements : les conventions acceptées renvoient vrai, les textes irréguliers renvoient faux. La correspondance exacte tient compte des espaces initiaux et finaux et repère ainsi les défauts invisibles de copier-coller avant l’entrée des identifiants dans un système. Pour traiter de nombreuses valeurs, appelez la capacité une fois par élément et conservez la valeur d’origine ainsi que le style détecté dans votre rapport. Vous obtenez ainsi un résultat vérifiable et laissez une personne décider si les noms exceptionnels sont intentionnels.
Interprétez les frontières et les entrées ambiguës
Les noms de casse peuvent se chevaucher lorsqu’une entrée ne contient qu’un mot. Le détecteur applique donc une priorité pratique et n’invente pas de frontières absentes. Un seul élément minuscule est indiqué comme lowercase, et non camelCase, car camel case présente normalement au moins un segment joint commençant par une majuscule. De même, un élément majuscule est UPPERCASE plutôt que CONSTANT_CASE. Les formes séparées de plusieurs mots sont plus précises : customer_order_id correspond à snake_case, CUSTOMER_ORDER_ID à CONSTANT_CASE et Customer Order Id à Title Case. Sentence case demande une majuscule initiale suivie de mots minuscules séparés par des espaces, alors que Title Case impose une majuscule au début de chaque mot. Les chaînes riches en sigles, les lettres Unicode, apostrophes, virgules, séparateurs doublés et combinaisons comme snake-Case sont déclarées mixtes si elles ne correspondent pas exactement à un modèle pris en charge. Cette prudence est volontaire : deviner une étiquette familière pourrait laisser passer un identifiant mal formé. L’algorithme est local et analytique, sans réseau, modèle de langage, hasard ni dépendance au temps. Les vérifications sont disponibles dans le navigateur et l’automatisation par API coûte $0.002 par élément.
Cas d’usage
Imposer les noms de champs d’API
Vérifiez que les noms reçus ou générés suivent la convention snake_case ou camelCase requise par un contrat d’API.
Auditer les clés de configuration
Classez les clés des fichiers de configuration et signalez les formes mixtes avant leur propagation entre environnements.
Valider les identifiants générés
Testez la sortie des générateurs de code de façon déterministe, sans modifier les identifiants ni masquer les frontières incorrectes.
Questions fréquentes
Quels styles de casse sont reconnus ?
Le détecteur reconnaît camelCase, PascalCase, snake_case, CONSTANT_CASE, kebab-case, Train-Case, dot.case, path/case, Title Case, Sentence case, les minuscules, les majuscules, les mots minuscules et les mots majuscules.
Pourquoi un mot minuscule n’est-il pas camelCase ?
Un seul mot minuscule ne comporte aucune frontière jointe ; il est donc classé comme lowercase. camelCase exige au moins une frontière en majuscule après le début minuscule.
L’outil convertit-il le texte vers une autre casse ?
Non. Il détecte uniquement le style actuel. Séparer la détection de la conversion sécurise la validation et préserve la saisie d’origine.
Que se passe-t-il avec des séparateurs ou majuscules incohérents ?
Le résultat est mixte et la reconnaissance vaut faux, car le texte ne suit exactement aucune convention prise en charge.
Combien coûte l’API ?
Chaque requête API coûte $0.002. La version pour navigateur de cette page peut s’exécuter localement sans appel d’API.
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/str/detect-case \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"text":"customerOrderId"}'const res = await fetch("https://api.kit.forhosting.com/str/detect-case", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"text": "customerOrderId"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/str/detect-case",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"text": "customerOrderId"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/str/detect-case", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"text":"customerOrderId"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"text":"customerOrderId"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/str/detect-case", 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": "customerOrderId"
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "str.detect_case",
"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. |