Convenciones de Nomenclatura en Programación — camelCase, snake_case y Más Allá

Abres un código fuente por primera vez y ves getUserName, get_user_name y GetUserName todo en el mismo archivo. Inmediatamente sabes que algo salió mal. Las convenciones de nomenclatura son una de esas cosas que parecen triviales hasta que trabajas en equipo — entonces se vuelven esenciales.

La nomenclatura consistente no es cuestión de preferencia personal. Se trata de hacer el código legible para la siguiente persona que lo toque, que a menudo eres tú mismo seis meses después.

Por Qué Importan las Convenciones de Nomenclatura

Tres cosas se rompen cuando un proyecto carece de nomenclatura consistente:

• La legibilidad se deteriora — Cuando los estilos de variables cambian cada pocas líneas, tu cerebro desperdicia ciclos analizando el formato en lugar de entender la lógica
• La colaboración del equipo se fractura — Los pull requests se convierten en campos de batalla sobre estilo en lugar de contenido. La incorporación de nuevos desarrolladores toma más tiempo porque no hay un patrón predecible
• Las herramientas dejan de funcionar correctamente — Los linters, autocompletado, generadores de código y herramientas de refactorización dependen de patrones de nomenclatura predecibles. Rompe la convención y romperás las herramientas

La convención que elijas importa mucho menos que elegir una y mantenerla. Un código fuente con snake_case consistente en todas partes es infinitamente mejor que uno mezclando tres estilos diferentes.

La Guía Completa de Convenciones de Nomenclatura

camelCase

La primera palabra va en minúsculas y cada palabra subsiguiente comienza con mayúscula. Sin separadores.

// JavaScript / TypeScript
const userName = "Alice";
let itemCount = 42;
function getUserProfile(userId) {
  return fetchData(`/users/${userId}`);
}

Dónde se usa: JavaScript, TypeScript y Java usan camelCase para variables, nombres de funciones y métodos. También es el estándar en Swift para variables locales y parámetros de funciones.

camelCase se lee naturalmente en inglés porque el inicio en minúsculas señala "esto es un valor regular, nada especial". Las mayúsculas marcan los límites entre palabras sin ningún carácter separador.

PascalCase

Cada palabra comienza con mayúscula. También llamado UpperCamelCase.

// TypeScript / C#
class UserProfile {
  firstName: string;
  lastName: string;
}

interface DatabaseConnection {
  host: string;
  port: number;
}

// Componente React
function NavigationBar({ items }: NavProps) {
  return <nav>{/* ... */}</nav>;
}

Dónde se usa: C# usa PascalCase para casi todo lo público — clases, métodos, propiedades. TypeScript y JavaScript lo usan para clases, interfaces, alias de tipos y enums. React obliga PascalCase para nombres de componentes porque JSX necesita distinguir componentes de elementos HTML.

En Go, PascalCase tiene un significado especial: cualquier identificador que comienza con mayúscula es exportado (público). Esto hace que la convención sea funcional, no solo cosmética.

snake_case

Todas las palabras en minúsculas, separadas por guiones bajos.

# Python
user_name = "Alice"
item_count = 42

def get_user_profile(user_id):
    return fetch_data(f"/users/{user_id}")

class UserProfile:
    def __init__(self, first_name, last_name):
        self.first_name = first_name
        self.last_name = last_name

Dónde se usa: Python usa snake_case para prácticamente todo excepto nombres de clases. Ruby sigue el mismo patrón. Rust usa snake_case para variables, funciones y módulos. Los esquemas de bases de datos casi universalmente usan snake_case para nombres de tablas y columnas.

snake_case es probablemente la convención más legible porque los guiones bajos crean separadores visuales claros. La compensación es que los identificadores son más largos.

SCREAMING_SNAKE_CASE

Todo en mayúsculas con guiones bajos. Reservado para constantes y valores que nunca deben cambiar.

// Constantes en la mayoría de lenguajes
const MAX_RETRY_COUNT = 3;
const API_BASE_URL = "https://api.example.com";
const DEFAULT_TIMEOUT_MS = 5000;

# Constantes en Python
DATABASE_URL = "postgresql://localhost:5432/mydb"
MAX_FILE_SIZE_BYTES = 104_857_600

// Constantes en Rust
const MAX_CONNECTIONS: u32 = 100;
static APP_VERSION: &str = "2.1.0";

Dónde se usa: Casi todos los lenguajes usan SCREAMING_SNAKE_CASE para constantes. El formato todo en mayúsculas es una señal universal que dice "no reasignes este valor". En C, también se usa para macros del preprocesador.

kebab-case

Todo en minúsculas con guiones como separadores.

/* Nombres de clases CSS */
.navigation-bar {
  background-color: #1a1a2e;
}

.user-profile-card {
  border-radius: 8px;
}

.btn-primary-large {
  font-size: 1.125rem;
}

<!-- Atributos HTML y data attributes -->
<div data-user-id="42" aria-label="main-navigation">
  <input type="text" placeholder="search-query" />
</div>

# Flags de CLI
npm install --save-dev eslint
git commit --no-verify
docker run --restart=always

Dónde se usa: CSS y HTML favorecen fuertemente kebab-case. Los slugs de URL lo usan (como la URL de este artículo). Las herramientas de línea de comandos y los flags lo siguen. Las claves de configuración en YAML y TOML a menudo también lo usan.

kebab-case no puede usarse para nombres de variables en la mayoría de lenguajes de programación porque el guión se interpreta como un operador de resta. Por eso vive en CSS, HTML y archivos de configuración en lugar de en código.

dot.case

