• 4 heures
  • Facile

Ce cours est visible gratuitement en ligne.

Vous pouvez être accompagné et mentoré par un professeur particulier par visioconférence sur ce cours.

J'ai tout compris !

Mis à jour le 31/10/2017

Amusons-nous avec les End

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Et oui ! Fini le temps où on met bien tout ensemble, un jolie structure, toujours boucler tous les End au bon endroit ...
Accrochez-vous, car ce chapitre ne sera pas de tout repos. Au programme :

  • les End conditionnels

  • une boucle qui se finie à un autre endroit du programme

  • application pour faire des sous-programmes ... au sein du programme !

Le END conditionnel

Commençons par un exemple :

:For(A,1,10
	:Disp "MSG1",A
	:If A<5
	:End
	:Disp "MSG2
:End

Résultat :

MSG1
        1
MSG1
        2
MSG1
        3
MSG1
        4
MSG1
        5
MSG2
MSG1
        6
MSG2
MSG1
        7
MSG2
MSG1
        8
MSG2
MSG1
        9
MSG2
MSG1
        10
MSG2
        Done

Essayons maintenant de comprendre ce qui s'est passé :

  • Ligne 1 : entrée en boucle : A = 1

  • Ligne 2 : affichage de "MSG1" puis de la valeur de A

  • Ligne 3 : si A < 5 : ici, c'est le cas, donc l'instruction juste après est exécutée

  • Ligne 4 : fin de boucle : retour à la ligne 1 pour une incrémentation

Tout cela se passe jusqu'à ce que A = 5. Ensuite :

  • Ligne 1 : incrémentation de A : A = 5 (pour la première fois)

  • Ligne 2 : affichage de "MSG1" puis de la valeur de A

  • Ligne 3 : si A < 5 : ici, ce n'est pas le cas, donc l'instruction 4 est sautée

  • Ligne 5 : affichage de "MSG2"

  • Ligne 6 : fin de boucle : retour à la ligne 1 pour une incrémentation

Maintenant, modifions l'exemple en remplaçant :If A<5 par :If A>5 :

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Résultat :

MSG1
        1
MSG2
MSG1
        2
MSG2
MSG1
        3
MSG2
MSG1
        4
MSG2
MSG1
        5
MSG2
MSG1
        6
MSG1
        7
MSG1
        8
MSG1
        9
MSG1
        10
MSG2

ERROR:SYNTAX (ligne 6)
Décortiquons

Entrée dans la boucle, initialisation de A à 1 ;
affichage de "MSG1" et du contenu de A

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Test de la condition : négatif
=> la ligne 4 est sautée

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Affichage de "MSG2" puis fin de la boucle

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End
Au 6e tour de boucle, A=6

Incrémentation de A : A = 6 ;
affichage de "MSG1" et du contenu de A

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Test de la condition : positif
=> la ligne 4 n'est pas sautée

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Fin de la boucle : retour à la ligne 1

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End
Et, enfin, quand A = 10

Incrémentation de A : A = 10 ;
affichage de "MSG1" et du contenu de A

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Test de la condition : positif
=> la ligne 4 n'est pas sautée

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Fin de la boucle ;
incrémentation de A : A = 11
On a donc A > 10, donc la boucle s'arrête ici.
Le programme continue normalement, comme si
la "vraie" fin de la boucle était là.
Nous ne sommes donc plus sensé être dans
une boucle.

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Affichage de "MSG2"

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Erreur de syntaxe : le
programme rencontre un End alors
que nous ne sommes plus dans une boucle.

:For(A,1,10
	:Disp "MSG1",A
	:If A>5
	:End
	:Disp "MSG2
:End

Le ELSE conditionnel

Théorie

Alors là, accrochez-vous, ça va être encore pire !

Commençons encore une fois par un exemple :

:If // condition 1
:Then
	// instructions 1
:End

:If not( /* condition 1 */ ) or /* condition 1 */ and not( /* condition 2 */ )
:Then
	// instructions 2
:End

Cela peut se remplacer par :

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

Relisez ces deux codes au moins 200 fois pour être sûr d'avoir compris. Bon, je vous donne quand même la traduction en français :

  • si la condition 1 est remplie, on exécute les instructions 1

  • si elle n'est pas remplie, ou bien qu'elle est remplie mais que la condition 2 n'est pas remplie, on exécute les instructions 2

Décortiquons pas à pas :

Prenons condition 1 et condition 2 comme remplies

Test de la condition : positif
=> instructions 1 exécuté

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

Test de la condition : positif
=> la ligne 5 est prise en compte

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

On tombe sur Else : les instructions qui
suivent sont considérées comme celles exécutées
quand condition 1 n'est pas remplie.
On saute donc jusqu'au End suivant.

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

Fin de la boucle

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End
Prenons condition 1 comme remplie et condition 2 comme fausse

Test de la condition : positif
=> instructions 1 exécuté

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

Test de la condition : négatif
=> la ligne 5 est sautée

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

Exécution de instructions 2
puis fin de la boucle

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End
Prenons condition 1 comme fausse (la condition 2 ne changera rien)

Test de la condition : négatif
=> le programme cherche s'il y a un Else

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

Il y a un Else : poursuite de
l'exécution à partir de cet endroit

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

Exécution de instructions 2
puis fin de la boucle

:If // condition 1
:Then
	// instructions 1
	:If // condition 2
:Else
	// instructions 2
:End

Exemples

Prenons condition 1 et condition 2 comme remplies
:If 1
:Then
:Disp "MSG1
:If 1
:Else
:Disp "MSG2
:End
MSG1
Prenons condition 1 comme remplie et condition 2 comme fausse
:If 1
:Then
:Disp "MSG1
:If 0
:Else
:Disp "MSG2
:End
MSG1
MSG2
Prenons condition 1 comme fausse (la condition 2 ne changera rien)
:If 0
:Then
:Disp "MSG1
:If 0
:Else
:Disp "MSG2
:End
MSG2
:If 0
:Then
:Disp "MSG1
:If 1
:Else
:Disp "MSG2
:End

Un End qui se termine ailleurs

Je tien tout d'abord à remercier 11TLP de m'avoir fait remarqué sur le topic Tout sur les TI ! que les End n'étaient pas bouclés lorsque l'on faisait un Goto. Après de nombreuses recherches, j'ai réussi à autoriser la création de routines à l'intérieur d'un même programme ! Et cela sans utiliser l'assembleur, donc c'est est compatible avec les TI-82 ! Allez, on commence. :ninja:

Un Goto dans une boucle

Exemple

Avez-vous déjà fait un Goto à l'intérieur d'une boucle ? Je le suppose, mais sans doute n'aviez-vous pas remarqué que l'appartenance à la boucle existait toujours. Voici un petit exemple :

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4

Résultat :

MSG1
MSG3
MSG1
MSG3
MSG1
MSG3
MSG4
        Done
Compréhension

Initialisation de A à 1 ;
affichage de "MSG1" ;
appel de l'étiquette 1

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4

Branchement à l'étiquette 1 effectué ;
affichage de "MSG3" ;
fin de la boucle => retour à la ligne 1

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4

Incrémentation de A : A = 2 ;
affichage de "MSG1" ;
appel de l'étiquette 1

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4

Branchement à l'étiquette 1 effectué ;
affichage de "MSG3" ;
fin de la boucle => retour à la ligne 1

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4

Incrémentation de A : A = 3 ;
affichage de "MSG1" ;
appel de l'étiquette 1

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4

Branchement à l'étiquette 1 effectué ;
affichage de "MSG3" ;
fin de la boucle => incrémentation de A : A = 4
donc A > 3 => la boucle est terminée et le
programme continue ici

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4

Affichage de "MSG4"

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4
Interprétation

Vous pouvez constater que certaines lignes ont été ignorées (elles n'ont jamais été exécutées) :

:For(A,1,3
:Disp "MSG1
:Goto 1
:Disp "MSG2
:End
:Stop

:Lbl 1
:Disp "MSG3
:End

:Disp "MSG4

On peut donc remplacer notre programme par :

:For(A,1,3
:Disp "MSG1
:Disp "MSG3
:End

:Disp "MSG4

Donc, jusqu'ici, notre programme ne servait strictement à rien. Mais si on se met à mettre une condition pour que le branchement de fasse, ça change tout ! On va pouvoir faire des routines.

Les routines

Enfin ! Je suis sûr que c'était un des trucs que vous attendiez le plus dans ce tuto !
Concrètement, on veut :

  • faire un branchement vers une étiquette

  • et puis faire qu'à la fin, l'exécution retourne au même endroit

Pour que l'exécution reprenne au même endroit, vous l'aurez compris, nous ferons un Goto à l'intérieur d'une boucle pour qu'à la fin de celle-ci, ça revienne à celle-ci. Je vous donne directement la solution :

La création de la routine

Il suffit de la faire commencer par un Lbl, puis de la faire terminer par End. Exemple :

:Lbl 3
:Input "A=",A
:Input "B=",B
:Input "C=",C
:End
L'appel de la routine

Dans une boucle For, on fait un Goto :

:For(A,-1,0
:If A:Goto 3
:End

La condition permet que le Goto ne se fasse qu'au premier tour de boucle pour que l'exécution ne se poursuive pas à partir du End de la routine.

J'espère ne pas vous avoir trop torturé l'esprit avec tout ça et que vous saurez en faire bonne utilisation !
Bon vent ! :ange:

N'hésitez pas à relire cette partie ! Elle comporte beaucoup de "trucs" qui s'oublient rapidement si on ne se rafraîchit pas de temps en temps la mémoire...

Exemple de certificat de réussite
Exemple de certificat de réussite