Est-il une chose plus importante que de bien choisir les noms quand nous codons ? Prendre le temps de choisir de bons noms est un investissement gagnant à tous les coups. En codant, nos yeux passent leur temps à relire des bouts de code qui contiennent des noms de variables, de fonctions, de tables ou de classes. Même si l’on ne s’en rend pas toujours compte, le temps investi se regagne toujours ensuite. Chaque seconde que notre cerveau économise en s’épargnant des micro-réflexions inutiles s’accumule. Après plusieurs heures de codage, nous avons gagné un temps non négligeable et préservé tant que possible notre fatigue.

Comme le rappelle Robert C. Martin dans son livre Clean Code, il est crucial de prêter une attention particulière à la nomination et de la modifier dès que nous identifions une meilleure option.

« Quiconque lit notre code, y compris nous-mêmes, nous en sera reconnaissant. Le nom d’une variable, d’une fonction ou d’une classe devrait éclairer sur sa raison d’être, son rôle et sa manière d’être utilisée. Si un nom nécessite un commentaire pour sa clarification, il ne répond pas à ces exigences.

Regardez cet exemple :

int d; // Temps écoulé en jours.

Le simple nom « d » n’éclaire pas. Il ne suggère ni le temps écoulé ni le fait qu’il s’agisse de jours. Optons plutôt pour des noms qui précisent ce qui est mesuré et dans quelle unité, comme :

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

Avec des noms évocateurs, il devient beaucoup plus simple de saisir et de modifier le code. Prenons cet autre exemple :

public List getThem() {
    List list1 = new ArrayList();
    for (int[] x : theList)
        if (x[0] == 4)
            list1.add(x);
    return list1;
}

Ce code semble simple, mais sa compréhension peut s’avérer complexe car il manque de clarté. La cause réside dans ce qui est non dit, ce qui est sous-entendu. En renommant certaines choses, comme en remplaçant « theList » par « gameBoard » et en introduisant des noms de constantes, le code peut devenir beaucoup plus clair :

public List getFlaggedCells() {
    List flaggedCells = new ArrayList();
    for (int[] cell : gameBoard)
        if (cell[STATUS_VALUE] == FLAGGED)
            flaggedCells.add(cell);
    return flaggedCells;
}

La simplicité du code reste la même, mais sa lisibilité est grandement améliorée. En allant un peu plus loin et en définissant une classe pour les cellules plutôt qu’un tableau, tout devient encore plus clair :

public List getFlaggedCells() {
    List flaggedCells = new ArrayList();
    for (Cell cell : gameBoard)
        if (cell.isFlagged())
            flaggedCells.add(cell);
    return flaggedCells;
}

Grâce à quelques ajustements de noms, tout est devenu plus évident. C’est là le véritable pouvoir d’une nomination appropriée. »

Un autre aspect important est d’utiliser des noms qui ne soient pas des périphrases du code. Par exemple :

calculateData(items) {
    // ... logique pour calculer le total après remise ...
}

Le nom de la fonction n’apporte presque aucune information au lecteur. En regardant les paramètres, on se doute bien que la fonction va traiter les items. Il serait plus intéressant d’avoir un nom qui explique quel est le calcul qui est fait.

calculateTotalAfterDiscount(items) {
    // ... logique pour calculer le total après remise ...
} 

Cette fois tout est parfaitement clair, le lecteur n’aura pas besoin de lire le contenu de la fonction pour comprendre ce qu’elle fait.

Il est toujours bon de se rappeler que le code est écrit une fois, mais lu de nombreuses fois. Investir dans des noms clairs et descriptifs peut économiser beaucoup de temps et de confusion à long terme.