Pour ma part j'essaye de plus en plus de faire des codes lisibles avec une grande facilité, et extrêmement commentés.
J'utilise la technique du super oignon : mon code complètement refermé ne sort pas de ma fenêtre Purebasic : l'ascenseur n'est pas présent.
De plus, je dois pouvoir déplier deux parties de mon code très éloignées, mais en les affichant proche, avec le pliage, ce qui permet de travailler sur des endroits différents.
Quand je reprend mon code, la seule instruction visible est le END principal du programme, (je n'ai généralement qu'un seul point de fermeture du programme).
Tout le reste est les commentaires décrivant le contenu des pliages.
Chaque niveau de pliage est décrit par un commentaire qui explique quel est le but général du code plié.
Bien sur, plus les pliages descendent dans le code, plus l'explication est pointue. Je ne commente pas chaque ligne de code, car je pense que certains bloc de code ne peuvent
conduisent à une seule fonction qui est indiquée sur le pliage.
Sinon, pour ce qui est de l'organisation générale des déclarations et procédure, je fais comme pas mal de gens d'après ce que j'ai lu
(je n'ai toujours pas compris l’intérêt de déclarer
les procédures en bas du code :
pour un programme fenestré :
Code : Tout sélectionner
;######################################
; programme :
; version :
; description :
; détails :
; ajouts prévus :
; auteur :
;######################################
;{ structure et variables globales
;{ Divers plugin (image, audio, database)
;{ Procédures
;{ Déclaration si nécessaire
;{ procédures pour Fonction 1
procédure nécessaire pour la principale
procédure principale de la fonction
;}
etc ...
;}
;{ lecture des passages de paramètre (si besoin)
;{ lecture des préférences (si besoin)
;{ Ouverture de la fenêtre principale + initialisation de certaines variables
;{ boucle principale
Repeat
event = WaitWindowEvent(100)
;{ event gadget
Until event = #PB_Event_CloseWindow
;}
;{ sauvegarde des paramètres et fermeture de la fenetre
End
;{ DATA SECTION
Les fenêtres :
Certains font des procédures spéciales pour déclarer les fenêtres, je trouve ça inutile et cela rend le code confus.
Généralement, je déclare ma fenêtre principale avant la boucle principale, puis je fais une procédure principale pour chaque nouvelle fenêtre créée,
avec la boucle gérant la fenêtre dans cette même procédure.
Lorsque j'utilise des gadgets statiques, je les nomme en utilisant le numéro de la fenêtre comme chiffre des centaines, ce qui permet de bien savoir ou on en est.
Les variables et constantes :
J'essaye de trouver le nom le plus descriptif possible pour les variables d'utilisation longues, comme :
Je n'utilise les majuscules que comme moyen visuel de démarquer certaines variables globales.
variables utilisées dans les itérations : a, b, c, i, j, k
variables à usage très court : tmp_nom_d_utilisation
Pour ce qui est des Goto et Gosub, je ne crois pas en avoir utilisé un seul depuis mon tout début en programmation Purebasic, lorsque je ne connaissais pas toute les boucles.
Je n'en ai jamais ressenti le besoin. J'ai le sentiment que cela ne ferais qu'embrouiller mon code au possible
voila, je pense avoir pas trop mal décrit la présentation de mes derniers gros programmes structurés
parce que pour les bouts de code de test, c'est la joyeuse anarchie
, je ne met en forme que si ça dépasse le stade du test et de l'idée