- Convertisseur de casse : camelCase, snake_case, slug

À quoi sert un convertisseur de casse ?

En programmation, la casse (ou case en anglais) désigne la façon dont les mots d'un identifiant sont assemblés et ponctués : majuscules, minuscules, tirets, underscores ou points. Chaque langage et chaque écosystème impose ses propres conventions de nommage, et les respecter n'est pas une coquetterie : c'est une condition de lisibilité, de cohérence et parfois même de bon fonctionnement du code.

Un convertisseur de casse automatise cette transformation. Plutôt que de renommer manuellement maVariableUtilisateur en ma_variable_utilisateur au risque d'oublier une lettre ou d'ajouter une majuscule mal placée, vous collez le texte et l'outil produit instantanément toutes les variantes. C'est un gain de temps réel sur des tâches répétitives : renommer des champs, générer des slugs d'URL, transformer une maquette en noms de classes CSS, ou aligner du code importé sur la convention de votre projet.

Pourquoi la casse compte autant

Une base de code cohérente se lit plus vite. Lorsqu'un développeur voit UserProfile, il sait immédiatement qu'il s'agit d'une classe ou d'un composant ; userProfile lui indique une variable ou une instance ; USER_PROFILE signale une constante. Cette grammaire visuelle réduit la charge mentale et limite les erreurs.

À l'inverse, mélanger les conventions dégrade la qualité : les revues de code deviennent fastidieuses, les recherches échouent, et certains environnements sensibles à la casse (Linux, Git, npm) génèrent des bugs silencieux quand MonFichier.ts et monfichier.ts sont confondus.

Les conventions de nommage expliquées

Voici les 12 conventions prises en charge par l'outil, avec un exemple basé sur la phrase « nom utilisateur actif » :

camelCase et PascalCase

Ces deux conventions « collent » les mots et utilisent les majuscules comme séparateurs visuels. camelCase tient son nom des bosses du chameau formées par les majuscules internes. PascalCase (ou UpperCamelCase) ajoute simplement une majuscule au tout premier mot.

snake_case, kebab-case et CONSTANT_CASE

snake_case relie les mots par des underscores et reste tout en minuscules — populaire en Python et dans les bases de données. kebab-case (les mots embrochés comme une brochette) utilise des tirets : c'est le standard des URL, des noms de fichiers et des classes CSS. CONSTANT_CASE combine majuscules et underscores pour signaler une valeur immuable.

Slug URL : un cas particulier

Le slug est un kebab-case « nettoyé » : il supprime les accents (é → e), retire la ponctuation et met tout en minuscules. Été à Paris ! devient ete-a-paris — une chaîne sûre pour une URL, sans risque d'encodage cassé ni de caractère interdit.

Quelle casse choisir selon le contexte

Il n'existe pas de « meilleure » convention dans l'absolu : le bon choix dépend du langage, de l'écosystème et de la nature de l'élément nommé. Voici les usages les plus répandus.

JavaScript et TypeScript

L'écosystème JS repose sur camelCase pour les variables, les propriétés d'objet et les fonctions, et sur PascalCase pour les classes, les types, les interfaces et les composants. Angular suit strictement cette règle : un composant se nomme ProductListComponent, son sélecteur app-product-list (kebab-case), et son fichier product-list.component.ts.

Python, Ruby et bases de données

Python impose le snake_case via la PEP 8 pour les variables et fonctions, et le PascalCase pour les classes. Les bases de données relationnelles (PostgreSQL, MySQL) préfèrent le snake_case pour les tables et colonnes, car beaucoup de moteurs replient les identifiants non protégés en minuscules.

Le web : CSS, fichiers et URL

Le kebab-case règne sur le front-end : classes CSS (card-header), attributs data-*, web components et noms de fichiers. Les URL utilisent le slug, qui est un kebab-case sans accents — un détail crucial pour le SEO, car une URL propre et lisible est mieux indexée qu'une chaîne encodée.

Convertir la casse en JavaScript

Si vous souhaitez intégrer cette logique dans votre propre code, tout repose sur une étape clé : découper le texte en mots. Une fois cette liste de mots obtenue, chaque convention n'est qu'un assemblage différent.

Étape 1 — Découper le texte en mots

Le tokeniseur doit gérer trois cas : les séparateurs explicites (espaces, tirets, underscores), les frontières camelCase (aB) et les acronymes (HTMLParser → HTML / Parser).

// Découpe un texte en mots, quelle que soit sa casse d'origine
function tokenize(str) {
    if (!str) return [];
    return String(str)
        // insère un espace entre minuscule/chiffre et majuscule : aB -> a B
        .replace(/([\p{Ll}\p{N}])(\p{Lu})/gu, '$1 $2')
        // sépare un acronyme du mot suivant : HTMLParser -> HTML Parser
        .replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, '$1 $2')
        // remplace tout caractère non alphanumérique par un espace
        .replace(/[^\p{L}\p{N}]+/gu, ' ')
        .trim()
        .split(/\s+/)
        .filter(Boolean);
}

tokenize('getUserID');          // -> ['get', 'User', 'ID']
tokenize('mon-super_titre');    // -> ['mon', 'super', 'titre']
tokenize('HTMLParser2026');     // -> ['HTML', 'Parser2026']

Étape 2 — Réassembler selon la convention

// Helpers de transformation d'un mot
const lower = w => w.toLowerCase();
const upper = w => w.toUpperCase();
const cap   = w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();

// camelCase : premier mot en minuscule, le reste capitalisé
function camelCase(str) {
    return tokenize(str)
        .map((w, i) => (i === 0 ? lower(w) : cap(w)))
        .join('');
}

// snake_case : minuscules reliées par des underscores
function snakeCase(str) {
    return tokenize(str).map(lower).join('_');
}

// kebab-case : minuscules reliées par des tirets
function kebabCase(str) {
    return tokenize(str).map(lower).join('-');
}

// CONSTANT_CASE : majuscules reliées par des underscores
function constantCase(str) {
    return tokenize(str).map(upper).join('_');
}

camelCase('nom utilisateur actif');    // -> 'nomUtilisateurActif'
snakeCase('NomUtilisateurActif');      // -> 'nom_utilisateur_actif'
kebabCase('NOM_UTILISATEUR_ACTIF');    // -> 'nom-utilisateur-actif'

Étape 3 — Générer un slug d'URL

Le slug ajoute une étape de normalisation pour retirer les accents avant le découpage :

// Slug : kebab-case sans accents, sûr pour une URL
function slugify(str) {
    const sansAccents = str
        .normalize('NFD')                  // décompose é -> e + ´
        .replace(/[̀-ͯ]/g, '');  // supprime les diacritiques
    return tokenize(sansAccents).map(w => w.toLowerCase()).join('-');
}

slugify('Été à Paris : le guide !'); // -> 'ete-a-paris-le-guide'

Cas d'usage courants

Questions fréquentes