Exercice : Afficher des valeurs littérales

10 minutes

Dans cet exercice, vous affichez des messages contenant d’autres types de données et vous découvrez pourquoi les types de données sont si importants en C#.

Qu’est-ce qu’une valeur littérale ?

Une valeur littérale est une valeur constante qui ne change jamais. Précédemment, vous avez affiché une chaîne littérale dans la console de sortie. En d’autres termes, vous vouliez littéralement que la chaîne de caractères alphanumériques H, e, l, l, o, etc., s’affiche dans la console de sortie.

Utilisez le type de données “string” chaque fois que vous avez des mots, des phrases ou des données alphanumériques à présenter, et non à calculer. Quelles sont les autres sortes de données littérales que vous pouvez afficher dans la console de sortie ?

Exercice : Afficher différents types de données littérales

Il existe de nombreux types de données en C#. Mais comme vous commencez, vous n’avez besoin de connaître que cinq ou six types de données, car ils couvrent la plupart des scénarios. Affichez une instance littérale de type de données dans la console de sortie.

Notes

Notez que vous pouvez remarquer, lorsque vous commencez à travailler dans la fenêtre de code, que certains éléments de syntaxe sont colorés dans différentes couleurs pour indiquer des mots clés, des opérateurs, des types de données, etc. Commencez à prendre note de ces couleurs. Cela peut vous aider à repérer les erreurs de syntaxe à mesure que vous entrez des caractères et à comprendre le code d’une façon plus efficace.

Utiliser des littéraux de type caractère

Si vous voulez afficher un seul caractère alphanumérique, vous pouvez créer un littéral de type char en plaçant un caractère alphanumérique unique entre des guillemets simples. Le terme char est l’abréviation de character (caractère). En C#, ce type de données est officiellement nommé “char”, mais est souvent appelé “caractère”.

Ajoutez la ligne de code suivante dans l’éditeur de code :
```
Console.WriteLine('b');
```
Observez le code que vous avez entré.

Notez que la lettre b est entourée de guillemets simples 'b'. Les guillemets simples créent un littéral de type caractère. Rappelez-vous que l’utilisation de guillemets doubles crée un type de données string.
Appuyez sur le bouton vert “Exécuter” pour exécuter votre code. Vous voyez normalement le résultat suivant dans la fenêtre de sortie :
```
b
```

Si vous entrez le code suivant :

Console.WriteLine('Hello World!');

Vous obtenez l’erreur suivante :

(1,19): error CS1012: Too many characters in character literal

Notez les guillemets simples qui entourent Hello World!. Lorsque vous utilisez des guillemets simples, le compilateur C# attend un caractère unique. Toutefois, dans ce cas, la syntaxe utilisée est celle d’un littéral de type caractère, mais 12 caractères ont été fournis à la place.

Tout comme le type de données string, vous utilisez char chaque fois que vous avez un seul caractère alphanumérique destiné à la présentation (et non au calcul).

Utiliser des littéraux de type entier

Si vous voulez afficher une valeur numérique entière (sans fractions) dans la console de sortie, vous pouvez utiliser un littéral de type int. Le terme int est l’abréviation de « integer » (entier), qui doit vous rappeler vos cours de math. En C#, ce type de données est officiellement nommé “int”, mais est souvent appelé “entier”. Un littéral de type int ne nécessite aucun opérateur supplémentaire comme string ou char.

Ajoutez la ligne de code suivante dans l’éditeur de code :
```
Console.WriteLine(123);
```
Appuyez sur le bouton vert “Exécuter” pour exécuter votre code. Vous voyez normalement le résultat suivant dans la console de sortie :
```
123
```

Utiliser des littéraux de type virgule flottante

Un nombre à virgule flottante est un nombre qui contient une décimale, par exemple 3,14159. C# prend en charge trois types de données pour représenter des nombres décimaux : float, double et decimal. Chaque type prend en charge des degrés de précision variables.

Float Type    Precision
----------------------------
float         ~6-9 digits
double        ~15-17 digits
decimal        28-29 digits

Ici, la précision reflète le nombre de chiffres après le séparateur décimal qui sont exacts.

