Tous les articles

Front-end9 min de lecture

camelCase, PascalCase, kebab-case et snake_case : quand ?

Quand utiliser camelCase, PascalCase, kebab-case, snake_case et UPPER_CASE en TypeScript, Python, Go, C#, CSS, URLs, base de données et Git, avec une règle de lint.

Aussi en Português, English, Español

Chaque projet a cette discussion : le fichier s'appelle UserProfile.tsx ou user-profile.tsx ? La colonne, c'est createdAt ou created_at ? La constante s'écrit en majuscules ? Cela ressemble à un détail, mais des noms incohérents coûtent cher : on se trompe d'import, on cherche la mauvaise chose dans l'éditeur et on perd du temps en code review à débattre de goûts.

La bonne nouvelle, c'est qu'il n'y a presque jamais de goût à débattre. Chaque langage, format et outil a déjà une convention officielle ou dominante. Cet article rassemble les principales au même endroit et explique la raison de chacune, ce qui aide à s'en souvenir.

Une précision honnête : les règles de chaque langage viennent des guides officiels (en lien à la fin), et la configuration de lint de la fin a été testée : un fichier correct passe et un fichier incorrect signale les cinq erreurs.

TL;DR#

  • camelCase (firstName) : variables, fonctions et propriétés en JavaScript, TypeScript, Java et JSON.
  • PascalCase (UserProfile) : classes, types, interfaces et composants, dans presque tous les langages.
  • snake_case (first_name) : Python, Rust, Ruby et noms de tables et de colonnes en base de données.
  • kebab-case (user-profile) : CSS, URLs, noms de fichiers sur le web, paquets npm et branches.
  • UPPER_CASE (MAX_RETRIES) : constantes et variables d'environnement.
  • La règle qui prime sur toutes les autres : suivez la convention du langage et du projet, et laissez un outil de lint la faire respecter.

Le nom de chaque style#

StyleExempleAutres noms
camelCaseorderTotallowerCamelCase
PascalCaseOrderTotalUpperCamelCase, CapWords (en Python)
snake_caseorder_total
kebab-caseorder-totaldash-case, spinal-case
UPPER_CASEORDER_TOTALSCREAMING_SNAKE_CASE, CONSTANT_CASE
flatcaseordertotalutilisé pour les paquets Go et Java
Le même nom, cinq styles. Chacun a sa place

Le nom kebab vient de la brochette : les mots sont enfilés sur le tiret.

Par langage#

JavaScript et TypeScript#

naming.ts
export const MAX_RETRIES = 3;
export enum OrderStatus { Pending, Paid }
export interface UserProfile { firstName: string; isAdmin: boolean }
export class OrderService {
  private readonly baseUrl = '/api';
  getOrders(customerId: string) { return `${this.baseUrl}/customers/${customerId}`; }
}
export function OrderCard() { return null; }
export function formatPrice(value: number) {
  const isFree = value === 0;
  const headers = { 'Content-Type': 'application/json' };
  return isFree ? 'Free' : `${value} ${headers['Content-Type']}`;
}
  • camelCase pour les variables, fonctions, paramètres, méthodes et propriétés.
  • PascalCase pour les classes, interfaces, types, enums et composants React (React exige qu'un composant commence par une majuscule, pour le distinguer d'une balise HTML).
  • UPPER_CASE pour les constantes de module qui représentent une valeur fixe, comme une limite ou un réglage. Une const dans une fonction reste en camelCase : const dit que la variable ne change pas, pas qu'il s'agit d'une « constante » au sens de la configuration.

Le guide de style TypeScript de Google suit exactement cette répartition.

Python#

naming.py
MAX_RETRIES = 3
 
class OrderService:
    def get_orders(self, customer_id: str) -> list[dict]:
        is_cached = customer_id in self._cache
        ...

Le PEP 8, guide officiel de Python, définit : snake_case pour les fonctions, variables et méthodes, CapWords (PascalCase) pour les classes, UPPER_CASE pour les constantes, et des noms de modules courts, en minuscules. Le _ devant (_cache) indique un usage interne.

Go#

Go a une particularité : la majuscule change le comportement. Un nom qui commence par une majuscule (GetOrders) est exporté, visible en dehors du paquet. Avec une minuscule (getOrders), il reste privé au paquet. C'est pour ça que Go utilise MixedCaps et pas snake_case, et que les noms de paquets sont courts et en minuscules, sans séparateur.

