Quelques raccourcis :
Ce site collige un résumé des principales règles programmatiques appliquées dans le cours 420-201-RE.
L'indentation est un terme utilisé pour dénoter les règles de présentation générale du code. L'idée de base est simple : un programme est un texte complexe, dont il importe de faciliter la lecture et la compréhension par des humains (y compris vous-mêmes). Pour cette raison, il faut que la forme visuelle du code soit représentative de sa structure.
Pour le moment, gardez en tête que :
Quelques exemples d'indentations correctes et incorrectes dans ce cours suivent :
| Correct | Incorrect[1] | Incorrect |
|---|---|---|
namespace Correct
{
class Program
{
static void Main(String [] args)
{
int valeur;
}
}
}
|
namespace Incorrect0
{
class Program
{
static void Main(String [] args)
{
int valeur;
}
}
}
|
namespace Incorrect1
{
class Program
{
static void Main(String [] args)
{
int valeur;
}
}
}
|
| Incorrect | Incorrect | Incorrect |
namespace Incorrect2
{
class Program
{
static void Main(String [] args)
{
int valeur;
}
}
}
|
namespace Incorrect3 {
class Program {
static void Main(String [] args) {
int valeur; }
}
}
|
namespace Incorrect4 {
class Program {
static void Main(String [] args)
{ int valeur;
}
}
}
|
Remarquez les caractéristiques de l'exemple qualifié de correct selon les règles en vigueur dans ce cours :
Une discussion plus détaillée de l'indentation est disponible sur ../../../Sujets/Developpement/Pratique-programmation.html#indentation. Notez toutefois que, peu importe le cours que vous suivez, les règles de votre cours priment sur les recommandations générales décrites sur la page vers laquelle vous mène ce lien.
Pour que l'indentation fasse son travail, il est important que vous présentiez le code à l'aide d'une police non-proportionnelle. Ceci est vrai autant pour le pseudocode que pour le code dans un langage de programmation tel que C#.
| Police proportionnelle | Police non-proportionnelle |
Une police proportionnelle est telle que certains caractères (le « W » majuscule, par exemple) occupent un plus grand espace horizontal que d'autres (le « i » minuscule, disons). Ces polices sont idéales pour des textes de type littéraire. |
Une police est non-proportionnelle si tous les caractères occupent le même espace horizontal. Ces polices sont meilleures pour le code car elles permettent de mettre en relief l'indentation. |
Voir ../../../Sujets/TrucsScouts/Police-pour-code.html pour plus de détails.
Dans un programme C#, selon les normes de ce cours, les consignes suivantes s'appliquent. Certaines de ces consignes s'appliquent à tous vos cours (p. ex. : utiliser des noms significatifs), d'autres peuvent varier selon les cours ou les langages (p. ex. : la permission d'utiliser des accents dans les noms de variables n'est raisonnable que si le langage le permet).
| Consigne | Exemples |
|
On ne doit utiliser des noms EN MAJUSCULES SEULEMENT que pour les constantes |
La constante symbolique π s'exprime en majuscules, donc PI, pas Pi ou pi : |
|
On doit utiliser en tout temps des noms significatifs |
Une variable servant à contenir la valeur du rayon d'un cylindre se nommera rayon, pas R ou r ou xyz123 |
|
Les accents sont utilisés dans le code |
On écrira nbÉtudiants, pas nbEtudiants |
|
Dans un nom de variable, le premier mot débute par une minuscule et les autres mots débutent par une majuscule |
On écrira nbCasExplorés, par nbcasexplorés |
|
On n'utilisera pas de caractères de soulignement dans les noms de variables, préférant marquer le début d'un mot autre que le tout premier par une majuscule |
Pour une variable locale, on écrira nbÉtudiants, pas nb_étudiants |
|
Dans le cas des constantes, écrites en majuscules, séparer les mots par un soulignement est de mise |
Pour une constante, on écrira NB_ÉTUDIANTS |
|
Un nom de classe débute par une majuscule |
On aura une classe Carré plutôt qu'une classe carré |
|
Un nom de méthode débute par une majuscule |
On aura une méthode CalculerSurface() plutôt qu'une méthode calculerSurface() |
|
Un nom de propriété débute par une majuscule |
On aura une propriété Surface plutôt qu'une propriété surface |
|
Un nom d'attribut s'écrit comme un nom de variable |
On aura un attribut rayon plutôt qu'un attribut Rayon |
Une discussion plus détaillée de questions de nomenclature est disponible sur ../../../Sujets/Developpement/Pratique-programmation.html#nomenclature. Notez toutefois que, peu importe le cours que vous suivez, les règles de votre cours priment sur les recommandations générales décrites sur la page vers laquelle vous mène ce lien.
Dans un programme C#, selon les normes de ce cours :
| Consigne | Correct | Vilain |
|---|---|---|
|
On ne met jamais plus d'une instruction par ligne. |
//
// Sphère.cs
// Auteur : Gaëtan Tromblon
// Date : 22 août 2013
// Rôle: calculer et afficher le volume d'une sphère
// étant donné son rayon
//
const float PI = 3.14159f;
float rayon,
volume;
rayon = float.Parse(Console.ReadLine());
volume = 4.0f/3.0f * PI * rayon; // calcul du volume d'une sphère
Console.WriteLine("Volume: {0}", volume);
|
const float PI = 3.14159f;
float rayon,
volume;
rayon = float.Parse(Console.ReadLine());
volume = 4.0f/3.0f * PI * rayon; Console.WriteLine("Volume: {0}", volume); |
|
On ne déclare pas plus d'un identifiant (variable ou constante) par ligne. |
//
// Sphère.cs
// Auteur : Gaëtan Tromblon
// Date : 22 août 2013
// Rôle: calculer et afficher le volume d'une sphère
// étant donné son rayon
//
const float PI = 3.14159f;
float rayon,
volume;
rayon = float.Parse(Console.ReadLine());
volume = 4.0f/3.0f * PI * rayon; // calcul du volume d'une sphère
Console.WriteLine("Volume: {0}", volume);
|
const float PI = 3.14159f; float rayon, volume;
rayon = float.Parse(Console.ReadLine());
volume = 4.0f/3.0f * PI * rayon; // calcul du volume d'une sphère
Console.WriteLine("Volume: {0}", volume); |
|
On doit identifier clairement chaque programme par le biais d'un en-tête standardisé. |
//
// Sphère.cs
// Auteur : Gaëtan Tromblon
// Date : 22 août 2013
// Rôle: calculer et afficher le volume d'une sphère
// étant donné son rayon
//
const float PI = 3.14159f;
float rayon,
volume;
rayon = float.Parse(Console.ReadLine());
volume = 4.0f/3.0f * PI * rayon; // calcul du volume d'une sphère
Console.WriteLine("Volume: {0}", volume);
|
//
// SPHERE
//
const float PI = 3.14159f;
float rayon,
volume;
rayon = float.Parse(Console.ReadLine());
volume = 4.0f/3.0f * PI * rayon; // calcul du volume d'une sphère
Console.WriteLine("Volume: {0}", volume);
|
|
On doit s'assurer que toutes les instructions du programme sont facilement compréhensibles, notamment en ajoutant des commentaires judicieux. |
//
// Sphère.cs
// Auteur : Gaëtan Tromblon
// Date : 22 août 2013
// Rôle: calculer et afficher le volume d'une sphère
// étant donné son rayon
//
const float PI = 3.14159f;
float rayon,
volume;
rayon = float.Parse(Console.ReadLine());
volume = 4.0f/3.0f * PI * rayon; // calcul du volume d'une sphère
Console.WriteLine("Volume: {0}", volume);
|
//
// UnGrosGarage.cs
// Auteur : Gaëtan
// Date : 22 août
// Rôle: fait le calcul
//
const float PI = 3.14159f;
float rayon,
volume;
rayon = float.Parse(Console.ReadLine());
volume = 4.0f/3.0f * PI * rayon; // icitte
Console.WriteLine("Volume: {0}", volume);
|
[1] À titre d'information, il existe des standards qui utilisent cette forme d'indentation (en particulier, celui appliqué dans les projets GNU y ressemble beaucoup), mais dans notre cours ce ne sera pas une forme acceptée.
