Todos los artículos

Front-end8 min de lectura

camelCase, PascalCase, kebab-case y snake_case: cuándo usar

Cuándo usar camelCase, PascalCase, kebab-case, snake_case y UPPER_CASE en TypeScript, Python, Go, C#, CSS, URLs, bases de datos y Git, con una regla de lint probada.

También en Português, English, Français

Todo proyecto tiene esa discusión: ¿el archivo es UserProfile.tsx o user-profile.tsx? ¿La columna es createdAt o created_at? ¿La constante va en mayúsculas? Parece un detalle, pero un nombre inconsistente sale caro: te equivocas en un import, buscas lo que no es en el editor y pierdes tiempo en el code review discutiendo gustos.

La buena noticia es que casi nunca hay gustos que discutir. Cada lenguaje, formato y herramienta ya tiene una convención oficial o dominante. Este post junta las principales en un solo lugar y explica el porqué de cada una, que es lo que ayuda a recordarlas.

Un aviso honesto: las reglas de cada lenguaje vienen de las guías oficiales (enlazadas al final), y la configuración de lint del final se probó: un archivo correcto pasa y uno incorrecto marca los cinco errores.

TL;DR#

  • camelCase (firstName): variables, funciones y propiedades en JavaScript, TypeScript, Java y JSON.
  • PascalCase (UserProfile): clases, tipos, interfaces y componentes, en casi todos los lenguajes.
  • snake_case (first_name): Python, Rust, Ruby y nombres de tablas y columnas en bases de datos.
  • kebab-case (user-profile): CSS, URLs, nombres de archivo en la web, paquetes npm y ramas.
  • UPPER_CASE (MAX_RETRIES): constantes y variables de entorno.
  • La regla que vale más que todas: sigue la convención del lenguaje y del proyecto, y deja que una herramienta de lint la haga cumplir.

El nombre de cada estilo#

EstiloEjemploOtros nombres
camelCaseorderTotallowerCamelCase
PascalCaseOrderTotalUpperCamelCase, CapWords (en Python)
snake_caseorder_total
kebab-caseorder-totaldash-case, spinal-case
UPPER_CASEORDER_TOTALSCREAMING_SNAKE_CASE, CONSTANT_CASE
flatcaseordertotalusado en paquetes de Go y Java
El mismo nombre, cinco estilos. Cada uno tiene su lugar

El nombre kebab viene de la brocheta: las palabras quedan ensartadas en el guion.

Por lenguaje#

JavaScript y 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 para variables, funciones, parámetros, métodos y propiedades.
  • PascalCase para clases, interfaces, tipos, enums y componentes de React (React exige que un componente empiece con mayúscula, para distinguirlo de una etiqueta HTML).
  • UPPER_CASE para constantes de módulo que representan un valor fijo, como un límite o una configuración. Una const dentro de una función sigue en camelCase: const dice que la variable no cambia, no que sea una "constante" en el sentido de configuración.

La guía de estilo de TypeScript de Google sigue exactamente esta división.

Python#

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

El PEP 8, la guía oficial de Python, define: snake_case para funciones, variables y métodos, CapWords (PascalCase) para clases, UPPER_CASE para constantes, y nombres de módulo cortos, en minúsculas. El _ adelante (_cache) indica uso interno.

Go#

Go tiene una particularidad: la mayúscula cambia el comportamiento. Un nombre que empieza con mayúscula (GetOrders) se exporta, es visible fuera del paquete. Con minúscula (getOrders), queda privado al paquete. Por eso Go usa MixedCaps y no snake_case, y los nombres de paquete son cortos y en minúsculas, sin separador.

C# y .NET#

Microsoft documenta: PascalCase para clases, métodos y propiedades públicas, camelCase para parámetros y variables locales, _camelCase para campos privados, e interfaces que empiezan con I (IOrderService).

Java#

Clases en PascalCase, métodos y variables en camelCase, constantes en UPPER_CASE y paquetes todos en minúsculas (com.example.orders).

Rust#

Las directrices oficiales del lenguaje piden snake_case para funciones, variables y módulos, UpperCamelCase para tipos y traits y SCREAMING_SNAKE_CASE para constantes. El compilador avisa cuando un nombre se aparta de eso.

Fuera del código#

CSS y 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 es el estándar del propio CSS (background-color, font-weight), y las clases siguen el mismo estilo.
  • BEM es una convención popular sobre eso: bloque (order-card), elemento (__title) y modificador (--selected).
  • Las variables CSS también van en kebab-case, con -- adelante.
  • Un elemento personalizado en HTML necesita un guion en el nombre, por regla de la especificación: <order-card> vale, <ordercard> no. Así el navegador distingue una etiqueta tuya de una nativa.

URLs#

/articulos/smart-y-dumb-components y no /articulos/smart_y_dumb_components. La documentación de Google para buscadores recomienda guiones para separar palabras en las URLs. Usa también solo minúsculas: las URLs distinguen mayúsculas de minúsculas, y /Acerca y /acerca se vuelven dos páginas.

