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.

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#
| Estilo | Ejemplo | Otros nombres |
|---|---|---|
| camelCase | orderTotal | lowerCamelCase |
| PascalCase | OrderTotal | UpperCamelCase, CapWords (en Python) |
| snake_case | order_total | |
| kebab-case | order-total | dash-case, spinal-case |
| UPPER_CASE | ORDER_TOTAL | SCREAMING_SNAKE_CASE, CONSTANT_CASE |
| flatcase | ordertotal | usado en paquetes de Go y Java |
El nombre kebab viene de la brocheta: las palabras quedan ensartadas en el guion.
Por lenguaje#
JavaScript y TypeScript#
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
constdentro de una función sigue en camelCase:constdice 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#
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 { 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 (
UserProfileenuser-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#
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, comofix(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.opensolo 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:
orderses una lista,orderes un elemento.orderListes redundante. - Sin abreviaturas oscuras:
customerIdy nocId. 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,
loadHttpUrly noloadHTTPURL, porque queda legible y funciona en cualquier convención. - Eventos y handlers por lo que hacen:
saveUserData()dice más quehandleClick(). 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:
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:
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#
- Guía de estilo de TypeScript de Google
- PEP 8: convenciones de nombres en Python
- Effective Go: nombres
- Convenciones de nombres en C#
- Rust API Guidelines: nombres
- Guía de estilo de Angular
- Estructura de URL, Google Search Central
- Guía de estilo de JSON de Google
- Identificadores en PostgreSQL
- Conventional Commits
- naming-convention de typescript-eslint
Comentarios
Para comentar, entra con tu cuenta de GitHub.
Sigue leyendo

Front-end10 min de lectura
Signals en Angular 22: signal, computed, effect y más

Front-end12 min de lectura
Smart y dumb components en Angular y React, en 2026

Front-end11 min de lectura
Storybook: cómo empezar y hasta dónde vale la pena ir