Cet article traite des idées fondamentales pour la programmation structurée, et donne quelques conseils pour écrire de meilleurs programmes en Small Basic.

Parler de 'Meilleurs Programmes' reste totalement subjectif, certains préféreront parler de style différents, mais il y a quelques règles générales qui peuvent vous y aider, en particulier lorsque vos programmes deviennent plus complexes.

GoTo

C'est certainement l'instruction la plus controversée et au sujet de laquelle les opinions divergent.

Normalement un programme exécute une ligne, puis la suivante, progressant à travers le code dans un  ordre logique. Il peut faire des boucles For ou While et exécuter un code différent en utilisant  If, ElseIf et EndIf. Le chemin emprunté lors de l’exécution du code et généralement appelé le "flux" du code. Nous essayons toujours à faire de sorte que ce flux soit le plus clair et logique possible.

Une instruction GoTo se contente de "sauter" n'importe où dans le code. Ce qui peut rendre le code très difficile à suivre et pratiquement impossible à déboguer ou à faire évoluer si on utilise ces instructions sans discernement. Toutefois, elles sont des notions naturelles pour un programmeur débutant avant qu'il apprenne d'autres manières de contrôler le flux du code.

Ci-dessous un exemple de code utilisant trop de GoTo - qu'est-ce qu'il est supposé faire et pourquoi ne fonctionne-t'il pas ?

x = 0
y = 0
For i = 1 To 100
  a:
  x = x+1
  b:
  x = x-1
  c:
  If (i < 10) Then
    Goto a
  Else
    y = y+1
    Goto b
  EndIf
  If (y < 3) Then
    Goto c
  EndIf
EndFor
 
TextWindow.WriteLine(x+" "+y)

L'exemple qui suit fonctionne très bien, mais est réellement difficile à suivre.

Goto start
clear:
TextWindow.Pause()
TextWindow.Clear()
Goto Start
start:
count = 0
enterNumber:
TextWindow.WriteLine("Entrer un nombre")
count = count+1
If (count = 1) Then
  num1 = TextWindow.ReadNumber()
ElseIf (count = 2) Then
  num2 = TextWindow.ReadNumber()
  Goto getOperation
EndIf
Goto enterNumber
getOperation:
TextWindow.WriteLine("Entrer une opération (+,-,*,/)")
operation = Textwindow.Read()
If (operation <> "+" And operation <> "-" And operation <> "*" And operation <> "/") Then
  Goto getOperation
Else
  Goto dosum
EndIf
result:
TextWindow.WriteLine(num1+operation+num2+"="+result)
Goto clear
dosum:
If (operation = "+") Then
  result = num1 + num2
ElseIf (operation = "-") Then
  result = num1 - num2
ElseIf (operation = "/") Then
  result = num1 / num2
ElseIf (operation = "*") Then
  result = num1 * num2
EndIf
Goto result

C'est ce que l'on appelle du code 'spaghetti'.

La règle générale et que pour chaque GoTo que vous utilisez, vous devez déterminer avec attention s'il existe une meilleure méthode pour le faire - il en existe presque toujours une. Il y a des situations où dans le Small Basic où le GoTo reste la meilleur option, mais elles sont très rares.

Vous ne devez jamais utiliser un GoTo pour sauter dans ou en dehors d'une sous-routine, sous peine de faire planter votre programme. Ceci est dû au fait que la "Pile d'Appels" devient endommagée. La pile d'appels est une structure interne qui contrôle l'endroit où la sous-routine "revient" lorsqu'elle se termine et elle est mise à jour lorsque la sous-routine est appelée et lorsqu'on en revient.

Sous-routines

Les sous-routines sont des blocs de code qui exécute une tâche spécifique. Souvent cette tâche est nécessaire à différents endroits de votre code, et les sous-routines évitent la duplication de code. Si vous avez écrit un code identique à différents endroits de votre programme, les sous-routines vous aideront très certainement.

Une sous-routine en Small Basic commence avec le mot clé Sub et se termine avec EndSub.  Elle peut ensuite être appelée en utilisant le nom de la sous-routine suivit de parenthèses ().

value = Math.Pi
roundResult()
writeOutput()
 
Sub roundResult
  result = 0.001*(Math.Floor(1000*value+0.5))
EndSub
 
Sub writeOutput
  TextWindow.WriteLine("la valeur actuelle arrondie à 3 décimales est "+result)
EndSub

Le bloc de code d'une sous-routine peut être placé n'importe où dans votre code, mais il est préférable de les placer tous ensemble après le code principal.

Souvent nous pouvons décomposer une tâche en plusieurs sous-tâches, chacune d'entre elles peut alors devenir une sous-routine. 

La longueur la sous-routine importe peu, évitez juste de découper un grand bloc de code en sous-routine sauf si cela correspond à des tâches spécifiques. Généralement notre code est bon lorsque le code ou les sous-routines principales (ou de haut niveau) sont assez courtes, ainsi il est facile de suivre la logique générale du programme.

La clé pour les sous-routine est:

  • La concevoir pour ne faire qu'une seule tâche - elle peut être tr��s générale comme "Initialisation du Programme" et inclure plusieurs sous-tâches ou alors très spécifique comme "Vérifier le chevauchement de 2 formes". Vous devez pouvoir décrire la tâche de la sous-routine juste en quelques mots, et ne pas être tenté de "juste ajoute une petite chose encore".
  • La rendre la plus générale possible - surtout si vous voulez réutiliser votre code dans d'autres programmes. Voir la section "Variables et Constantes".

Commentaires

Un commentaires commence avec une apostrophe ' et est affiché en vert. Tout ce qui suit est ignoré jusqu'à la fin de la ligne.

' Calcul la distance entre les objets
distance = Math.SquareRoot((x-a)*(x-a) + (y-b)*(y-b)) '(x,y) est le joueur

