Al escribir código, uno de los aspectos críticos pero que más se pasa por alto es el nombramiento.

Los nombres que elegimos para variables, funciones, clases y otras entidades en nuestro código pueden afectar significativamente la legibilidad, la mantenibilidad y la calidad general.

El capítulo 2 de Clean Code profundiza en el arte y la ciencia de elegir nombres significativos y proporciona un conjunto de pautas que pueden ayudar a los desarrolladores a escribir código que sea a la vez expresivo y comprensible.

En esta publicación de blog, exploraremos las conclusiones clave de este capítulo, ilustrando cada concepto con ejemplos en JavaScript.

?1. Utilice nombres que revelen la intención

Los nombres que elija deben transmitir claramente la intención detrás de la variable, función o clase. El lector debería poder comprender qué hace el código sin necesidad de contexto adicional.

// Bad
let d; 

// Good
let daysUntilDeadline;

En el primer ejemplo, d es vago y no proporciona contexto. La versión mejorada, daysUntilDeadline, indica claramente lo que representa la variable.

?2. Evite la desinformación

Los nombres no deben ser engañosos. Evite el uso de nombres que puedan implicar un significado diferente al que realmente tiene el código.

// Bad
let accountList = new Map();

// Good
let accountsMap = new Map();

Aquí, accountList podría ser engañoso porque sugiere una lista (que es una colección ordenada), mientras que la estructura de datos real es un mapa. Usar AccountsMap es más preciso.

?3. Haga distinciones significativas

Si necesita diferenciar entre variables, funciones o clases similares, hágalo de manera que la distinción sea clara y significativa.

// Bad
getUserInfo();
getUserData();

// Good
getUserProfile();
getUserSettings();

En el primer ejemplo, getUserInfo y getUserData son demasiado similares y no transmiten claramente sus diferencias. El segundo ejemplo aclara la distinción al nombrar las funciones según lo que devuelven.

?4. Utilice nombres pronunciables

Los nombres deben ser fáciles de leer y pronunciar. Esto hace que discutir el código con otras personas sea más sencillo.

// Bad
let genymdhms;

// Good
let generationTimestamp;

genymdhms es un nombre no pronunciable que sería difícil de recordar o discutir. GenerationTimestamp, sin embargo, es claro y fácil de decir.

?5. Utilice nombres que se puedan buscar

En bases de código más grandes, es importante utilizar nombres que sean fáciles de buscar. Evite el uso de nombres de una sola letra o nombres demasiado abreviados.

// Bad
let e = document.getElementById('email');

// Good
let emailInputElement = document.getElementById('email');

e no se puede buscar fácilmente y no transmite lo que representa. emailInputElement es más descriptivo y más fácil de localizar en el código base.

?6. Evite codificaciones

Evite incluir tipos, prefijos u otras codificaciones en sus nombres. Deje que el nombre en sí sea lo suficientemente descriptivo.

// Bad
let phoneString;

// Good
let phoneNumber;

En este caso, phoneString incluye una codificación de tipo innecesaria (String). phoneNumber es más simple y directo.

?7. Los nombres de las clases deben ser sustantivos, los nombres de las funciones deben ser verbos

Las clases representan objetos o conceptos, por lo que sus nombres deben ser sustantivos. Las funciones, por otro lado, representan acciones, por lo que sus nombres deben ser verbos.

// Class names (Nouns)
class UserAccount {}
class ShoppingCart {}

// Function names (Verbs)
function calculateTotal() {}
function sendEmail() {}

Esta distinción ayuda a comprender el papel de cada elemento en su código.

?8. Evite el mapeo mental

No fuerces al lector a traducir un nombre a algo más significativo. El nombre debe explicarse por sí mismo.

// Bad
let n = 5; // Number of users

// Good
let userCount = 5;

n requiere que el lector recuerde o deduzca que representa el número de usuarios, mientras que userCount queda inmediatamente claro.

Conclusión ⚡

Elegir nombres significativos es más que una simple cuestión de estilo: es una práctica fundamental para escribir código limpio y fácil de mantener.

Si sigue las pautas descritas en el Capítulo 2 de Código limpio, puede mejorar la legibilidad de su código JavaScript y facilitar su comprensión y mantenimiento para otros (y para usted mismo).

Recuerde, el objetivo es escribir código que comunique su propósito y lógica, reduciendo la carga cognitiva del lector.

La próxima vez que nombre una variable, función o clase, considere los principios de la denominación significativa y cómo pueden contribuir a un código más limpio y eficaz.

¡Feliz codificación!