Exercice - Utiliser des espaces blancs pour faciliter la lecture de votre code

10 minutes

Les concepteurs de documents et de sites web savent que le fait de placer trop d’informations dans un espace réduit décourage les personnes qui les voient. Ils utilisent donc des espaces blancs ou négatifs de façon stratégique pour décomposer les informations afin d’optimiser la capacité de la personne qui les voit à consommer le message principal de leur travail.

Les développeurs peuvent utiliser une stratégie similaire lors de l’écriture de code dans un éditeur. En utilisant des espaces blancs pour indiquer une signification, les développeurs peuvent accroître la clarté de l’intention de leur code.

Qu’est-ce qu’un espace blanc ?

Le terme « espace blanc » fait référence aux espaces que vous obtenez avec la touche space bar, aux tabulations que vous obtenez avec la touche tab et aux nouvelles lignes que vous obtenez avec la touche enter.

Le compilateur C# ignore les espaces blancs. Pour comprendre comment les espaces blancs sont ignorés et comment maximiser la clarté en utilisant des espaces blancs, effectuez l’exercice suivant.

Ajouter du code pour illustrer la façon dont les espaces blancs sont ignorés par le compilateur C#

Assurez-vous d’avoir un fichier Program.cs vide ouvert dans Visual Studio Code.

Si nécessaire, ouvrez Visual Studio Code, puis effectuez les étapes suivantes pour préparer un fichier Program.cs dans l’Éditeur :
1. Dans le menu Fichier, sélectionnez Ouvrir le dossier.
2. Utilisez la boîte de dialogue Ouvrir le dossier pour accéder au dossier CsharpProjects et l’ouvrir.
3. Dans la vue Explorateur de Visual Studio Code, sélectionnez Program.cs.
4. Dans le menu Sélection de Visual Studio Code, sélectionnez Tout sélectionner, puis appuyez sur la touche Suppr.

Entrez le code suivant :

// Example 1:
Console
.
WriteLine
(
"Hello Example 1!"
)
;

// Example 2:
string firstWord="Hello";string lastWord="Example 2";Console.WriteLine(firstWord+" "+lastWord+"!");

Dans le menu Fichier de Visual Studio Code, sélectionnez Enregistrer.
Dans l’affichage EXPLORATEUR, pour ouvrir un terminal à l’emplacement de votre dossier TestProject, cliquez avec le bouton droit sur TestProject, puis sélectionnez Ouvrir dans le terminal intégré.
À l’invite de commandes Terminal, tapez dotnet run, puis appuyez sur Entrée.

Vous devez normalement voir la sortie suivante.
```
Hello Example 1!
Hello Example 2!
```
À partir de ce résultat, prenez le temps de réfléchir à la façon dont vous devez utiliser les espaces blancs dans votre code.

Ces deux exemples de code illustrent deux concepts essentiels :
- Les espaces blancs ne comptent pas pour le compilateur. Cependant...
- Les espaces blancs, quand ils sont utilisés de façon appropriée, peuvent accroître votre capacité à lire et à comprendre le code.
Vous allez probablement écrire votre code une seule fois, mais vous devrez le lire plusieurs fois. Par conséquent, vous devez vous concentrer sur la lisibilité du code que vous écrivez. Au fil du temps, vous allez acquérir une meilleure perception des endroits où il convient d’utiliser des espaces blancs, et sur la façon de les représenter, par exemple avec le caractère d’espacement, les tabulations et les nouvelles lignes.

Voici déjà quelques règles de base :
- Chaque commande complète (une instruction) doit figurer sur une ligne distincte.
- Si une même ligne de code devient trop longue, vous pouvez la décomposer. Cependant, vous devez éviter de diviser arbitrairement une même instruction en plusieurs lignes, sauf si vous avez une bonne raison de le faire.
- Utilisez un espace à gauche et à droite de l’opérateur d’assignation.
Remplacez votre code existant par le code ci-dessous :
```
Random dice = new Random();
int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);
int total = roll1 + roll2 + roll3;
Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");
if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3)) {
    if ((roll1 == roll2) && (roll2 == roll3)) {
        Console.WriteLine("You rolled triples!  +6 bonus to total!");
        total += 6; 
    } else {
        Console.WriteLine("You rolled doubles!  +2 bonus to total!");
        total += 2;
    }
}
```
Notez que ce code n’inclut pas beaucoup d’espaces blancs. Ce code sera utilisé pour illustrer une approche permettant d’ajouter des espaces blancs à vos applications. Des espaces blancs efficaces doivent faciliter la compréhension de ce que fait votre code.

Notes

Le code utilise la classe Random pour aider à développer un jeu de dés simulé, où la valeur totale de trois lancers est utilisée pour évaluer un score « gagnant ». Le code accorde des points supplémentaires pour les lancers aboutissant à des doubles ou des triples. Vous n’avez pas besoin de comprendre entièrement ce code pour voir l’avantage d’inclure des espaces blancs.
Prenez une minute pour réfléchir à la façon dont vous utiliseriez les espaces blancs pour améliorer la lisibilité de ce code.

Vous pouvez noter deux caractéristiques de ce code :
- Aucun espace blanc vertical n’est présent dans cet exemple de code. En d’autres termes, il n’y a pas de lignes vides séparant les lignes de code. Celles-ci sont toutes placées ensemble dans un même code de densité élevée.
- Les blocs de code tels qu’ils sont définis par les symboles d’accolades ouvrantes et fermantes { } sont placés ensemble, ce qui rend leurs limites difficiles à distinguer visuellement.
En règle générale, pour améliorer la lisibilité, vous introduisez une ligne vide entre deux, trois ou quatre lignes de code qui effectuent des opérations similaires ou liées.

