• 10 hours
  • Easy

Free online content available in this course.

You can get support and mentoring from a private teacher via videoconference on this course.

Got it!

Last updated on 1/7/13

Un script propre et lisible

Log in or subscribe for free to enjoy all this course has to offer!

Ce chapitre a un but très précis : vous savez maintenant comment créer une interface graphique, mais j'estime ce chapitre nécessaire pour vous apprendre à coder proprement vos futurs programmes.

Quand vous écrivez un script, il est bien de suivre certains principes de base, qui vous éviteront les foudres des plus doués, ou des remarques à répétition. :colere2:
La construction d'un script nécessite une rigueur toute particulière, car le moindre écart peut vous faire perdre un temps précieux, quelques fois pour une broutille.
Ici vont vous être présentés les quelques principes de base à respecter.

Tout est ok ? Alors installez-vous et commençons.

Le squelette de base

Ce chapitre va vous montrer comment rendre un code propre et lisible en six parties.

Nous allons donc suivre un squelette de base qui pourra être modifié selon les programmes, certaines parties étant parfois optionnelles.

  • I - Présentation de votre script

  • II - Déclarations des directives de compilation

  • III - Déclarations des Includes, variables, et autres

  • IV - Construction de votre GUI (Graphic User Interface)

  • V - Boucle d'attente d'une action sur la GUI

  • VI - Définition des fonctions utilisées dans le script

La Section II est optionnelle, elle n'est utilisée que lorsque vous souhaitez paramétrer votre compilateur, qui fonctionne très bien sans paramètres. :)

Si vous êtes prêt, attachez vos ceintures, ça va démarrer.

I - Présentation de votre script

Cette partie est en fait la présentation de votre script, et regroupe quelques informations de base que vous jugez intéressantes pour de futures mises à jour du programme.

Image utilisateur

La première information permet de savoir avec quelle version de AutoIt ce script a été construit et testé.
Parfois entre les différentes versions de AutoIt, certaines commandes ne sont pas utilisées de la même manière, ce qui peut rendre un script inutilisable.

Le reste des informations permet de savoir sur quelle plateforme peut fonctionner votre script, la description du script, et les différentes informations concernant l'auteur, ainsi que les versions.

Fort bien, mais tu m'as dit que les lignes commençant par ";" étaient des commentaires, alors on peut enlever tout ce passage !

En effet, ceci n'est que de l'information pure pour celui qui lira votre code. Mais ces informations sont très utiles lorsque vous aurez des problèmes de programmation et que l'envie vous prendra de vous faire aider. Un script bien commenté permet de se faire comprendre facilement et ce pour n'importe quel langage de programmation.
De plus, en jeunes padawans que vous êtes, vous ne pensez pas au futur. Mais croyez moi, le temps où vous écrirez des programmes de plus de 1000 lignes va très vite arriver, et vous serez content de vous y retrouver en codant proprement.

Maintenant que les informations sont données, on peut passer aux choses sérieuses... (ou pas :ange: ).

II - Déclarations des directives de compilation

Cette partie n'est pas toujours indispensable, puisqu'elle regroupe les directives utilisées lorsque vous souhaitez compiler votre .au3 en .exe.
En effet, lorsque vous souhaitez distribuer votre superbe programme à vos amis, vous avez besoin de le compiler, afin que vos amis aient juste à double-cliquer pour pouvoir le lancer. Mais pour cela, il faut utiliser un compilateur !

Cool, tu m'as emmené jusqu'ici pour me dire qu'il faut encore que je télécharge quelque chose...

Pas de soucis, tout est déjà bien en place. En effet, faites un clic droit sur un programme en Autoit (*.au3). Vous pouvez lire : Compile Script (ou Compiler le script, pour les anglophobes). Il suffit de cliquer et hop le .exe apparait.

Cependant, cette compilation va être "minimale", vous ne pourrez pas choisir une icône, ou encore la description. Pour cela, il faut cliquer sur "Compile With Options" pour voir apparaitre un utilitaire AutoItWrapper.

AutoItWrapper est un utilitaire permettant de compiler votre programme avec des options. Toutes les lignes ci-dessous sont des directives que lui seul comprend.

Image utilisateur
Image utilisateur

Voilà, vous savez maintenant comment compiler votre programme avec une icône, une description, etc...

III - Déclarations des Includes, variables, et autres

Attention, on arrive à une partie plus facile mais indispensable : les déclarations diverses.
C'est dans cette partie que l'on va placer les Includes et les variables locales et globales...