Ajoutez la ligne de code suivante dans l’éditeur de code :
```
Console.WriteLine(0.25F);
```
Pour créer un littéral float, ajoutez la lettre F après le nombre. Dans ce contexte, F est appelé suffixe littéral. Le suffixe littéral indique au compilateur que vous souhaitez utiliser une valeur de type float. Vous pouvez utiliser une minuscule (f) ou une majuscule (F) pour le suffixe littéral d’une valeur float.
Appuyez sur le bouton vert “Exécuter” pour exécuter votre code. Vous voyez normalement le résultat suivant dans la console de sortie :
```
0.25
```
Notez que le type de données float est le moins précis. Il est donc recommandé de réserver son utilisation pour les valeurs fractionnaires fixes afin d’éviter des erreurs de calcul inattendues.
Ajoutez la ligne de code suivante dans l’éditeur de code :
```
Console.WriteLine(2.625);
```
Pour créer un littéral double, entrez simplement un nombre décimal. Le compilateur utilise par défaut un littéral double quand un nombre décimal est entré sans suffixe littéral.
Appuyez sur le bouton vert “Exécuter” pour exécuter votre code. Vous voyez normalement le résultat suivant dans la fenêtre de sortie :
```
2.625
```
Ajoutez la ligne de code suivante dans l’éditeur de code :
```
Console.WriteLine(12.39816m);
```
Pour créer un littéral décimal, ajoutez la lettre m après le nombre. Dans ce contexte, m est appelé suffixe littéral. Le suffixe littéral indique au compilateur que vous souhaitez utiliser une valeur de type decimal. Vous pouvez utiliser une minuscule (m) ou une majuscule (M) pour le suffixe littéral d’une valeur decimal.
Appuyez sur le bouton vert “Exécuter” pour exécuter votre code. Vous voyez normalement le résultat suivant dans la console de sortie :
```
12.39816
```

Utiliser des littéraux de type booléen

Si vous voulez afficher une valeur représentant true ou false, vous pouvez utiliser un littéral bool.

Le terme bool est l’abréviation de Boolean. En C#, le terme officiel est « bool », mais les développeurs utilisent souvent le terme « Boolean » (Booléen).

Ajoutez les lignes de code suivantes dans l’éditeur de code :
```
Console.WriteLine(true);
Console.WriteLine(false);
```
Appuyez sur le bouton vert “Exécuter” pour exécuter votre code. Vous voyez normalement le résultat suivant dans la console de sortie :
```
True
False
```

Les littéraux de type bool représentent l’idée du vrai et du faux. Vous utiliserez beaucoup de valeurs bool quand vous commencerez à ajouter une logique de décision à vos applications. En effet, vous aurez besoin d’évaluer des expressions pour voir si elles sont vraies (true) ou fausses (false).

Pourquoi mettre l’accent sur les types de données ?

Les types de données jouent un rôle central en C#. En fait, l’importance accordée aux types de données est l’une des caractéristiques clés qui distingue C# des autres langages tels que JavaScript. Les concepteurs de C# ont cru qu’ils pouvaient aider les développeurs à éviter les bugs logiciels courants en appliquant des types de données. Vous découvrirez ce concept au fil de votre apprentissage de C#.

Les types de données définissent des fonctionnalités

Plus tôt, vous avez vu que les types string et char sont utilisés pour “la présentation, pas le calcul”. Si vous devez effectuer une opération mathématique sur des valeurs numériques, vous devez utiliser des valeurs int ou decimal. Si vous avez des données qui servent uniquement à des fins de présentation ou de manipulation de texte, vous devez utiliser le type de données string ou char.

Supposons que vous deviez collecter des données auprès d’un utilisateur, par exemple un numéro de téléphone ou un code postal. En fonction de votre pays/région de résidence, ces données peuvent se composer de caractères numériques. Toutefois, étant donné que vous effectuez rarement des calculs mathématiques sur des numéros de téléphone et des codes postaux, vous devriez préférer utiliser un type de données string lors de leur manipulation.

Cela vaut également pour les valeurs bool. Si vous avez besoin de travailler avec les mots "true" et "false" dans votre application, vous devez utiliser une valeur string. Toutefois, si vous devez utiliser le concept des valeurs true ou false quand vous effectuez une évaluation, vous utilisez une valeur bool.

Il est important de savoir que ces valeurs peuvent ressembler à leurs équivalents littéraux de chaîne. En d’autres termes, vous pouvez penser que les instructions suivantes sont identiques :

Console.WriteLine("123");
Console.WriteLine(123);

Console.WriteLine("true");
Console.WriteLine(true);

Cependant, ce n’est que la sortie affichée qui semble similaire. Le fait est que les choses que vous pouvez faire avec les types de données int ou bool sous-jacents seront différentes de leur équivalent string.

Récapitulatif

Le principal point à retenir est qu’il existe de nombreux types de données, mais vous vous concentrerez sur quelques-uns pour l’instant:

string pour les mots, les expressions ou les données alphanumériques destinées à la présentation, et non au calcul
char pour un seul caractère alphanumérique
int pour un nombre entier
decimal pour un nombre avec un composant fractionnaire
bool pour une valeur true/false

Continuer