Nombres de archivo#

Aquí el ecosistema se divide, y lo que vale es la convención del framework:

  • Angular: kebab-case, con la guía oficial pidiendo que el nombre del archivo coincida con la clase (UserProfile en user-profile.ts).
  • React: es común que el archivo del componente siga el nombre del componente (UserProfile.tsx), y el resto en kebab-case o camelCase. No hay regla oficial, así que elige una y documéntala.
  • Python: snake_case, porque el nombre del archivo se vuelve el nombre del módulo en el import.

Un cuidado que atrapa a mucha gente: macOS y Windows, por defecto, no distinguen mayúsculas de minúsculas en los nombres de archivo, y Linux sí. Si renombras button.tsx a Button.tsx en una Mac, Git puede no notar el cambio, tu import funciona en tu máquina y se rompe en la CI, que corre en Linux. Para cambiar solo las mayúsculas, usa git mv button.tsx Button.tsx.

Bases de datos#

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

snake_case en minúsculas es el estándar más seguro. En PostgreSQL, los nombres sin comillas se convierten a minúsculas: si creas la columna createdAt sin comillas, queda como createdat. Para mantener la mayúscula, tienes que escribir "createdAt" con comillas en cada consulta, para siempre.

APIs y JSON#

No hay consenso. La guía de JSON de Google usa camelCase en las propiedades, que es lo natural para quien consume en JavaScript. Muchas APIs públicas grandes usan snake_case. Lo importante es elegir uno y mantenerlo en toda la API. Si la base de datos es snake_case y el front es camelCase, haz la conversión en un solo lugar, en la capa que arma la respuesta, y no repartida por el código.

Variables de entorno#

DATABASE_URL, API_KEY, NODE_ENV. UPPER_CASE con guion bajo es la convención de todo sistema Unix, y la especificación POSIX describe así los nombres de las variables que usan sus utilidades: letras mayúsculas, dígitos y guion bajo.

Git#

  • Ramas: kebab-case con un prefijo del tipo de trabajo: feat/order-filter, fix/login-redirect.
  • Mensajes de commit: la especificación Conventional Commits usa tipo(alcance): descripción, como fix(orders): keep selection after reload.

Más allá de las mayúsculas: nombres que se explican#

La convención de mayúsculas es la parte fácil. Lo que más ayuda a quien lee es que el nombre diga qué es la cosa:

  • Booleanos como pregunta: isOpen, hasItems, canEdit, shouldRetry. open solo puede ser un verbo, un estado o una función.
  • Funciones con verbo: getOrders, formatPrice, saveDraft. Componentes y clases con sustantivo: OrderCard, PriceFormatter.
  • Listas en plural: orders es una lista, order es un elemento. orderList es redundante.
  • Sin abreviaturas oscuras: customerId y no cId. La excepción son las que todo el mundo conoce: id, url, html.
  • Siglas como palabra: la guía de Google recomienda tratar la sigla como una palabra común, loadHttpUrl y no loadHTTPURL, porque queda legible y funciona en cualquier convención.
  • Eventos y handlers por lo que hacen: saveUserData() dice más que handleClick(). La guía de estilo de Angular lo recomienda explícitamente.

Deja que la herramienta lo exija#

Una convención que depende de la memoria y del code review se pierde. En TypeScript, la regla naming-convention de typescript-eslint exige todo esto en el editor y en la 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 },
    ],
  },
});

Probándola con un archivo incorrecto:

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

ESLint marcó los cinco problemas: la interfaz user_profile y la propiedad first_name fuera del patrón, la función Format_price, el parámetro Value y el booleano free sin prefijo de pregunta. El archivo del principio del post pasó sin ningún error.

Un detalle de versión: typescript-eslint 8.73, la versión actual en noviembre de 2026, todavía pide TypeScript por debajo de la 6.1. En un proyecto que ya pasó a TypeScript 7, revisa la compatibilidad antes de instalarlo.

Para Python, Ruff tiene las reglas de nombres del PEP 8 (el grupo N). En Go y Rust, la propia herramienta del lenguaje ya se queja.

Checklist#

  • Variables y funciones en el estilo del lenguaje (camelCase en JS/TS, snake_case en Python).
  • Clases, tipos y componentes en PascalCase.
  • Constantes de configuración y variables de entorno en UPPER_CASE.
  • CSS, URLs, paquetes y ramas en kebab-case, solo minúsculas.
  • Tablas y columnas en snake_case, sin comillas.
  • Archivos siguiendo la convención del framework, y cambios de mayúsculas hechos con git mv.
  • Booleanos como pregunta, funciones con verbo, listas en plural.
  • Una regla de lint que lo exija, en lugar del code review.

Referencias#

  • Front-end
  • convenciones
  • buenas-practicas
  • typescript
  • python
  • css

Escrito por

Ingeniera de software y diseñadora. Escribo sobre lo que encuentro construyendo apps, APIs y productos.

Comentarios

Para comentar, entra con tu cuenta de GitHub.