Palabras separadas por puntos.

// Nombres de paquetes Java
package com.example.userservice.controllers;

import org.springframework.boot.SpringApplication;

# Claves de configuración
server.port=8080
spring.datasource.url=jdbc:postgresql://localhost/mydb
logging.level.root=INFO

Dónde se usa: Nomenclatura de paquetes Java, extensiones de archivos, claves de propiedades de configuración en Spring Boot y frameworks similares.

Title Case

Cada palabra principal se capitaliza. Las palabras menores como "y", "el" y "de" permanecen en minúsculas a menos que inicien la frase.

Configuración de Cuenta de Usuario
Opciones de Privacidad y Seguridad
Primeros Pasos con React

Dónde se usa: Encabezados de interfaz, títulos de páginas, elementos de menú, secciones de documentación y nombres propios. Es una convención de presentación más que de código.

path/case

Palabras separadas por barras diagonales, siguiendo convenciones de sistema de archivos o espacios de nombres.

src/components/UserProfile
com/example/service/UserAuth
features/authentication/login

Dónde se usa: Rutas del sistema de archivos, rutas de módulos, jerarquías de espacios de nombres y estructuras de enrutamiento de URLs. Es estructural más que estilístico.

Tabla de Convenciones por Lenguaje

Aquí tienes una referencia rápida de lo que espera cada lenguaje:

La clave de esta tabla: PascalCase para tipos y clases es casi universal. La mayor variación está en cómo los lenguajes manejan variables y funciones.

Errores Comunes y Cómo Solucionarlos

1. Mezclar convenciones dentro del mismo ámbito

// ❌ Inconsistente
const user_name = "Alice";
const itemCount = 42;
const MaxRetries = 3;

// ✅ camelCase consistente
const userName = "Alice";
const itemCount = 42;
const maxRetries = 3;

Este es el error más común. Sucede cuando los desarrolladores traen hábitos de un lenguaje a otro, o cuando un proyecto no tiene guía de estilo.

2. Usar la convención incorrecta para el lenguaje

# ❌ Usando camelCase en Python
def getUserProfile(userId):
    userName = fetchUser(userId)
    return userName

# ✅ Usando snake_case como Python espera
def get_user_profile(user_id):
    user_name = fetch_user(user_id)
    return user_name

Cuando escribes Python con camelCase, cada desarrollador de Python que lea tu código tiene que traducirlo mentalmente. Sigue el estándar del lenguaje — PEP 8 para Python, la guía de estilo de Go para Go, etc.

3. Abreviaciones y acrónimos

// ❌ Manejo inconsistente de acrónimos
const XMLParser = new XmlParser();
const htmlToJSON = convert(HTMLString);

// ✅ Tratar acrónimos como palabras
const xmlParser = new XmlParser();
const htmlToJson = convert(htmlString);

La regla general: trata los acrónimos como palabras regulares en camelCase y PascalCase. Escribe getApiUrl no getAPIURL, y XmlParser no XMLParser.

4. Nombres demasiado cortos o crípticos

// ❌ Demasiado cortos
const n = users.length;
const cb = (err, res) => { /* ... */ };

// ✅ Descriptivos
const userCount = users.length;
const handleResponse = (error, result) => { /* ... */ };

5. Nombres booleanos sin prefijos is/has/can

// ❌ Booleano ambiguo
const active = true;
const admin = false;

// ✅ Intención clara del booleano
const isActive = true;
const isAdmin = false;

Prefijar booleanos con is, has, can o should hace que las sentencias condicionales se lean como inglés: if (isActive) es más claro que if (active).

Conversión Automática Entre Convenciones

Cuando trabajas entre lenguajes — tal vez convirtiendo una respuesta de API de Python a código frontend en JavaScript — convertir manualmente las convenciones de nomenclatura es tedioso y propenso a errores.

Nuestro Convertidor de Casos de Texto maneja esto automáticamente. Pega cualquier identificador y conviértelo entre camelCase, PascalCase, snake_case, kebab-case, SCREAMING_SNAKE_CASE y más con un solo clic.

Configurar la Aplicación de Convenciones

No dependas solo de las revisiones de código para detectar violaciones de nomenclatura. Automatízalo:

ESLint para JavaScript/TypeScript:

{
  "rules": {
    "camelcase": ["error", { "properties": "always" }],
    "@typescript-eslint/naming-convention": [
      "error",
      { "selector": "variable", "format": ["camelCase", "UPPER_CASE"] },
      { "selector": "typeLike", "format": ["PascalCase"] }
    ]
  }
}

Pylint para Python:

[FORMAT]
variable-rgx=[a-z_][a-z0-9_]{0,30}$
function-rgx=[a-z_][a-z0-9_]{0,30}$
class-rgx=[A-Z_][a-zA-Z0-9]+$

Lecturas Adicionales

Las convenciones de nomenclatura son solo una pieza de escribir código limpio y mantenible. Para más buenas prácticas de desarrollo, consulta:

• Mejores Prácticas de Formateo JSON — Estructura tus datos tan limpiamente como nombras tus variables
• Guía Rápida de Regex — Referencia de coincidencia de patrones para validación y procesamiento de texto
• Mejores Prácticas de Formateo SQL — Escribe consultas SQL legibles con mayúsculas adecuadas y alineación

---

¿Listo para convertir convenciones de nomenclatura automáticamente? Prueba nuestro Convertidor de Casos de Texto — pega cualquier identificador y transfórmalo entre camelCase, snake_case, PascalCase, kebab-case y más. Sin registro, sin datos enviados a servidores, completamente gratis.