Série de tutoriels
Ceci est la partie 4 d'une série de 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
Bienvenue à nouveau, programmeurs en herbe !
Dans cet article, nous allons explorer le flux de contrôle et comment vous pouvez utiliser des conditions, des branches, des boucles et d'autres mécanismes pour déterminer ce qui se passe dans votre programme.
Si vous n'avez pas lu les articles précédents de cette série, je vous suggère fortement de le faire. Nous nous appuyons sur les connaissances antérieures dans tous ces articles, il est donc important pour votre compréhension que vous sachiez ce que nous avons déjà couvert.
Nous avons beaucoup à couvrir dans cet article, alors sans plus de cérémonie, passons aux choses sérieuses.
.
Gestion des exceptions
La dernière fois que nous avons quitté notre programme, nous avions trois lignes de code et un problème. Le code ressemble à ceci :
Console.WriteLine("Devinez un nombre entre 1 et 10 :");string text =Console.ReadLine();int input =int.Parse(text); Cependant, si nous exécutons ce programme et saisissons quoi que ce soit sauf un nombre lorsque vous y êtes invité, le programme se bloque car le compilateur ne sait pas comment transformer un texte non numérique en entier.
Si vous vous souvenez de la dernière fois, nous obtenons ce qu'on appelle une exception , et c'est l'un des moyens de contrôler le déroulement d'un programme dans une situation très spécifique, à savoir lorsqu'une situation exceptionnelle se produit.
Je voulais commencer par la gestion des exceptions car c'est le sujet le plus complexe et peut-être déroutant du contrôle de flux, donc si vous pouvez comprendre ce que nous faisons ici, vous trouverez probablement les concepts restants beaucoup plus faciles à comprendre.
Pour la gestion des exceptions en programmation, nous avons deux idées importantes que vous devez comprendre. La première idée est que vous pouvez demander à votre programme d'essayer quelque chose. La deuxième idée est que si l'ordinateur échoue à ce qu'il essaie, vous pouvez détecter le problème et le gérer.
Ces deux idées fonctionnent ensemble un peu comme un funambule avec un filet de sécurité. Un funambule (votre programme) peut fonctionner normalement le long de la corde raide, dans la plupart des cas. Mais si quelque chose hors de l'ordinaire se produit, comme un faux pas sur la corde raide (une exception), il devrait y avoir un filet de sécurité pour empêcher l'artiste de s'effondrer au sol (un hic pour gérer l'exception).
Avec une compréhension de la gestion des exceptions, nous pouvons maintenant commencer à voir une solution à notre problème. Nous pouvons demander à l'ordinateur d'essayer d'analyser le texte en un entier, et s'il échoue, plutôt que de laisser le programme planter, nous pouvons détecter l'erreur, en informer l'utilisateur et lui demander de réessayer.
Voyons à quoi cela pourrait ressembler dans notre code.
Console.WriteLine("Devinez un nombre entre 1 et 10 :");string text =Console.ReadLine();int input =0;try{ input =int.Parse(text);}catch{ Console.WriteLine ("Oups, vous n'avez pas saisi de chiffre");}
Notre premier changement est que nous définissons initialement le int input à zéro avant d'essayer de le définir sur le résultat de l'analyse du texte saisi par l'utilisateur. Il y a une raison spécifique pour laquelle j'ai d'abord défini la valeur sur zéro, puis je l'ai définie sur autre chose plus tard.
Notez qu'après le try ligne, le code que nous voulons essayer est entouré d'accolades comme celles-ci :
{}
En C# et dans de nombreux langages similaires, nous utilisons des accolades pour englober ou limiter la portée de certaines actions, opérations ou même des cycles de vie variables. Généralement, les variables ne survivent qu'à l'intérieur de ces crochets. Lorsque notre exécution de code sort d'un ensemble de ces crochets, toutes les variables à l'intérieur disparaissent (parfois appelées sortir de la portée).
Vous voyez les mêmes accolades après le catch ligne, qui est une instruction selon laquelle tout ce qui se trouve à l'intérieur des accolades ne doit être exécuté que si nous décelons une erreur ou une exception. Le code entre accolades est souvent appelé un bloc de code .
Cela signifie que si nous avions créé le int entrée à l'intérieur du try bloc de code, alors la variable disparaîtrait une fois que nous aurons passé le try bloc de code, et nous ne pouvions plus y accéder pour vérifier s'il correspond à notre valeur secrète. Je vais travailler un exemple de notre code pour vous montrer ce que je veux dire. Notez dans la figure 1 ci-dessous comment je ne définis pas le int entrée jusqu'à ce que nous soyons entre les accolades de notre try déclaration.
Figure 1 :Portée variable
Oh, et remarquez que j'ai une ligne qui commence par // . En C#, les doubles barres obliques indiquent que tout ce qui suit et jusqu'à la fin de la ligne est un commentaire qui ne fait pas partie du programme. Le compilateur ignorera simplement ces lignes.
.
Pour essayer notre programme, nous pouvons mettre un point d'arrêt dans le catch crochets sur Console.WriteLine ligne, puis exécutez notre programme. Entrez une entrée non numérique pour vérifier qu'au lieu de planter, le programme entre maintenant dans le catch bloc de code, puis affiche éventuellement le message d'erreur à l'utilisateur, comme vous pouvez le voir sur la figure 2.
Figure 2 :Exception détectée !
.
Conditions
Maintenant, ce code est plutôt inutile tel qu'il est actuellement écrit parce que nous lisons une valeur, mais - sauf pour dire à l'utilisateur s'il fait une erreur - nous n'utilisons la valeur pour rien. Vous pouvez essayer ceci et voir que si vous entrez un nombre, disons 7, le point d'arrêt n'est pas atteint.
Pour rendre notre code utile comme jeu de devinettes, nous devons tester si nous avons deviné le bon nombre. Ici, nous devons introduire un nouveau concept de contrôle de flux appelé condition .
Une condition est un bloc de code qui s'exécute uniquement si une certaine règle ou un ensemble de règles est rempli. Nous commençons ces conditions par le mot if et suivez-le avec la règle ou l'ensemble de règles que nous vérifions entre parenthèses, qui est ensuite suivi du bloc de code que nous voulons exécuter.
if (la condition est remplie) { // exécute ce bloc de code}
Il existe, bien sûr, des règles de syntaxe très strictes sur la façon dont nous pouvons formater ces conditions, et elles ne sont pas nécessairement aussi intuitives qu'elles pourraient l'être. Par exemple, pour comparer des valeurs, vous devez utiliser deux signes égal en C# et parfois trois en JavaScript. (N'oubliez pas que l'utilisation d'un signe égal est la façon dont vous assignez une valeur.)
if (value ==other_value) // exemple de comparaison de valeurs
Vous pouvez utiliser un large éventail d'opérateurs de comparaison et les autres sont un peu plus intuitifs. Par exemple, comme en mathématiques normales, vous pouvez utiliser supérieur à (>) et inférieur à (<) et les combiner avec des signes égal pour créer une condition supérieure ou égale (>=) ou inférieure ou égale (<=).
Vous pouvez également créer des conditions négatives. Dans de nombreux langages de programmation, vous indiquez un opérateur négatif avec le point d'exclamation (!), qui est aussi souvent appelé "bang". Par exemple, si vous souhaitez créer une condition qui s'exécute si deux valeurs ne sont pas égales, vous pouvez écrire :
if (valeur !=autre_valeur)
Vous pouvez également créer plusieurs conditions en séparant les différentes conditions à l'aide de && (double esperluette) pour les conditions "ET" ou || (tuyaux doubles) pour les conditions "OU".
if (value1 ==other_value &&value2 ==other_value) … //signifie que value1 et value2 doivent être égaux à other_valueif (value1 ==other_value || value2 ==other_value) … //signifie que value1 ou value2 doit être égal à other_value
En utilisant une condition, nous pouvons maintenant créer un test pour voir si le joueur a deviné le bon numéro. Ajoutez les lignes suivantes après la dernière accolade du catch bloc de code :
if (input ==3){ Console.WriteLine("Félicitations ! Vous avez bien deviné !");}
Cette condition teste si entrée (la valeur que l'utilisateur a entrée) est égal à 3. Si cette condition est remplie, le jeu affichera une note de félicitations, comme illustré à la figure 3.
Figure 3 :Condition remplie, félicitations accordées
Si l'utilisateur ne devine pas le chiffre 3, notre programme n'affiche plus rien et l'application se ferme.
N'oubliez pas que vous pouvez placer des points d'arrêt n'importe où dans votre code pour arrêter l'exécution et voir les résultats de ce que vous faites. Nous ferons exactement cela pour voir les résultats des modifications que nous apporterons à notre code à partir de maintenant.
.
Ce serait bien, cependant, si nous pouvions afficher un autre message si l'utilisateur n'a pas deviné le bon numéro. Heureusement, les conditions autorisent également ce comportement via le else mot-clé.
Le else le mot-clé doit venir directement après un if bloc de code et indique ce qui devrait se passer si la condition entre parenthèses d'un if déclaration n'est pas remplie. Pour essayer cela, ajoutez les lignes suivantes après le if bloquer :
else{ Console.WriteLine("Non, désolé, ce n'était pas ça. Meilleure chance la prochaine fois !");}
L'ensemble de vos blocs de code conditionnel devrait maintenant ressembler à la figure 4 ci-dessous.
Figure 4 :deviner le code du programme du jeu avec des blocs de code conditionnels
Lorsque vous exécutez votre programme, selon que vous devinez 3, vous obtiendrez soit une félicitation, soit un encouragement à réessayer. Nous appelons ce type de contrôle de flux branchement conditionnel car le programme va dans l'une ou l'autre branche selon les conditions que vous mettez en avant.
Augmentons un peu les chances de ceux qui ne savent pas que le nombre magique est toujours 3. Nous autoriserons plusieurs tentatives de devinettes si le joueur ne devine pas correctement.
.
Faire une boucle
Pour accomplir cette nouvelle fonctionnalité, nous devons implémenter quelque chose appelé une boucle . En programmation, une boucle est un bloc de code qui s'exécute de manière répétée. Deux types de boucle très courants sont for boucles et while boucles.
La meilleure utilisation de for les boucles sont lorsque vous avez un certain nombre de fois où vous voulez que quelque chose se produise. Commençons par cela dans notre code et voyons où cela nous mène.
Dans un for boucle, vous avez besoin du mot-clé for suivi d'un bloc entre parenthèses contenant trois informations.
Tout d'abord, nous définissons l'environnement de départ de notre boucle, qui inclut les variables que nous voulons utiliser pour suivre le nombre d'exécutions de notre bloc de code. Deuxièmement, nous voulons une condition qui détermine si nous devons continuer la boucle. Enfin, nous avons les modifications que nous voulons apporter aux conditions de la boucle chaque fois que nous exécutons la boucle. Prenons un exemple.
for (int i =0; i <3; i++){ // Ce bloc de code s'exécutera trois fois.}
Le bit important ici est la première ligne. Remarquez les points-virgules qui séparent les trois parties que j'ai mentionnées. Voici comment chaque partie se décompose :
int i=0 ; // Initialisation :crée une variable entière appelée "i" et la définit à 0.i<3 ; // Condition :Continuer l'exécution tant que "i" est inférieur à 3.i++ // Changement se produisant à chaque boucle :"i" augmente de un à chaque exécution de la boucle.
Le i++ la notation est un raccourci pour écrire i=i+1 , qui définit i à la valeur de i plus un - en d'autres termes, il augmente i par un. Vous auriez pu écrire i=i+1 également, mais ce modèle particulier est très, très courant en programmation, je le montre donc comme un exemple utile.
Tout ce que vous mettez dans le bloc qui suit le for La déclaration de boucle se produira tant que la condition est remplie - dans ce cas, trois fois. Par exemple, vous pouvez ajouter un Console.WriteLine() à l'intérieur du bloc de code, et il se répétera trois fois, comme dans la figure 5 ci-dessous.
for (int i =0; i <3; i++){ Console.WriteLine("Je suis dans une boucle !");} 
Figure 5 :"Je suis dans une boucle !"
Nous voulons utiliser ce type de boucle pour permettre à l'utilisateur d'avoir plusieurs tentatives pour deviner le bon nombre. Ainsi, nous pouvons envelopper tout le programme que nous avons déjà écrit dans un for boucle comme décrit ci-dessus. Le code devrait maintenant ressembler à la figure 6 ci-dessous.
Figure 6 :Boucle de devinette
Bien sûr, si vous devinez le bon nombre avant d'avoir atteint trois essais, cela n'a aucun sens de continuer à deviner. En tant que tel, nous sommes sur le point de faire une très mauvaise chose….
Rappelez-vous que la condition pour la poursuite de l'exécution est que i reste en dessous de 3. Donc, si on veut arrêter la boucle, on peut simplement augmenter i à 3 ou plus pour arrêter la boucle. Si vous ajoutez i = 3 à l'intérieur du bloc qui s'exécute si l'utilisateur devine correctement, comme le montre la figure 7 ci-dessous, le jeu s'arrêtera une fois que l'utilisateur aura deviné 3.
Figure 7 :Court-circuiter la boucle For
Vous ne comprenez peut-être pas pourquoi c'est une mauvaise idée, et en réalité, c'est plus un argument philosophique qu'un argument technique. Cependant, c'est un argument important alors faisons-le.
Un for La boucle est conçue pour s'exécuter un certain nombre de fois. Si vous ne savez pas à l'avance combien de fois vous allez exécuter la boucle, alors un for boucle est un mauvais choix. Il existe d'autres formes de boucles mieux adaptées à cette tâche, donc utiliser un for boucle choisit le mauvais outil pour le travail.
Cet argument peut sembler insignifiant et pédant. Le programme fonctionne bien tel quel et fait exactement ce que vous attendez.
Cependant, l'esprit du programmeur est celui qui devrait tendre vers la clarté, et cet exemple n'est certainement pas clair. En regardant la première ligne de notre code actuel, vous pensez qu'il s'agit d'une boucle qui s'exécute trois fois, mais ensuite nous "trichons" la boucle du milieu afin que la boucle puisse s'exécuter n'importe où entre une et trois fois ; nous n'avons aucun moyen de le savoir. Nous avons brisé la clarté de ce qui va se passer, et c'est une mauvaise chose.
Même si vous ne vous souciez pas que quelqu'un lise votre code, rappelez-vous qu'en tant que programmeurs, nous travaillons avec des machines incapables de comprendre l'intention. Il ne comprend exactement que ce que nous disons. Si nous ne sommes pas clairs, la probabilité que nous obtenions des résultats inattendus augmente. Nous risquons de nous créer des problèmes plus tard lorsque les programmes deviennent plus complexes.
En tant que tel, nous devons trouver une meilleure approche, et cette meilleure approche est un while boucle.
.
Une boucle While
Un while La boucle s'exécute tant qu'une condition est vraie. Peu importe le nombre de fois :tant que la condition est vraie, la boucle continue.
Un while la boucle est plus simple dans la déclaration qu'un for boucle et comprend le mot-clé while suivi d'une parenthèse ouvrante, des conditions et d'une parenthèse fermante.
while (condition) { // Code à exécuter}
Cette exécution peut être très dangereuse si vous n'avez pas de conditions claires. Si vous faites une erreur ou ne tenez pas compte correctement de toutes les conditions et événements, votre programme peut se déchaîner et immobiliser votre machine.
Le danger réside dans le fait de s'assurer que vous invalidez la condition à l'intérieur du bloc de code lorsque vous souhaitez que l'exécution s'arrête. Sinon, la boucle s'exécutera indéfiniment.
Changeons notre for boucle vers un while boucle et laissez-la s'exécuter tant que l'utilisateur n'a pas deviné trois fois. Nous pouvons créer cette condition en déclarant un int i=0; avant le début de la boucle, puis en définissant la valeur de i à l'intérieur de la boucle. Mettez à jour votre code en tant que tel :
static void Main(string[] args){ int i=0 ; while(i <3) { Console.WriteLine("Devinez un nombre entre 1 et 10 :"); texte de chaîne =Console.ReadLine(); entrée entière =0 ; essayez { entrée =int.Parse (texte); } catch { Console.WriteLine("Oups, vous n'avez pas entré de nombre"); } if (input ==3) { Console.WriteLine("Félicitations ! Vous avez bien deviné !"); je =3 ; } else { Console.WriteLine("Non, désolé, ce n'était pas ça. Meilleure chance la prochaine fois !"); } }}
Notez qu'il y a une erreur dans ce code, qui montre à quel point il est facile de créer des boucles infinies. Nous n'augmentons pas i à moins que nous devinions correctement! En d'autres termes, le joueur obtient une infinité d'essais, mais il n'y a aucun moyen d'arrêter de deviner s'il ne devine pas correctement !
Heureusement, si vous démarrez ce programme, vous savez que la réponse est fixée à 3, vous pouvez donc le deviner, mais sans cela, vous pourriez avoir un énorme problème sur votre main.
Je dis cela pour ne pas vous effrayer d'utiliser while boucles, mais plutôt pour inculquer un sentiment de respect pour leur pouvoir. While les boucles sont très puissantes et utiles mais peuvent aussi être dangereuses si vous n'y faites pas attention.
Pour résoudre votre problème, ajoutez i++; comme première ligne à l'intérieur du bloc de code while, précédant immédiatement Console.WriteLine("Guess a number between 1 and 10:") . Votre code devrait maintenant fonctionner comme prévu, être très clair et vous donner un jeu de devinettes très basique mais ennuyeux.
.
Un aperçu de l'orientation de l'objet
Alors, que pouvons-nous faire pour rendre ce jeu intéressant, même à distance ? Je sais, rendons le numéro secret aléatoire !
Je me suis retenu car nous devons introduire de nouvelles idées pour créer des nombres aléatoires. Ces idées deviendront claires dans le prochain article qui traite de l'orientation objet. Pour l'instant, laissez-moi vous donner le code et j'expliquerai en détail ce qu'il fait dans le dernier article de cette série.
static void Main(string[] args){ Random random =new Random(); // Objet orientation stuff int answer =random.Next(10)+1 ; // Donnez-moi un nombre aléatoire inférieur à 10 et ajoutez-en un int i =0; tandis que (je <3) { je++ ; Console.WriteLine("Devinez un nombre entre 1 et 10 :"); texte de chaîne =Console.ReadLine(); entrée entière =0 ; essayez { entrée =int.Parse (texte); } catch { Console.WriteLine("Oups, vous n'avez pas entré de nombre"); } if (input ==answer) { Console.WriteLine("Félicitations ! Vous avez bien deviné !"); je =3 ; } else { Console.WriteLine("Non, désolé, ce n'était pas ça. Meilleure chance la prochaine fois !"); } }}
Il y a maintenant deux nouvelles lignes et une ligne modifiée. Les nouvelles lignes créent un entier aléatoire answer entre 1 et 10, et dans la ligne modifiée, nous comparons ce que l'utilisateur devine avec cette réponse aléatoire.
Ne vous souciez pas de la génération aléatoire pour le moment, je vous expliquerai cela dans le prochain article. Mais pour l'instant, félicitations, vous êtes officiellement développeur de jeux en plus d'être programmeur ! N'hésitez pas à jouer au jeu maintenant et à voir comment vous vous en sortez. Vous devriez battre le jeu, en moyenne, 3 fois sur 10.
Comme exercice supplémentaire pour vous-même, pourquoi n'ajoutez-vous pas un message après la fin du jeu qui indique au joueur quel était le numéro secret ? Pour l'instant, résumons et passons en revue ce que nous avons couvert.
.
Récapitulatif
Dans cet article, vous avez découvert le déroulement du programme et comment vous pouvez contrôler le déroulement de votre programme. Vous avez appris les exceptions pour gérer les erreurs. Vous avez appris les blocs de code et le branchement conditionnel avec if et else . Vous avez également appris les boucles avec for et while .
Dans le prochain article, nous passerons un peu de temps à peaufiner le jeu et nous examinerons également l'orientation des objets plus en détail.
Série de tutoriels
Ceci est la partie 4 d'une série de 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