Les commentaires ne sont pas uniquement pour que les autres lisent votre code, ils vous permettent de vous rappeler plus tard pourquoi vous aviez fait les choses ainsi. Plus important encore ils montrent la "pensée" qui se cache derrière le code et les idées sur la manière dont le programmes doit fonctionner.

Essayez d'ajouter des commentaires qui expliquent quelque chose de complexe ou pourquoi vous avez quelque chose d'une manière ou d'une autre. Ils doivent vous rappeler et d'aider les autres à comprendre l'idée globale que vous aviez lorsque vous avez écrit le programme.

Mettre le "plus de commentaires c'est mieux" n'est pas très bon, les commentaires suivants n'apportent rien.

x = x+5 'Ajoute 5 à x

Parfois les commentaires permettent de séparer visuellement les sections de votre code comme le début des sous-routines.

'===================================================
'SOUS-ROUTINES
'===================================================

Les noms de variable

Essayez d'utiliser des noms descriptifs pour vos variables, il n'y a aucun impact de performance ou sur la mémoire à utiliser des noms longs pour les variables. Ne les faites pas trop longs quand même, mais soyez clair sur ce qu'elles sont.

Il y a des conventions pour le nommage des variables, mais la plus courante est d'utiliser des minuscules et de mettre une majuscule pour chaque mot sauf le premier (qui reste en minuscule).

Pour les boucle à compteur il est de tradition d'utilise une lettre seule, i, j, k etc.

playerTank = Shapes.AddImage(playerTankImage)
For i = 1 To numEnemy
  enemyTank[i] = Shapes.AddImage(enemyTankImage)
EndFor

Variables et constantes

Parfois dans votre code vous utilisez des valeurs qui sont fixes, peut-être un nombre d'ennemis, ou un offset pour placer une forme par son centre ou un texte utiliser pour poser une question.

C'est une bonne pratique de placer toutes ces constantes dans des variables, ainsi vous n'avez qu'a modifier la variable sans avoir à modifier votre constante dans tout votre code. Cela permet également de rendre votre code plus générique et ainsi d'être réutilisable ou d'utiliser plus intensément les sous-routines, réduisant ainsi la duplication de code. Toutes ces variables peuvent simplement être initialisée au démarrage dans une sous-routine.

GraphicsWindow.Show()
displayText = "Hello World"
For i = 1 To 11
  letter = Text.GetSubText(displayText,i,1)
  letterShape = Shapes.AddText(letter)
  For j = 1 To 100
    Shapes.Move(letterShape,20*i,j)
    Program.Delay(10)
  EndFor
  Program.Delay(100)
EndFor)

Le code ci-dessus est mieux écrit dans celui qui suit, ainsi nous pouvons facilement modifier les paramètres de la méthode si nous changeons la police par exemple.

Initialise()
displayText = "Hello World"
ShowText()
 
Sub Initialise
  GraphicsWindow.Show()
  characterOffset = 20
  movingLetterSteps = 100
  delayMovingLetter = 10
  delayLetter = 100
EndSub
 
Sub ShowText
  For i = 1 To Text.GetLength(displayText)
    letter = Text.GetSubText(displayText,i,1)
    letterShape = Shapes.AddText(letter)
    For j = 1 To movingLetterSteps
      Shapes.Move(letterShape,characterOffset*i,j)
      Program.Delay(delayMovingLetter)
    EndFor
    Program.Delay(delayLetter)
  EndFor
EndSub

Les Tableaux

Utilisez les tableaux lorsque c'est possible de regrouper des items. Par exemple si vous avez de plusieurs boutons, placez les tous dans un tableau. Dans l'exemple suivant tout ce dont nous avons besoin nous ajouter plus de boutons, et d'ajouter un élément dans le tableau "buttonText".

Initialise()
Controls.ButtonClicked = OnButtonClicked
 
Sub Initialise
  buttonText[1] = "Clear"
  buttonText[2] = "Start"
  buttonText[3] = "Run"
  buttonText[4] = "Pause"
  buttonText[5] = "Exit"
  numButton = Array.GetItemCount(buttonText)
  
  For i = 1 To numButton
    button[i] = Controls.AddButton(buttonText[i],60*i-50,GraphicsWindow.Height-40)
    Controls.SetSize(button[i],50,30) 'Equal size to look better
  EndFor
EndSub
 
Sub OnButtonClicked
  lastButton = Controls.LastClickedButton
  For i = 1 To numButton
    If (lastButton = button[i]) Then
      GraphicsWindow.ShowMessage(buttonText[i]+" was clicked","Information")
    EndIf
  EndFor
EndSub

Organisation du code

Indentation et espacement

Utilisez la fonction du Small Basic pour formater votre code. Vous pouvez la trouver en faisant un clic-droit et de sélectionner "Formater le programme".

Utilisez également des lignes vides pour séparer des morceaux de code, mais essayez de ne pas avoir trop de lignes vides placées au hasard.

Organisation du code

Mettez votre code principal au début, placez en dessous toutes les sous-routines, peut-être que vous devriez séparer les sous-routines des évènements.

Peut-être devriez vous également découper votre code principal en sections comme 'Initialisation et Configuration', 'Programme Principal' ou d'autres approches qui peuvent s'appliquer.

Planification

Essayez de réfléchir à la structure de votre programme dés de début, ensuite créez les sous-routines principales et les variables/tableaux et ajoutez progressivement les détails. Testez les détails dans de petit programmes prototypes en premier, puis ajoutez les dans votre programme principal.

La tentation sera grande d'ajouter tous les petits détails d'un programme dés le début et ensuite de construire une structure autour, mais attention car ça rendra votre code difficile à développer et à déboguer.



Autres Langues