C# et .NET#

Microsoft documente : PascalCase pour les classes, méthodes et propriétés publiques, camelCase pour les paramètres et variables locales, _camelCase pour les champs privés, et des interfaces qui commencent par I (IOrderService).

Java#

Classes en PascalCase, méthodes et variables en camelCase, constantes en UPPER_CASE et paquets entièrement en minuscules (com.example.orders).

Rust#

Les directives officielles du langage demandent snake_case pour les fonctions, variables et modules, UpperCamelCase pour les types et traits et SCREAMING_SNAKE_CASE pour les constantes. Le compilateur prévient quand un nom s'en écarte.

En dehors du code#

CSS et HTML#

order-card.css
.order-card { display: grid; }
.order-card__title { font-weight: 600; }
.order-card--selected { outline: 2px solid currentColor; }
 
:root { --color-accent: #ff385c; }
  • kebab-case est le standard du CSS lui-même (background-color, font-weight), et les classes suivent le même style.
  • BEM est une convention populaire par-dessus : bloc (order-card), élément (__title) et modificateur (--selected).
  • Les variables CSS s'écrivent aussi en kebab-case, avec -- devant.
  • Un élément personnalisé en HTML doit contenir un tiret dans son nom, selon la spécification : <order-card> est valide, <ordercard> ne l'est pas. C'est ainsi que le navigateur distingue votre balise d'une balise native.

URLs#

/articles/composants-smart-et-dumb et non /articles/composants_smart_et_dumb. La documentation de Google pour les moteurs de recherche recommande des tirets pour séparer les mots dans les URLs. Utilisez aussi uniquement des minuscules : les URLs sont sensibles à la casse, et /Contact et /contact deviennent deux pages.

Noms de fichiers#

Ici l'écosystème se divise, et ce qui compte, c'est la convention du framework :

  • Angular : kebab-case, le guide officiel demandant que le nom du fichier corresponde à la classe (UserProfile dans user-profile.ts).
  • React : il est courant que le fichier du composant suive le nom du composant (UserProfile.tsx), et le reste en kebab-case ou camelCase. Il n'y a pas de règle officielle, alors choisissez-en une et documentez-la.
  • Python : snake_case, car le nom du fichier devient le nom du module dans l'import.

Un piège qui attrape beaucoup de monde : par défaut, macOS et Windows ne distinguent pas majuscules et minuscules dans les noms de fichiers, alors que Linux, si. Si vous renommez button.tsx en Button.tsx sur un Mac, Git peut ne pas voir le changement, votre import fonctionne sur votre machine et casse en CI, qui tourne sous Linux. Pour changer seulement la casse, utilisez git mv button.tsx Button.tsx.

Bases de données#

orders.sql
CREATE TABLE customer_orders (
  id BIGSERIAL PRIMARY KEY,
  customer_id BIGINT NOT NULL,
  created_at TIMESTAMPTZ NOT NULL DEFAULT now()
);

Le snake_case en minuscules est le standard le plus sûr. Dans PostgreSQL, les noms sans guillemets sont convertis en minuscules : si vous créez la colonne createdAt sans guillemets, elle devient createdat. Pour garder la majuscule, il faut écrire "createdAt" entre guillemets dans chaque requête, pour toujours.

APIs et JSON#

Il n'y a pas de consensus. Le guide JSON de Google utilise le camelCase pour les propriétés, ce qui est naturel quand on consomme en JavaScript. Beaucoup de grandes API publiques utilisent le snake_case. L'important est d'en choisir un et de le garder dans toute l'API. Si la base est en snake_case et le front en camelCase, faites la conversion à un seul endroit, dans la couche qui construit la réponse, et non éparpillée dans le code.

Variables d'environnement#

DATABASE_URL, API_KEY, NODE_ENV. UPPER_CASE avec underscore est la convention de tous les systèmes Unix, et la spécification POSIX décrit ainsi les noms des variables utilisées par ses utilitaires : lettres majuscules, chiffres et underscore.

Git#

  • Branches : kebab-case avec un préfixe du type de travail : feat/order-filter, fix/login-redirect.
  • Messages de commit : la spécification Conventional Commits utilise type(portée): description, comme fix(orders): keep selection after reload.

Au-delà de la casse : des noms qui s'expliquent#

La convention de casse, c'est la partie facile. Ce qui aide le plus le lecteur, c'est un nom qui dit ce qu'est la chose :

  • Les booléens comme une question : isOpen, hasItems, canEdit, shouldRetry. open tout seul peut être un verbe, un état ou une fonction.
  • Les fonctions avec un verbe : getOrders, formatPrice, saveDraft. Les composants et classes avec un nom : OrderCard, PriceFormatter.
  • Les listes au pluriel : orders est une liste, order est un élément. orderList est redondant.
  • Pas d'abréviation obscure : customerId et non cId. Les exceptions sont celles que tout le monde connaît : id, url, html.
  • Les sigles comme des mots : le guide de Google recommande de traiter un sigle comme un mot ordinaire, loadHttpUrl et non loadHTTPURL, car cela reste lisible et fonctionne avec n'importe quelle convention.
  • Les événements et handlers nommés d'après ce qu'ils font : saveUserData() en dit plus que handleClick(). Le guide de style d'Angular le recommande explicitement.

Laissez l'outil faire respecter la règle#

Une convention qui dépend de la mémoire et du code review finit par se perdre. En TypeScript, la règle naming-convention de typescript-eslint fait respecter tout cela dans l'éditeur et en CI :

eslint.config.mjs
import tseslint from 'typescript-eslint';
 
export default tseslint.config({
  files: ['**/*.ts', '**/*.tsx'],
  languageOptions: { parser: tseslint.parser, parserOptions: { projectService: true } },
  plugins: { '@typescript-eslint': tseslint.plugin },
  rules: {
    '@typescript-eslint/naming-convention': [
      'error',
      // Default: camelCase for variables, functions, parameters and members.
      { selector: 'default', format: ['camelCase'] },
      // React components are functions written in PascalCase.
      { selector: 'function', format: ['camelCase', 'PascalCase'] },
      // Module-level constants may be UPPER_CASE.
      { selector: 'variable', modifiers: ['const', 'global'], format: ['camelCase', 'UPPER_CASE', 'PascalCase'] },
      // Types, interfaces, classes and enums in PascalCase.
      { selector: 'typeLike', format: ['PascalCase'] },
      { selector: 'enumMember', format: ['PascalCase'] },
      // Booleans read like a question: isOpen, hasItems, canEdit.
      { selector: 'variable', types: ['boolean'], format: ['PascalCase'], prefix: ['is', 'has', 'should', 'can'] },
      // Object keys that come from outside (HTTP headers, APIs) are left alone.
      { selector: 'objectLiteralProperty', format: null },
    ],
  },
});

En la testant avec un fichier incorrect :

bad.ts
export interface user_profile { first_name: string }
export function Format_price(Value: number) {
  const free = Value === 0;
  return free;
}

ESLint a signalé les cinq problèmes : l'interface user_profile et la propriété first_name hors norme, la fonction Format_price, le paramètre Value et le booléen free sans préfixe de question. Le fichier du début de l'article est passé sans aucune erreur.

Un détail de version : typescript-eslint 8.73, la version actuelle en novembre 2026, exige encore un TypeScript inférieur à 6.1. Dans un projet déjà passé à TypeScript 7, vérifiez la compatibilité avant de l'installer.

Pour Python, Ruff propose les règles de nommage du PEP 8 (le groupe N). En Go et en Rust, l'outillage du langage s'en plaint déjà.

Checklist#

  • Variables et fonctions dans le style du langage (camelCase en JS/TS, snake_case en Python).
  • Classes, types et composants en PascalCase.
  • Constantes de configuration et variables d'environnement en UPPER_CASE.
  • CSS, URLs, paquets et branches en kebab-case, uniquement en minuscules.
  • Tables et colonnes en snake_case, sans guillemets.
  • Fichiers selon la convention du framework, et changements de casse faits avec git mv.
  • Booléens comme une question, fonctions avec un verbe, listes au pluriel.
  • Une règle de lint pour faire respecter tout ça, plutôt que le code review.

Références#

  • Front-end
  • conventions
  • bonnes-pratiques
  • typescript
  • python
  • css

Écrit par

Ingénieure logiciel et designer. J'écris sur ce que je rencontre en créant des apps, des APIs et des produits.

Commentaires

Connectez-vous avec votre compte GitHub pour commenter.