Nombres con sentido en código limpio (Clean Code)
En el software los nombres están en todas partes: variables, funciones, clases, ficheros, carpetas. Los escribimos una vez y los leemos cientos. Por eso merece la pena ponerlos bien.
Un nombre es como la etiqueta de un tarro en la despensa. Si pone «azúcar», no tienes que abrirlo y probarlo. Si pone «cosas» o no pone nada, te toca abrirlo cada vez. Y si pone «sal» pero dentro hay azúcar, el problema es mayor: te fías de la etiqueta y te equivocas.
Este artículo resume el capítulo «Meaningful Names» (en español, «nombres con sentido» o «nombres significativos»; capítulo 2) de Clean Code, de Robert C. Martin, en su primera edición de 2008. En la segunda edición, de 2025, el tema pasa a ser el capítulo 4. Los ejemplos están en JavaScript y se han ejecutado con Node 24.
Usa nombres que revelen la intención
Elegir un buen nombre lleva un rato, pero ahorra mucho más tiempo del que cuesta. Y no es para siempre: cuando encuentres uno mejor, cámbialo.
El nombre de una variable, función o clase debe responder a tres preguntas: ¿por qué existe? ¿Qué hace? ¿Cómo se usa? Si necesita un comentario para responderlas, el nombre no revela su intención.
let d; // número de días de vida
let diasDeVida;
El nombre se explica solo
- Lees la línea y sabes qué guarda
- No hace falta comentario
- Cambiar el código da menos miedo
El nombre obliga a adivinar
- Tienes que buscar dónde se usa
- Dependes de un comentario que puede quedarse viejo
- Cada cambio empieza con una investigación
Evita la desinformación
Un nombre desinforma cuando deja una pista falsa: sugiere algo distinto de lo que el código hace. Es la etiqueta de «sal» en el tarro de azúcar.
Abreviaturas ambiguas. hp puede parecer una buena abreviatura de «hipotenusa», pero para otra persona puede ser «puntos de vida», «caballos de potencia» o el fabricante HP. Si hay más de una lectura posible, escribe la palabra entera: hipotenusa.
El tipo en el nombre. Poner el tipo de dato en el nombre no aporta nada si no hay otra posibilidad, y desinforma en cuanto el tipo cambia:
const nombreString = 'Ana'; // ¿puede un nombre ser otra cosa que un texto?
const nombre = 'Ana';
Si mañana el dato deja de ser un texto, tendrías que cambiar el nombre en todas partes o dejar una mentira en el código. Lo mismo pasa con listaDeClientes cuando en realidad no es una lista: llámalo clientes.
Nombres casi iguales. ¿Cuánto tardas en ver la diferencia entre estas dos?
let numeroDeVueltasRealesPorMinuto;
let numeroDeVueltasEsperadasPorMinuto;
Son largas y solo cambia una palabra en medio. Es fácil confundirlas al leer y al elegir una en el autocompletado del editor. Busca nombres que se distingan a primera vista, por ejemplo con la diferencia al principio: rpmReales y rpmEsperadas.
La l minúscula y la O mayúscula. En muchas fuentes se parecen demasiado al 1 y al 0:
let l = 1;
let O = 0;
if (O == l) {
l = O;
} else {
O = 1;
}
¿A que cuesta leerlo? La solución no es cambiar la fuente: es no usarlas como nombres.
Haz distinciones con sentido
El ordenador no se confunde con a1 y a2: son nombres distintos. Pero tú sí. No desinforman, simplemente no informan.
function copiar(a1, a2) {
a1 = a2;
}
Esta función, además, no copia nada. En JavaScript, a1 = a2 solo cambia a qué apunta el parámetro dentro de la función; el array original queda igual. Con nombres claros y un bucle que copia de verdad:
function copiarCaracteres(origen, destino) {
for (let i = 0; i < origen.length; i++) {
destino[i] = origen[i];
}
}
const destino = [];
copiarCaracteres(['h', 'o', 'l', 'a'], destino);
console.log(destino); // [ 'h', 'o', 'l', 'a' ]
Ahora se lee qué va a dónde, sin mirar cómo se llama la función.
Añadir palabras está bien si añaden significado. El problema son las palabras de relleno: las que se ponen solo para que dos nombres sean distintos. ¿Qué diferencia hay entre estas parejas?
let casa;
let laCasa;
let dinero;
let cantidadDeDinero;
let usuario;
let infoUsuario;
let mensaje;
let elMensaje;
Sin una convención que lo explique, nadie lo sabe. info, datos, el, la o cantidadDe no dicen nada nuevo. Si dos cosas son distintas, el nombre debe decir en qué se diferencian, de forma que quien lo lea lo vea sin pensar.
Usa nombres que se puedan pronunciar
let nopapsap; // nombre, primer apellido, segundo apellido
¿Cómo le dices a un compañero que «a nopapsap le pasa algo»? Programar es también hablar del código con otras personas. Si un nombre no se puede decir en voz alta, la conversación se vuelve torpe.
let nombreYApellidos;
Usa nombres que se puedan buscar
for (let i = 0; i < 5; i++) {
// ...
}
Buscar «5» en un proyecto devuelve cientos de resultados, y ninguno te dice qué significa ese 5. Con un nombre, la búsqueda es directa y el código se explica solo:
const DIAS_LABORABLES_POR_SEMANA = 5;
for (let dia = 0; dia < DIAS_LABORABLES_POR_SEMANA; dia++) {
// ...
}
Un valor así, sin nombre, se llama número mágico. Lo explico con más detalle en Números mágicos en programación.
La regla tiene un matiz: la longitud del nombre debe ir con el tamaño de su ámbito. Una i como contador de un bucle de tres líneas se entiende. Una e que vive en todo un fichero, no.
Evita las codificaciones
Ya trabajamos con bastantes códigos (lenguajes, formatos, protocolos) como para añadir los internos de cada equipo. Los nombres codificados son difíciles de pronunciar y fáciles de escribir mal.
Notación húngara
La notación húngara consiste en empezar el nombre de una variable con una o varias letras que indican su tipo de dato. Por ejemplo:
| Prefijo | Tipo |
|---|---|
c |
char |
by |
BYTE (unsigned char) |
n |
short |
i |
int |
Así, iEdad sería un entero y cInicial un carácter. Tenía sentido cuando los compiladores no comprobaban los tipos. Hoy el lenguaje y el editor te dicen el tipo de cada variable, así que el prefijo solo estorba al leer y puede mentir si el tipo cambia.
Prefijos de atributos
Pasa lo mismo con prefijos como m_ para los atributos de una clase (m_nombre). Si las clases y funciones son pequeñas, no hacen falta, y el editor ya los distingue con colores.
Interfaces e implementaciones
En algunos lenguajes es costumbre poner una I delante de las interfaces: IFabricaDeFormas. Martin prefiere dejar la interfaz sin adornos (FabricaDeFormas), porque es lo que usa el resto del código, y marcar, si hace falta, la implementación.
Evita las asignaciones mentales
Una asignación mental es tener que traducir de cabeza un nombre a lo que significa: «la j es el nombre, la z es el apellido». Funciona mientras te acuerdas; en cuanto vuelves al código una semana después, toca descifrarlo otra vez.
const nombres = ['Pepe', 'Juan', 'Santiago'];
const apellidos = ['Pérez', 'Rodríguez', 'Santana'];
for (let i = 0; i < nombres.length; i++) {
const j = nombres[i];
const z = apellidos[i];
console.log(j, z);
}
Con nombres con sentido no hay nada que traducir:
function nombresCompletos(nombres, apellidos) {
return nombres.map((nombre, posicion) => `${nombre} ${apellidos[posicion]}`);
}
console.log(nombresCompletos(nombres, apellidos));
// [ 'Pepe Pérez', 'Juan Rodríguez', 'Santiago Santana' ]
Martin lo plantea como la diferencia entre un programador listo, que presume de recordar que z es el apellido, y uno profesional, que sabe que lo que cuenta es la claridad.
Nombres de clases y de métodos
- Clases: sustantivos.
Cliente,Factura,DireccionPostal. Evita palabras vagas comoGestor,Procesador,DatosoInfo, que caben en cualquier sitio y no dicen nada. - Métodos: verbos.
guardar,enviarFactura,borrarPagina. Para leer, cambiar o preguntar por un valor, lo habitual es empezar porget,setois(en español, por ejemplo,obtener,cambiaroes/esta).
Sin chistes ni juegos de palabras
No te hagas el gracioso. Un nombre ingenioso solo lo entiende quien conoce la broma. acabarConTodo() puede hacer gracia hoy; borrarTodosLosPedidos() se entiende siempre.
Una palabra por concepto. Elige una palabra para cada idea y mantenla en todo el código. Si en una clase se dice obtener, en otra recuperar y en otra traer para lo mismo, el lector se preguntará en qué se diferencian. Igual con Controlador, Gestor y Driver.
No uses la misma palabra para dos ideas. Es el error contrario. Si anadir suma dos valores en unas clases y mete un elemento en una lista en otras, son dos conceptos con el mismo nombre. Para el segundo, mejor insertar o agregarAlFinal.
Nombres del problema y de la solución
Quien lea tu código es programador. Por eso puedes usar nombres técnicos conocidos: ColaDePedidos, cacheDeUsuarios o el nombre de un patrón de diseño. Cuando no haya un término técnico, usa el del negocio: Poliza, Siniestro, Franquicia. Así, si alguien no lo entiende, sabe a quién preguntar.
Añade contexto con sentido
¿A quién pertenece la dirección en este código?
let nombrePersona;
let apellidoPersona;
let nombreEmpresa;
let direccion;
Un prefijo o sufijo lo arregla a medias:
let direccionEmpresa;
Mejor todavía es agrupar los datos en clases, porque el contexto lo da la propia estructura:
class Direccion {
constructor(calle, ciudad, codigoPostal) {
this.calle = calle;
this.ciudad = ciudad;
this.codigoPostal = codigoPostal;
}
}
class Empresa {
constructor(nombre, direccion) {
this.nombre = nombre;
this.direccion = direccion;
}
}
const lumbre = new Empresa('Lumbre S. A.', new Direccion('C/ Violeta, 90', 'Las Palmas de Gran Canaria', '35001'));
console.log(lumbre.direccion.calle); // C/ Violeta, 90
En CSS, la convención BEM aplica la misma idea: tarjeta__titulo dice a qué bloque pertenece.
Sin contexto de más
El exceso también molesta. Si tu aplicación se llama «Lumbre», no hace falta que todas las clases empiecen por Lumbre: LumbreCliente, LumbreFactura… Al escribir Lum en el editor, el autocompletado te ofrece cientos de opciones iguales. Los nombres cortos son mejores que los largos siempre que sean claros.
El código debe leerse como un libro de instrucciones sin acertijos.
Nombres con sentido cuando programas con IA
Esto ya no es criterio de Martin, sino del enfoque IA Limpia: los nombres son también lo que lee un agente de IA cuando trabaja en tu código.
- Un nombre vago obliga al agente a adivinar, igual que a una persona. Ante una función
procesar(datos), tiene que deducir qué hace a partir de cómo se usa, y puede deducir mal. - Si en tu código conviven
obtener,traeryrecuperar, el agente no tiene forma de saber cuál es el bueno, y lo normal es que siga mezclándolos. - Pídele propuestas de nombres, pero decide tú. Sugerir alternativas es algo que hace bien; elegir la que encaja con el negocio y con el resto del código es tu trabajo.
- Renombra con la herramienta del editor, no a mano ni con buscar y reemplazar. En IntelliJ IDEA es Shift + F6 (⇧ + F6 en Mac) y cambia todas las referencias a la vez. Después, pasa los tests. Tienes más atajos en Atajos de teclado de IntelliJ IDEA.
Tu lista de comprobación
Antes de dar por bueno un nombre, repásalo:
- ¿Se entiende sin comentario qué es, para qué sirve y cómo se usa?
- ¿Puede leerse de otra forma o mentir si el código cambia?
- ¿Se distingue a primera vista de los nombres parecidos?
- ¿Puedes decirlo en voz alta y encontrarlo con una búsqueda?
- ¿Usa la misma palabra que el resto del código para la misma idea?
- ¿Tiene el contexto justo, ni más ni menos?
Los nombres son la base de todo lo demás. El siguiente paso de la serie es aplicar lo mismo a las funciones: Funciones en código limpio.
Fuentes
- Robert C. Martin, Clean Code: A Handbook of Agile Software Craftsmanship, primera edición (Prentice Hall, 2008), capítulo 2, «Meaningful Names». Los títulos de las secciones se han comprobado en el índice de las páginas de muestra de la editorial. El texto del capítulo no está en esa muestra: el artículo explica sus ideas con palabras propias y no contiene citas literales del libro.
- La segunda edición (Addison-Wesley, 30 de septiembre de 2025), donde el tema es el capítulo 4, «Meaningful Names»: ficha e índice en Pearson.
- Los ejemplos de
copiarCaracteres,nombresCompletos,DIAS_LABORABLES_POR_SEMANAy las clasesDireccionyEmpresase han ejecutado con Node 24.21.0 y comprobado con tests denode:test, en noviembre de 2026.