Image utilisateur

La première ligne, #include <GuiConstants.au3> sert à dire au programme que nous allons avoir besoin d'utiliser des fonctions stockées dans cet UDF (User Definition File), et donc de l'ajouter lors de l'exécution ou de la compilation. En effet, certains utilisateurs expérimentés créent leurs propres fonctions et les partagent avec les autres. C'est ce qu'on appelle un UDF. Les plus utilisés sont inclus dans AutoIt à l'origine, et sont de couleur bleu ciel dans Scite au lieu du bleu habituel. Vous pouvez les trouver facilement, ce sont celles qui commencent par un "_". Par Exemple : _FileToArray est un UDF, StringSplit est une fonction de base. Tous les UDFs sont en fait des scripts composés à partir des fonctions de base. Ils sont là pour vous simplifier la vie.

La deuxième ligne indique au compilateur de ne pas afficher l'icône du programme dans le systray. En effet, si vous ne mettez pas cette ligne, si vous créez un quelconque programme, une icône en forme de A s'affichera dans le SysTray (Barre Système en bas à droite de votre écran) qui vous permettra de quitter le programme à n'importe quel moment. Il est possible de modifier cette icône ainsi que le menu, mais ceci nécessite des fonctions avancées que nous verrons plus tard. Il vaut donc mieux l'enlever pour l'instant.

Toute une liste de déclarations peuvent être utilisées en fonction de vos besoins.
Consulter l'aide par la touche F1 section Keyword/Statement Reference.

Les deux dernières lignes servent à déclarer des variables.
Nous avons déjà vu comment déclarer une variable dans le tutoriel, ceci ne devrait pas vous poser trop de problèmes pour l'instant.

IV - Construction de votre GUI (Graphic User Interface)

Cette partie concerne la construction de votre interface graphique (GUI pour Graphic User Interface).
Pour ce faire, on crée d'abord la fenêtre principale puis on ajoute les différents éléments à utiliser.

La création de la GUI est liée à l'Include de GUIConstants.au3.
Sans cet Include, vous aurez une erreur au lancement du script. En effet, cet include contient toutes les constantes de windows qui vont paramétrer votre fenêtre.

Image utilisateur

