Série de tutoriels
Ceci est la partie 3 d'une série en 5 parties pour Introduction à la programmation
- Introduction à la programmation :Premiers pas
- Introduction à la programmation :votre premier programme
- Introduction à la programmation :variables, types et manipulation de données
- Introduction à la programmation :contrôle de flux
- Introduction à la programmation :programmation orientée objet
Retour à notre programme
Dans les deux articles précédents de cette série, vous avez, en moyenne, écrit une ligne de code par article. Dans celui-ci, nous ajoutons une autre ligne, mais nous allons également modifier les lignes que nous avons déjà car maintenant nous allons commencer à parler de variables et de types de données.
L'objet de cet article est de vous apprendre les variables et les types et comment les manipuler pour créer un programme qui ne se contente pas d'afficher "Hello World !"
Nous avons beaucoup à couvrir, alors préparez vos doigts et allons-y.
.
Utiliser des variables
Notre programme actuel reste exceptionnellement simple avec seulement deux lignes de code :
Console.WriteLine("Hello World!");
Console.ReadLine(); La première ligne envoie un morceau de texte à la console et la seconde lit une ligne de l'utilisateur. Mais où finit cette ligne dans laquelle nous sommes entrés ? Actuellement, il tombe dans le néant parce que nous ne faisons rien pour le récupérer, alors changeons cela immédiatement.
Modifiez la deuxième ligne pour qu'elle ressemble à ceci :
String input = Console.ReadLine();
Ce que nous faisons ici, c'est dire que "l'entrée de chaîne" (quelle qu'elle soit) doit être affectée à tout ce qui sort de la méthode ReadLine appelé sur la Console classe statique.
Nous utilisons le signe égal pour attribuer des valeurs en C# et dans de nombreux langages similaires. Tout ce qui se trouve à gauche du signe égal se voit attribuer la valeur de ce qui se trouve à droite.
Les deux mots dans String input ont des significations différentes. String indique le type de valeur et input est le nom que nous utilisons pour représenter la valeur. Ce que nous faisons ici est de créer une variable appelé "entrée" qui a un type de "Chaîne". J'expliquerai les types plus loin dans cet article.
En programmation, nous utilisons des variables pour conserver les données en mémoire afin de pouvoir les manipuler facilement. Vous l'utilisez également dans votre vie quotidienne, sans l'appeler une variable. Pensez, par exemple, à "Votre téléphone", qui est simplement un moyen facile de se souvenir du nom d'un appareil électronique particulier qui peut changer avec le temps. Ou, considérez "le taux de change du dollar américain par rapport à l'euro". Vous ne vous souvenez pas tout le temps de ce taux, et il change rapidement, vous trouverez donc probablement plus facile de vous y référer par son nom plutôt que par sa valeur.
Les variables nous permettent de faire référence à une donnée particulière par son nom au lieu de sa valeur, quelle que soit la valeur ou si elle change. Dans notre programme, les données sont celles que l'utilisateur saisit avant d'appuyer sur Enter clé. Le nom que nous donnons à cette donnée particulière, dans ce cas, est "entrée", mais nous pouvons l'appeler différentes choses. En fait, il existe toute une gamme de modèles juste pour nommer les variables, et vous serez probablement très confus plus tard dans votre carrière.
.
Déboguer avec des points d'arrêt
Vous pouvez essayer ceci maintenant, mais avant de le faire, je veux vous montrer une astuce de Visual Studio appelée un point d'arrêt . Un point d'arrêt vous permet d'arrêter l'exécution d'un programme et de voir quelle ligne de code est en cours d'exécution. Il vous permettra même de parcourir le code ligne par ligne à partir de ce point.
Pour créer un point d'arrêt, déplacez votre curseur sur la première ligne de votre code et appuyez sur F9 ou cliquez dans la marge à gauche des numéros de ligne sur la ligne où vous souhaitez définir votre point d'arrêt. Si cela est fait correctement, toute la ligne devrait devenir rouge et vous devriez obtenir un cercle rouge dans la marge.
Figure 1 :point d'arrêt ajouté
Notez que le point d'arrêt arrête l'exécution avant la ligne à laquelle vous l'avez défini. De plus, les points d'arrêt ne fonctionnent que lorsque vous exécutez votre application via un outil de développement tel que Visual Studio, donc si vous ne supprimez pas vos points d'arrêt avant de distribuer votre application, c'est parfaitement bien.
Maintenant, appuyez sur F5 ou ce bouton Démarrer dans le menu et regardez votre application se lancer. Juste après, Visual Studio devrait réapparaître et vous montrer la prochaine ligne à exécuter en jaune.
Figure 2 :Point d'arrêt atteint
À ce stade, vous pouvez contrôler l'exécution étape par étape et observer les résultats dans la fenêtre de la console. Pour aller plus loin, appuyez sur F10 dans Visual Studio. Amenez la fenêtre de la console à l'avant et observez que votre code a maintenant avancé d'une ligne, et il y a maintenant "Hello World!" affiché dans la fenêtre comme prévu.
Figure 3 :Prochaine ligne de commande exécutée
Remarque :Les programmeurs se réfèrent souvent à ce processus d'accrochage dans votre code pendant son exécution en tant que « débogage ». Ce processus est un exemple du type de débogage que vous pouvez effectuer pour vérifier que votre code fonctionne comme prévu.
.
Avancez une fois de plus dans votre code dans Visual Studio. Notez que lorsque vous le faites, la fenêtre de la console apparaît automatiquement. Cet événement se produit car la console a besoin d'une entrée de l'utilisateur lors de l'exécution de Console.ReadLine() méthode.
Entrez n'importe quel morceau de texte que vous aimez et appuyez sur Enter . Lorsque vous le faites, Visual Studio réapparaît car maintenant que vous avez fourni l'entrée, l'exécution peut continuer et nous ne faisons que parcourir le code.
Dans cette fenêtre Visual Studio, j'aimerais attirer votre attention sur la partie inférieure de l'écran où vous devriez voir un onglet appelé "Locals". Si vous ne le trouvez pas, vous pouvez l'ouvrir en allant dans le menu et en sélectionnant Debug->Windows->Locals ou en appuyant sur CTRL+D puis L .
Une fois que vous avez ouvert la fenêtre Locals, vous devriez voir qu'il y a une variable appelée "input" qui a une valeur définie sur ce que vous avez entré dans la fenêtre de la console. Dans mon cas, j'ai saisi "Salut !".
Figure 4 :Débogage des variables locales
L'onglet Variables locales affiche les variables que vous pouvez utiliser dans la portée actuelle. Cependant, avant de commencer à manipuler et à utiliser ces données, il est important de comprendre le concept de types de variables.
.
Types de variables :statiques et dynamiques
Vous voyez, il existe deux approches de ce que les programmeurs appellent "taper", et aucune n'a rien à voir avec l'appui sur les touches d'un clavier. Les deux approches ont des forces et des faiblesses. Et non, je ne vais pas vous dire lequel est le meilleur; vous aurez amplement le temps de le déterminer vous-même et, peut-être, comprendrez-vous pourquoi certains programmeurs développent une préférence presque fanatique pour l'un par rapport à l'autre.
Les deux approches sont statiques et dynamique dactylographie. C#, le langage que vous utilisez dans ces articles, est un langage à typage statique, tandis que d'autres langages populaires comme JavaScript sont des langages à typage dynamique. Laissez-moi vous expliquer la différence.
Vous avez remarqué précédemment que lorsque nous avons créé la variable "input", nous avons décidé qu'il s'agissait d'une String variable. String est un terme qui sert à indiquer quel type de données peut entrer dans la variable. Vous ne pouvez pas ajouter de données incompatibles à une variable car Visual Studio, ou techniquement le compilateur qui traduit votre code de programmation en code machine, s'y opposera et refusera de coopérer.
Une String n'est qu'un morceau de texte et peut contenir presque n'importe quoi, ce qui est logique lorsque nous demandons à l'utilisateur de saisir n'importe quel morceau de texte. Cependant, il y a un problème potentiel lorsque nous voulons commencer à travailler avec nos données.
Disons que nous voulons demander à l'utilisateur d'entrer son âge et que nous voulons limiter certaines fonctionnalités si l'utilisateur a moins de 13 ans, par exemple.
Comment déterminez-vous si "Salut !" est inférieur à 13 ? Vous ne pouvez pas, car il n'y a aucun moyen de faire de l'arithmétique sur un morceau de texte. "Tomate" plus 45 n'a pas de sens.
Une situation comme celle-ci est la raison pour laquelle les langages à typage statique ont différents types de variables. Nous pouvons savoir si nous pouvons effectuer des opérations arithmétiques ou autres sur les données avant même d'envoyer le programme à l'utilisateur.
Dans les langages à typage statique, tels que C#, VisualBasic et Java, vous devez définir à l'avance ce qu'une variable peut contenir, et vous ne pouvez pas créer ou compiler votre programme sans respecter ces règles. En retour, vous êtes assuré de ne pas comparer Apples à 3,42 ou d'essayer de déterminer s'il est légal de vendre de l'alcool à une personne qui ne vous regarde pas depuis des années.
Dans les langages à typage dynamique, vous n'obtenez pas de telles garanties. Au lieu de cela, vous travaillez simplement avec des variables qui peuvent contenir n'importe quel type de données. JavaScript est un exemple de langage typé dynamiquement. En JavaScript, les programmeurs doivent vérifier que les données qu'ils obtiennent sont d'une valeur attendue car leur code peut planter s'ils essaient d'ajouter ou de comparer "oui" à 18.
Remarque :Vous pouvez en fait ajouter "oui" à 18 dans la plupart des langues, selon la façon dont vous le faites. Vous obtiendrez très probablement "oui18", cependant, ce qui n'est probablement pas ce à quoi vous vous attendiez.
.
Dans les langages à typage statique, vous constaterez également que toutes les méthodes renvoient un type spécifique de données ou, dans certains cas, rien du tout. Par exemple, le Console.ReadLine() La méthode renvoie une valeur de chaîne, donc cela fonctionne très bien pour définir notre String input variable à la sortie de cette méthode comme nous l'avons fait.
Cependant, que se passera-t-il si nous voulons demander à l'utilisateur de choisir un nombre entre 1 et 10 parce que nous voulons utiliser ce nombre pour quelque chose plus tard ? Commençons à créer un jeu simple et voyons, d'accord ?
.
Un programme de jeu de devinettes
Le jeu que nous allons construire est un jeu de devinettes. Nous choisissons un nombre secret entre 1 et 10, puis nous demandons à l'utilisateur de deviner de quel nombre il s'agit. Nous rendrons ce jeu plus avancé plus tard, donc pour l'instant, l'utilisateur n'obtient qu'une seule supposition et a donc 10% de chances de bien faire les choses. En fait, nous n'allons même pas tester si elles sont correctes dans cet article car cela impliquerait des conditions et un contrôle de flux, qui sont des concepts que nous n'allons pas encore apprendre.
Premièrement, le type de variable pour un nombre qui n'a pas de décimales est appelé un entier, ou int pour faire court. Un int peut contenir de très grands nombres, généralement limités par le type d'architecture du processeur, avec un processeur 32 bits contenant des nombres entiers jusqu'à environ 4,4 milliards. Au-delà de cela, nous pouvons utiliser d'autres types de variables. Cependant, pour nos exemples simples, un int normal fonctionnera bien.
Pour tous les types de variables, nous pouvons attribuer directement des valeurs simples. Par exemple :
int value = 10; string name = “Frank”;
Nous pouvons également effectuer des opérations sur des variables, tant qu'elles "ont un sens". Par exemple, vous pouvez additionner deux valeurs entières.
int value1 = 10; int value2 = 3; int value3 = value1+value2;
L'entier stocké dans la variable "value3" est 13 après que la portion de code contenant ces lignes passe par ce point.
Nous pouvons également attribuer des valeurs à partir de la valeur de retour des méthodes. Essayons simplement d'attribuer le résultat de la Console.ReadLine() méthode dans un int , on y va? Si vous ne l'avez pas déjà fait, arrêtez l'exécution de votre programme. Nous allons maintenant mettre à jour nos deux lignes de code ainsi :
Console.WriteLine("Guess a number between 1 and 10:");
int input = Console.ReadLine(); Lorsque vous le faites, vous obtiendrez un cas de gribouillis rouges (comme illustré ci-dessous dans la figure 5) et un message d'erreur dans la liste des erreurs indiquant "Impossible de convertir implicitement le type 'chaîne' en 'int'".
Figure 5 :Un cas de gribouillis rouges
Nous obtenons cette erreur car la valeur qui sort de Console.ReadLine() est une chaîne et le compilateur ne peut pas garantir qu'il peut convertir ce qu'un utilisateur peut entrer en un nombre. Un utilisateur peut entrer « NON ! » par exemple, et il n'y a aucun moyen de transformer cette entrée en nombre.
Il existe, bien sûr, des moyens de contourner ce problème. Nous pouvons forcer le compilateur à accepter tout ce qui arrive comme étant d'un type spécifique. En fait, nous pouvons le faire avec n'importe quel type. C'est un processus appelé casting .
Lorsque nous transtypons des types de variables, le compilateur fera de son mieux pour convertir d'un type de variable à un autre. Ce cast peut, par exemple, fonctionner si vous avez un nombre décimal et que vous voulez un nombre entier.
decimal decimalvalue = 3.14M; int integervalue = decimalvalue;
La première ligne attribue la valeur 3.14 au decimal variable appelée decimalvalue . La deuxième ligne tente d'attribuer cette valeur décimale à un entier.
Remarque :Le M est là simplement pour indiquer au compilateur que nous créons une valeur décimale car, pour ajouter encore plus de confusion à ce point, il existe plusieurs types de
decimalvaleurs, y compris la double précision et les valeurs à virgule flottante. Bien qu'il soit utile de le savoir, aucun de ces points n'est une chose dont vous devrez vous soucier dans cet article.
.
Si vous entrez ces lignes dans Visual Studio, vous remarquerez que même maintenant, nous obtenons un cas de gribouillis car un decimal la valeur ne rentre pas dans un int évaluer. Si nous essayions, nous perdrions le .14 et nous n'aurions plus que 3 comme valeur de integervalue .
Ce comportement peut être exactement ce que nous voulons. Dans ce cas, nous pouvons convertir le decimal valeur à un int , forçant effectivement le compilateur à accepter la conversion explicite d'une valeur décimale en une valeur entière. Nous le faisons en faisant précéder la valeur du type que nous voulons entre parenthèses. Comparez ces lignes de code à celles ci-dessus.
decimal decimalvalue = 3.14M; int integervalue = (int)decimalvalue;
Maintenant, nos gribouillis Visual Studio vont disparaître et le compilateur est content. Nous perdons certains détails dans les chiffres, mais vous pouvez être sûr que c'est ce que vous voulez.
En C#, le compilateur vous demandera de caster des valeurs s'il y a un risque de perte de données, comme c'est le cas si vous passez d'une valeur décimale à une valeur entière. Cependant, il acceptera volontiers une conversion compatible lorsqu'il n'y a aucun risque de perte de données. Si vous avez essayé d'attribuer un int valeur à un decimal type, par exemple, vous n'obtiendrez aucune querelle de la part du compilateur.
Jusqu'à présent, cependant, nous ne nous rapprochons pas vraiment d'une solution à notre problème. Nous pouvons essayer de caster la valeur de chaîne provenant de Console.ReadLine() dans un int , mais le compilateur se plaindra qu'il ne peut pas convertir automatiquement une valeur de chaîne en un entier (comme illustré ci-dessous dans la figure 6) car il n'y a aucun moyen de garantir à l'avance qu'il est possible de transformer ce qui vient de l'utilisateur en un nombre.
Figure 6 :Erreur lors de la conversion de la chaîne en Int
N'ayez crainte, car il existe une meilleure façon de résoudre ce problème ! La solution utilise une méthode statique pour analyser la valeur de la chaîne en un entier, et elle se trouve directement dans le int tapez lui-même. En tant que tel, nous pouvons appeler le int.Parse méthode, envoyez-lui tout ce qui vient de la Console.ReadLine() et récupérez un entier.
Alors, mettons à jour le code de votre programme pour inviter d'abord l'utilisateur à saisir les données, puis récupérons les données dans une String variable appelée "texte", et enfin d'analyser "texte" en un entier.
Console.WriteLine("Guess a number between 1 and 10:");
string text = Console.ReadLine();
int input = int.Parse(text); Une fois que vous l'avez fait, tous vos gribouillis devraient disparaître et votre programme devrait s'exécuter comme prévu. N'hésitez pas à définir un point d'arrêt après la dernière ligne pour arrêter l'exécution et inspecter vos variables. Voyez ce qui se passe lorsque vous entrez un nombre pendant l'exécution.
Figure 7 :Exécution valide
Vous verrez que "input" montre maintenant qu'il a une valeur de 3 alors que "text", dans mon cas, a une valeur de "3" (remarquez les guillemets doubles ; les guillemets doubles signifient une valeur de chaîne).
Mais que se passe-t-il si nous saisissons autre chose qu'un nombre ? Eh bien, si vous entrez quelque chose comme "Bonjour" au lieu d'un numéro, le programme plantera. Dans Visual Studio, l'exécution s'arrêtera et vous informera d'une exception, comme illustré ci-dessous dans la figure 8.
Figure 8 :Exécution invalide
En tant que programmeurs, nous ne voulons pas que notre logiciel plante, nous devons donc gérer ce bogue. Cependant, nous allons laisser cela pour le prochain article car cela implique de manipuler le déroulement du programme, et nous en avons déjà couvert pas mal pour en arriver là.
.
Récapitulatif des variables, des types et de la manipulation des données
Pour l'instant, il est temps de conclure ce troisième article, et malgré l'écriture d'une seule ligne de code de plus, nous avons couvert beaucoup de nouveau matériel. Ne vous inquiétez pas, lorsque j'ai commencé à apprendre cela il y a de nombreuses années, il y avait aussi de nombreux aspects déroutants pour moi.
Dans cet article, nous avons couvert le concept de variables et examiné les types de données et quand et pourquoi les types de données sont importants. Vous avez appris à créer des variables et même à transformer des données d'un type en un autre grâce à la diffusion. Vous avez appris le débogage pas à pas, les points d'arrêt et comment inspecter les variables disponibles dans Visual Studio.
Vous devez également noter que les choses que vous avez apprises maintenant sont très courantes dans tous les langages et plates-formes, et j'ai pris soin d'introduire et d'expliquer des concepts qui varient, tels que le typage statique par rapport au typage dynamique.
Dans le prochain article, nous examinerons le contrôle de flux afin que vous puissiez apprendre à contrôler l'exécution de votre programme et vérifier diverses conditions pour déterminer ce que le programme doit faire ensuite.
Série de tutoriels
Ceci est la partie 3 d'une série en 5 parties pour Introduction à la programmation
- Introduction à la programmation :Premiers pas
- Introduction à la programmation :votre premier programme
- Introduction à la programmation :variables, types et manipulation de données
- Introduction à la programmation :contrôle de flux
- Introduction à la programmation :programmation orientée objet