Lors de l'écriture de code, l'un des aspects les plus négligés mais les plus critiques est la dénomination.

Les noms que nous choisissons pour les variables, fonctions, classes et autres entités dans notre code peuvent avoir un impact significatif sur la lisibilité, la maintenabilité et la qualité globale.

Le chapitre 2 de Clean Code explore l'art et la science du choix de noms significatifs, en fournissant un ensemble de directives qui peuvent aider les développeurs à écrire du code à la fois expressif et compréhensible.

Dans cet article de blog, nous explorerons les principaux points à retenir de ce chapitre, en illustrant chaque concept avec des exemples en JavaScript.

?1. Utilisez des noms révélateurs d’intention

Les noms que vous choisissez doivent clairement exprimer l'intention derrière la variable, la fonction ou la classe. Le lecteur doit être capable de comprendre ce que fait le code sans avoir besoin de contexte supplémentaire.

// Bad
let d; 

// Good
let daysUntilDeadline;

Dans le premier exemple, d est vague et ne fournit aucun contexte. La version améliorée, daysUntilDeadline, indique clairement ce que représente la variable.

?2. Évitez la désinformation

Les noms ne doivent pas être trompeurs. Évitez d'utiliser des noms qui pourraient impliquer une signification différente de celle que fait réellement le code.

// Bad
let accountList = new Map();

// Good
let accountsMap = new Map();

Ici, accountList pourrait être trompeur car il suggère une liste (qui est une collection ordonnée), alors que la structure de données réelle est une carte. L'utilisation de AccountsMap est plus précise.

?3. Faites des distinctions significatives

Si vous devez faire la différence entre des variables, des fonctions ou des classes similaires, faites-le de manière à ce que la distinction soit claire et significative.

// Bad
getUserInfo();
getUserData();

// Good
getUserProfile();
getUserSettings();

Dans le premier exemple, getUserInfo et getUserData sont trop similaires et ne traduisent pas clairement leurs différences. Le deuxième exemple clarifie la distinction en nommant les fonctions en fonction de ce qu'elles renvoient.

?4. Utilisez des noms prononçables

Les noms doivent être faciles à lire et à prononcer. Cela rend la discussion du code avec d'autres plus simple.

// Bad
let genymdhms;

// Good
let generationTimestamp;

genymdhms est un nom non prononçable dont il serait difficile de se souvenir ou de discuter. GenerationTimestamp, cependant, est clair et facile à dire.

?5. Utiliser des noms consultables

Dans les bases de code plus volumineuses, il est important d'utiliser des noms faciles à rechercher. Évitez d'utiliser des noms à une seule lettre ou des noms trop abrégés.

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

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

e n’est pas facilement consultable et il ne donne pas ce qu’il représente. emailInputElement est plus descriptif et plus facile à localiser dans la base de code.

?6. Évitez les encodages

Évitez d'inclure des types, des préfixes ou d'autres codages dans vos noms. Que le nom lui-même soit suffisamment descriptif.

// Bad
let phoneString;

// Good
let phoneNumber;

Dans ce cas, phoneString inclut un codage de type inutile (String). phoneNumber est plus simple et plus direct.

?7. Les noms de classe doivent être des noms, les noms de fonctions doivent être des verbes

Les classes représentent des objets ou des concepts, leurs noms doivent donc être des noms. Les fonctions, quant à elles, représentent des actions, leurs noms doivent donc être des verbes.

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

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

Cette distinction aide à comprendre le rôle de chaque élément dans votre code.

?8. Évitez la cartographie mentale

Ne forcez pas le lecteur à traduire un nom en quelque chose de plus significatif. Le nom doit être explicite.

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

// Good
let userCount = 5;

n oblige le lecteur à se souvenir ou à déduire qu'il représente le nombre d'utilisateurs, alors que userCount est immédiatement clair.

Conclusion ⚡

Choisir des noms significatifs est plus qu'une simple question de style : c'est une pratique fondamentale pour écrire du code propre et maintenable.

En suivant les directives décrites dans le chapitre 2 de Clean Code, vous pouvez améliorer la lisibilité de votre code JavaScript et le rendre plus facile à comprendre et à maintenir pour les autres (et vous-même).

N'oubliez pas que l'objectif est d'écrire du code qui communique son objectif et sa logique, réduisant ainsi la charge cognitive du lecteur.

La prochaine fois que vous nommerez une variable, une fonction ou une classe, réfléchissez aux principes d'une dénomination significative et à la manière dont ils peuvent contribuer à un code plus propre et plus efficace.

Joyeux codage !