Ce code vous affichera une fenêtre vide, du nom de Form1.

  • La première ligne indique que l'interface a été codée avec Koda. C'est un utilitaire qui vous est expliqué dans la partie II du tutoriel.

  • La deuxième ligne permet de délimiter la partie création de la GUI (ceci n'est pas obligatoire, mais permet une meilleure lisibilité du code).

  • La troisième ligne se compose de deux choses :

    • $Form1, qui récupère le handle de la fenêtre, et l'instruction de la création de la fenêtre.

    • Le fait de récupérer le handle de la fenêtre nous permettra d'intervenir sur celle-ci plus tard dans le code.

  • La quatrième ligne se compose aussi de deux choses :

    • $Button1, qui récupère le controlID (l'identifiant) du bouton que l'on va créer, puis la commande de création du bouton.

    • Le fait de récupérer le controlID du bouton, nous permettra d'intervenir sur celui-ci, ou d'intercepter des messages d'actions en provenance de celui-ci.

  • La cinquième ligne est la commande qui affiche la GUI. Vous pouvez grâce à cette commande, afficher ou masquer votre GUI.

  • Et la sixième ligne est le délimiteur de fin de la partie GUI (non obligatoire si vous n'avez pas mis la ligne de début de la GUI).

V - Boucle d'attente d'une action sur la GUI

Cette partie est également indispensable, puisqu'il s'agit de la boucle d'attente d'une action sur la GUI.

Sans cette boucle, votre interface apparaît mais disparaît aussitôt, sans que vous n'ayez le temps de voir quoi que ce soit.

Image utilisateur

Nous avons donc dans cette section une boucle While / WEnd dans laquelle on vient lire les messages venant de l'interface graphique par la commande GUIGetMsg(), et on attribue cette valeur à la variable $nMsg.
À chaque retour de boucle (WEnd), on recommence à lire GUIGetMsg(), et ainsi de suite.

À l'intérieur de cette boucle While / WEnd, nous utilisons la fonction Switch / EndSwitch pour faire une action en fonction de la valeur de $nMsg (nous aurions pu aussi utiliser la fonction Select / EndSelect).
Switch $nMsg permet de dire au programme : selon la valeur de $nMsg, traite le cas (Case) concerné.

Autrement dit :

  • Si vous cliquez sur la croix de fermeture de la fenêtre, la fonction GUIGetMsg() attribue à $Msg la valeur $GUI_EVENT_CLOSE, et donc lors du traitement par la commande Switch, nous sommes dirigés vers : Case $GUI_EVENT_CLOSE. Nous appliquons ensuite un appel à la fonction Fin() faisant partie de la section 6.

  • Si vous cliquez sur le bouton OK, alors la valeur de retour de GUIGetMsg() est $Button1, et donc la boucle effectue le traitement de Case $Button1, qui est en l'occurrence l'affichage d'une boite de dialogue "Info".

Il existe une autre méthode de traitement, qui consiste à gérer les actions sur l'interface selon un mode événementiel. Il n'y a pas de meilleure méthode, elles sont juste différentes. Le mode événementiel est peut-être plus adapté aux programmes lourds, mais la différence s'arrête là.

VI - Définition des fonctions utilisées dans le script

Cette partie n'est utile que si vous avez besoin d'utiliser des fonctions dans votre script.
Une fonction est une partie de code que l'on va appeler pour exécuter une suite d'actions.

Une fonction peut être appelée n'importe où dans le script, puis on reviendra à l'endroit de l'appel pour exécuter la suite du code.

Image utilisateur

Je ne détaillerai pas la fonction Fin() car elle est suffisamment commentée. N'oubliez pas de vous renseigner dans la documentation pour savoir ce que sont les commandes Splah[...]

Ce qu'il faut retenir, c'est que si l'on a besoin de faire une tâche régulièrement dans un code (lancer l'exécution d'une action depuis plusieurs endroits du code), il vaut mieux dans ce cas créer une fonction.
Pour information, les commandes que vous lancez à partir des Includes ne sont que des fonctions créées de la même manière.

Conclusion

Je vous donne ci-dessous le code complet que vous pouvez tester. Vous voyez qu'il est aisément compréhensible car aéré, commenté à souhait, et clair.

; ----------------------------------------------------
; -------------------- Section I --------------------
; ----------------------------------------------------
; Version AutoIt :    3.2.8.1
; Langue     :        Francais
; Plateforme :        Win9x/XP
; Auteur    :        Tlem (tlem at tuxolem dot net)
;
; Fonction du script: Démonstration de la construction d'un script.
;
;
;
; Version 1.0 : 21/11/2007
;           - Première Version.
;

; ----------------------------------------------------
; -------------------- Section II --------------------
; ----------------------------------------------------
; Début de section des directives.
#Region Compiler directives section

; Utiliser pour la compatibilité avec Win98 (Y).
#AutoIt3Wrapper_UseAnsi=N
; Icone(s) à rajouter dans les ressources de l'application compilée (Accepte les chemins relatifs).
#AutoIt3Wrapper_Res_Icon_Add=./Res/Icon.ico
; Icone de l'application compilée.
#AutoIt3Wrapper_Icon=./Res/Icon1.ico
; Nom du fichier compiler.
#AutoIt3Wrapper_OutFile=../Demo_v1.0.exe
; Format de sortie de l'application (A3X ou EXE).
#AutoIt3Wrapper_OutFile_Type=exe
; Déscription du script.
#AutoIt3Wrapper_Res_Description=Démo script
; Commentaire du script
#AutoIt3Wrapper_Res_Comment=Utilitaire de démo
; Version du script.
#AutoIt3Wrapper_Res_Fileversion=1.0
; Activation de l'incrémentation de version automatique.
#AutoIt3Wrapper_Res_FileVersion_AutoIncrement=n

; Information complèmentaire : Nom interne
#AutoIt3Wrapper_Res_Field=Nom Interne|Démo Script
; Information complèmentaire : date de compilation (Utilisation d'une variable).
#AutoIt3Wrapper_Res_Field=Compilation Date|%date%
; Information complèmentaire : heure de compilation (Utilisation d'une variable).
#AutoIt3Wrapper_Res_Field=Compilation Heure|%time%
; Information complèmentaire : version de AutoIt (Utilisation d'une variable).
#AutoIt3Wrapper_Res_Field=Version du Compilateur|AutoIt v%AutoItVer%

; Information complèmentaire : Entreprise.
#AutoIt3Wrapper_res_Field=Entreprise|Tuxolem Software
; Information complèmentaire : auteur.
#AutoIt3Wrapper_Res_Field=Créer par|Tlem
; Information complèmentaire : Email de l'auteur.
#AutoIt3Wrapper_Res_Field=Email|tlem at tuxolem.net
; Information complèmentaire : Copyright ou Copyleft.
#AutoIt3Wrapper_Res_LegalCopyright=Copyright (C) 2003-2007 Tuxolem Software
; Information complèmentaire : Langue du script.
#AutoIt3Wrapper_Res_Language=0x040c

; Utilisation de tidy lors du lancement du script (F5).
#AutoIt3Wrapper_run_tidy=y
; Paramètre de sauvegarde Tidy (Copie de sauvegarde du script  0 = Garde toutes les versions).
#Tidy_Parameters= /kv 0
; Utilisation de la compression pour générer l'EXE.
#AutoIt3Wrapper_UseUpx=y
; Taux de compression (2 est une bonne valeur).
#AutoIt3Wrapper_Compression=2
; Controle du script avec AU3Check
#AutoIt3Wrapper_Run_AU3Check=n
; Action à réalisée avant compilation.
#AutoIt3Wrapper_Run_Before=
; Action à réalisée après compilation.
#AutoIt3Wrapper_Run_After=

; Fin de la région directives.
#EndRegion


; ----------------------------------------------------
; -------------------- Section III --------------------
; ----------------------------------------------------
; Déclarations Diverses.
#include <GuiConstants.au3>
#NoTrayIcon

; Déclaration des variables.
Global $Largeur = 400, $Hauteur = 100, $Titre = "Form1 "
Local $Ver = "V1.0"


; ----------------------------------------------------
; -------------------- Section IV --------------------
; ----------------------------------------------------
#Region ### START Koda GUI section ###

; Fenetre principale.
$Form1 = GUICreate($Titre & $Ver, $Largeur, $Hauteur, -1, -1)
; Bouton OK.
$Button1 = GUICtrlCreateButton("OK", 150, 50, 75, 25)

GUISetState(@SW_SHOW)

#EndRegion ### END Koda GUI section ###


; ----------------------------------------------------
; -------------------- Section V --------------------
; ----------------------------------------------------
While 1
    $nMsg = GUIGetMsg()
    Switch $nMsg
        Case $GUI_EVENT_CLOSE
            Fin()

        Case $Button1
            MsgBox(64, "Info", "Vous avez cliqué le Bouton OK")

    EndSwitch
WEnd


; ----------------------------------------------------
; -------------------- Section VI --------------------
; ----------------------------------------------------
#Region ################### Fonctions ###################
Func Fin()
    ; Lancement du splash screen.
    SplashTextOn("", "Fermeture du script en cours,  Veuillez patienter ...", 450, 70, -1, -1, 0 + 1 + 16 + 32, "Times New Roman", 12, 800)

    ; Pause de 3 secondes.
    Sleep(3000)

    ; Fermeture du splash.
    SplashOff()

    Exit
EndFunc   ;==>Fin
#EndRegion ################### Fonctions ###################

Je vais vous donner un petit récapitulatif.
Quand vous codez, n'oubliez jamais de :

  • Donner des noms compréhensibles aux variables, ni trop courts, ni trop longs.

  • Commenter les parties difficiles, les fonctions.

  • Aérez votre code, n'hésitez pas pour cela à passer par des fonctions.

  • Donnez des informations aux lecteurs sur l'utilité de votre programme, etc...

  • Indentez votre code grâce à votre éditeur préféré.

Et maintenant, avant de se quitter, je vais vous parlez de AutoIt Tidy, un utilitaire qui vous aidera à maintenir un script aéré et indenté. Eh oui, on a pensé à vous, et ceci est là pour vous simplifier la vie, encore une fois. Alors n'hésitez pas, et utilisez le en permanence avant de distribuer un script. Avec Scite4Autoit un simple Ctrl + T suffit à lancer Scite, qui vous rendra un script merveilleusement... propre et lisible !

Voilà, maintenant vous n'avez plus aucune excuse pour ne pas présenter un script propre et lisible.

Ne lésinez jamais sur les commentaires, mais n'en abusez pas. Il faut trouver le juste milieu. Si vous avez suivi le concours du Site du Zéro sur les Sudoku, vous avez remarqué que tous les scripts bien notés étaient propres, lisibles, commentés, et que cela jouait sur la note. Alors autant prendre de bonnes habitudes tout de suite. ;)

Example of certificate of achievement
Example of certificate of achievement