En el código, en todas partes se necesitan nombres. Como programadores, tenemos que nombrar clases, variables, funciones, parámetros, espacios de nombres, etc. Aquí hay 20 consejos que te ayudarán a mejorar tu capacidad de nombrar.

1. Usa nombres que expresen la intención

Los nombres deben decirnos qué hace, por qué existe y cómo funciona. Elegir nombres que expresen la intención nos ayudará a comprender mejor el código.

int d; // elapsed time in days

int elapsedTimeInDays;
int daysSinceCreation;
int daysSinceModification;
int fileAgeInDays;

En el fragmento anterior, solo podemos saber a qué se refiere la variable d a partir del comentario. Por lo tanto, quien lea el código tiene que buscar sus instancias para obtener pistas sobre su significado. Así que, si nombramos bien esa variable, quien lea el código podrá saber al instante su significado.

2. No temas dedicar tiempo a elegir nombres

Deberías probar varios nombres diferentes hasta que describan suficientemente su significado; no tengas miedo de dedicarles tiempo. Quien lea tu código más tarde (incluido tú mismo) se beneficiará de ello. Además, un nombre descriptivo incluso puede ayudarte a aclarar mentalmente el diseño del módulo. Un buen nombre ciertamente requiere tiempo, pero a la larga, los beneficios superan los costos.

3. Refactoriza los nombres

Si más adelante, durante el desarrollo, se te ocurre un mejor nombre, no dudes en cambiarlo de inmediato. Los IDE actuales hacen que refactorizar nombres sea extremadamente fácil.

4. Evita palabras que distraigan en los nombres

Por ejemplo,Manager、Processor、Data、Infoy sinónimos de "no sé cómo se llama esto" son palabras que distraen. Si necesitas usar esas palabras distractoras, entonces tu nombre probablemente sea demasiado redundante.

5. Cuidado con las clases/funciones difíciles de nombrar

Una clase o función difícil de nombrar muy probablemente sea un mal olor en el código. Esto indica:

• El código hace demasiado.
• El código no hace lo suficiente.
• Aún no entiendes el problema con suficiente profundidad y necesitas obtener más información.

6. Nombres de clases

Las clases deben tener un nombre que sea un sustantivo o una frase sustantiva, comoCustomer、WikiPage、AccountyAddressParser. La clase base heredada debe tener un nombre corto e impactante. El nombre de las subclases debería ser más largo, describiendo con adjetivos en qué se diferencian de su clase padre, comoSavingsAccountderivada de Account.

7. Nombres de variables

Los nombres de variables también deben ser sustantivos. En su mayoría derivan de la clase a la que apuntan. Las variables booleanas deben escribirse en forma de predicado, comoisEmptyyisTerminated, de modo que sean fáciles de entender en una sentencia if.

8. Nombres de métodos

Los nombres de métodos deben ser un verbo o frase verbal, comopostPayment()、deletePage()ysave(). Los accesores y mutadores deben tener los prefijos get y set respectivamente. Los métodos que devuelven booleanos deben tener el prefijo 'is', como isPostable(), para que sean fáciles de entender en una sentencia if.

9. Tamaño del alcance y longitud del nombre de variable

La longitud del nombre de una variable debe coincidir con el tamaño de su alcance. Si el alcance de la variable es corto, la longitud del nombre también debería ser corta. Por el contrario, el nombre debería ser más largo y más descriptivo.

10. Tamaño del alcance y longitud del nombre de métodos/clases

Para métodos y clases, la longitud del nombre debería ser inversamente proporcional a su alcance. Para los métodos públicos, los nombres más cortos son mejores, ya que se llaman muchas veces. Los métodos privados solo se llaman dentro del alcance de la clase, por lo que un nombre más largo puede servir como documentación. La excepción a esta regla son los nombres de las clases derivadas. Cuanto más derivada sea la clase, más adjetivos se añaden delante de la clase base y más largo es el nombre.

11. Un concepto, una palabra

Elige una palabra para un concepto abstracto y no la cambies. Por ejemplo, como métodos equivalentes en diferentes clases,get()、fetch()yretrieve()puede resultar confuso. Mantener un vocabulario consistente es una herramienta importante para que los programadores manejen el código.

12. No uses la misma palabra para dos conceptos diferentes

Si sigues el punto 11 —el principio de un concepto, una palabra—, evitarás muchas clases con el mismo nombre de método. No hay problema mientras las listas de parámetros y los valores de retorno de los métodos sean semánticamente equivalentes. El problema solo aparece cuando usas la misma palabra para dos conceptos diferentes.

Por ejemplo, podemos usar en varias clasesadd()un método que crea un nuevo valor al añadir o concatenar dos valores existentes. Si más tarde necesitamos introducir un método add en la clase para añadir parámetros a una colección, esto causará problemas por la diferencia de semántica. Lo mejor sería renombrar ese nuevo método como insert().

13. Usa nombres del dominio de la solución

15. Añade contexto significativo

La mayoría de los nombres no tienen significado por sí solos y necesitan estar en un contexto (clase/función/espacio de nombres) para que quien lea el código entienda a qué se refieren. En algunos casos, puede ser necesario añadir un prefijo al nombre para complementar el contexto. Por ejemplo, supongamos que tenemos algunas variables que representan una dirección:firstName、lastName、street、houseNumber、city、stateyzip. Si solo miramos la variable state, es difícil deducir qué significa. Una buena solución es encapsular estas variables en una clase Address.

16. No añadas contexto sin motivo

Mientras el significado sea claro, los nombres más cortos suelen ser mejores que los largos, así que no añadas contexto innecesariamente. No se deben añadir prefijos con información superflua que pueda deducirse de la clase, el paquete o el espacio de nombres.

17. Evita la codificación

Dado el poder de los IDE actuales, ya no necesitamos codificar información de tipo y alcance en los nombres de variables y clases. Esto incluye no tener que añadir I a las interfaces, porque los usuarios del código no necesitan saber que sus clases se están pasando a una interfaz. Por lo tanto, si insistes en usar codificación, es mejor codificar la implementación y no la interfaz.

18. Evita información engañosa

No des información errónea, porque eso engañará a quienes lean el código. Si nombras accountList a una variable que en realidad es un array, será fácil llegar a una conclusión equivocada.

19. Usa nombres impronunciables

La programación es una actividad social; usar esos nombres impronunciables solo dificulta nuestras discusiones.

20. Usa nombres fáciles de buscar

Usar nombres cortos y genéricos dificulta la búsqueda de cosas en el código base. Esto afecta en gran medida a nuestra capacidad para manipular el código y refactorizar.

Finalmente, si tienes opiniones diferentes, no dudes en compartirlas.

Fuente: http://www.codeceo.com/article/20-naming-tips-programmer-know.html