L’expressivité de la disposition de votre code avec des espaces blancs verticaux est subjective. Il est possible que deux développeurs ne s’accordent pas sur ce qui est le plus lisible ou sur les endroits où ajouter des espaces blancs. Faites ce que vous pensez être le mieux.
Pour ajouter des espaces blancs verticaux qui améliorent la lisibilité, mettez à jour votre code comme suit :
```
Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;
Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3)) {
    if ((roll1 == roll2) && (roll2 == roll3)) {
        Console.WriteLine("You rolled triples!  +6 bonus to total!");
        total += 6; 
    } else {
        Console.WriteLine("You rolled doubles!  +2 bonus to total!");
        total += 2;
    }
}
```
Votre première ligne d’espaces blancs est utilisée pour séparer la déclaration de la variable dice des lignes de code utilisées pour affecter des valeurs à vos variables de lancer. Cette séparation permet de mieux voir comment dice est utilisé dans votre code.

Votre ligne suivante d’espaces blancs sépare la déclaration de vos variables de lancer de la déclaration de total. Le regroupement de la déclaration de vos trois variables de lancer est utile à double titre. Tout d’abord, il crée un groupe de lignes de code qui comprend des variables liées. Deuxièmement, les noms des variables sont similaires et la déclaration suit le même modèle. Ainsi, leur regroupement attire votre attention sur les similarités et vous aide à exposer les différences.

Enfin, votre troisième ligne d’espaces blancs sépare un autre groupe d’instructions liées de vos instructions if imbriquées. Le groupe d’instructions qui inclut la déclaration de total et la méthode Console.WriteLine() est lié par objectif plutôt que par apparence. Votre code se concentre sur la valeur totale obtenue par les trois dés et sur le fait que le lancer comportait ou non des doubles ou des triples. Ces lignes sont liées, car vous devez calculer total et indiquer les résultats du lancer à l’utilisateur.

Certains développeurs pourraient considérer que vous devez ajouter une ligne vide entre la déclaration de total et Console.WriteLine(). Là encore, le choix des espaces blancs vous incombe. Vous devez déterminer ce qui est le plus lisible pour vous et utiliser ce style de façon cohérente.

Il ne vous reste plus que l’instruction if. Vous pouvez l’examiner maintenant.

Concentrez-vous maintenant sur les lignes de code sous le mot clé if et modifiez votre code comme suit :

Random dice = new Random();

int roll1 = dice.Next(1, 7);
int roll2 = dice.Next(1, 7);
int roll3 = dice.Next(1, 7);

int total = roll1 + roll2 + roll3;
Console.WriteLine($"Dice roll: {roll1} + {roll2} + {roll3} = {total}");

if ((roll1 == roll2) || (roll2 == roll3) || (roll1 == roll3)) 
{
    if ((roll1 == roll2) && (roll2 == roll3)) 
    {
        Console.WriteLine("You rolled triples!  +6 bonus to total!");
        total += 6; 
    } 
    else 
    {
        Console.WriteLine("You rolled doubles!  +2 bonus to total!");
        total += 2;
    }
}

Notez que vous avez déplacé les accolades ouvrantes et fermantes sur leur propre ligne pour améliorer l’espacement.

Les symboles { et } créent des blocs de code. De nombreuses constructions C# nécessitent des blocs de code. Ces symboles doivent être placés sur une ligne distincte, pour que leurs limites soient clairement visibles et lisibles.

De plus, il est important d’utiliser la touche tab pour aligner les symboles de bloc de code sous le mot clé auquel ils appartiennent. Par exemple, regardez la ligne de code qui commence par le mot clé if. Sous cette ligne, vous voyez le symbole {. Cet alignement permet de comprendre facilement que { « appartient à » l’instruction if. Le dernier symbole } est également aligné sur l’instruction if. La combinaison de l’alignement et de la mise en retrait permet de comprendre facilement où commence et se termine le bloc de code.

Les lignes de code de ce bloc de code sont indentées, indiquant qu’elles « appartiennent » à ce bloc de code.

Vous suivez un modèle similaire avec l’instruction if intérieure et l’instruction else, et le code à l’intérieur de ces blocs de code.

Les avis sont partagés sur ces conseils de style pour inclure des espaces blancs. Toutefois, vous devez envisager d’utiliser ces conseils comme point de départ lors de l’écriture du code. À l’avenir, vous pourrez décider en connaissance de cause de déroger à ces conseils.

Récapitulatif

Voici les principaux points à retenir de cet exercice :

Utilisez des espaces blancs de façon judicieuse pour améliorer la lisibilité de votre code.
Utilisez des sauts de ligne pour créer des lignes vides afin de séparer les « phrases » de code. Une « phrase » comprend des lignes de code similaires ou qui fonctionnent ensemble.
Utilisez des sauts de ligne pour séparer les symboles de bloc de code de façon à ce qu’ils se trouvent sur leur propre ligne de code.
Utilisez la touche tab pour aligner un bloc de code avec le mot clé auquel il est associé.
Indentez le code qui est à l’intérieur d’un bloc de code pour montrer son appartenance à ce bloc.

Commentaires

Est-ce que cette page vous a été utile?