Ce langage n'est utile que pour les boulets qui jouent aux jeux en ligne avec des bots.C'est un langage avec très peu de fonctions (pauvre).Ce langage ne gère pas le graphique (création d'interface).En gros? Ce langage ne sert à rien...Otez-vous tout de suite ces idées de la tête!!!
L'Autoit, depuis sa version 3, est un langage puissant. D'ailleurs, après une petite liste de choses fausses, voilà quelques exemples des avantages d'Autoit.
Facile à apprendre grâce à une syntaxe proche du BASIC.Possibilité de manipuler les fenêtres, les process', le registre, les fichiers, les objets WMI ...Possibilité d'interagir avec les fenêtres existantes.Possibilité de créer votre exécutable (rend le programme utilisable sur n'importe quelle machine) très facilement.Possibilité de créer des Interfaces Graphiques Utilisateurs (GUIs) de qualité.Supporte des objets Com et des expressions régulières.Peut appeler les DLL et les fonctions API de windows.Peut exécuter vos programmes avec les droits d'administrateur.Documentation très complète, facile à prendre en main, exemples pour chaque fonction... (Anglais officiel, mais Français en cours de traduction, je vous l'expliquerai plus tard)Compatible avec Windows 95 / 98 / ME / NT4 / 2000 / XP / 2003 / Vista / 2008 / Seven Sa grande force est de ne pas avoir besoin de compiler vos scripts à chaque fois que vous voulez les tester.Possibilité de simuler des mouvements, des clics et des sélections avec la souris, ainsi que l'appui sur des touches de votre clavier.(ce langage est à la base conçu pour cela)
Envie d'essayer ? C'est gratuit et la progression est rapide, alors suivez le guide! ]]>
L'éditeur intégré Scite (en version light).L'éditeur Scite4Autoit3 non intégré mais que je vous conseille vivement de télécharger car il possède des fonctionnalités super utiles pour les codeurs (donc vous :p ), comme l'explique le paragraphe suivant.Un autre éditeur (il en existe des centaines) (le bloc-notes peut suffire ;).
Nous verrons prochainement comment compiler un programme Autoit ,c'est à dire créer un executable qui sera compris par tous les ordinateurs sans aucune installation préalable. Les Executables ont une extension .exe, et nous verrons comment procéder très facilement avec Autoit.
Cependant,l'un des avantages est qu'il suffit de double-cliquer sur votre script pour le voir s'exécuter. Pas besoin d'installer un IDE complexe et lourd, pas besoin de compiler, le simple programme AutoIt.exe et le bloc-notes suffisent pour créer et exécuter un script AutoIt.
C'est génial non ? :D
Maintenant que vous en savez un peu plus, on va pouvoir le télécharger et l'installer.
Autoit ne fonctionne pas sous un noyau Linux. Il a été conçu pour Windows. Cependant, c'est aux dernières nouvelles l'un des rares langages qui permet d'afficher une Interface sous Windows Core !]]>
Le paragraphe qui suit dans le spoiler si dessous est la première version qui a été écrite au commencement de la rédaction de ce tutoriel. Mais le temps est ce qu'il est, pendant que certains rédigeaient ce tutoriel, un boulet de première un super programmeur a créé un Programme D'Installation Français Automatique qui va nous être utile. Si vous voulez vous simplifier la vie, sautez le paragraphe qui suit.
Installation Semi-AutomatiqueIl est peut-être temps de télécharger, non ? :-°
Autoit n'est plus compatible avec Windows 95, 98, ME et NT 4 dans ses version supérieures à la v3.2.12. Cependant les versions compatibles (antérieures à la v3.2.12) sont toujours disponibles ici.
Si votre disposez d'un OS superieur à Windows XP, rendez-vous ici.
Vous devez télécharger le package suivant:
AutoIt Full Installation (lien direct)
Et je vous conseille vivement de télécharger également Scite4Autoit3, qui est un éditeur très puissant, qui facilite la saisie du code, le débugage, la compilation d'exe ,et beaucoup d'autres choses encore.
SciTE for AutoIt3 (SciTE4AutoIt3.exe) (lien direct)
Pour l'installation, ne vous tracassez pas, appuyez toujours sur «suivant». ;)
Enfin, si vous voulez avoir les menus de SciTE en Français (c'est toujours plus sympa ;) ), téléchargez le fichier suivant et enregistrez le sous "C:\Program Files\AutoIt3\SciTE\locale.properties" (si AutoIt est installé dans "C:\Program Files\AutoIt3")
Menus SciTE en français (lien direct)
Si l'installation n'a pas réussie, vérifiez que vous avez bien choisi le bon package, désinstallez AutoIt et re-téléchargez-le.Installation Automatique En Français
Le pack AutoIt-Fr est un package complet qui permet de supprimer toute ancienne installation de AutoIt et/ou d'installer la dernière version de AutoIt agrémentée de quelques addons.
Si vous avez modifié des fichiers de configuration, pensez à les sauvegarder avant de procéder à la suppression d'une installation antérieure.
Ce pack d'installation installe tout d'abord AutoIt v3 puis Scite4AutoIt.
Puis il va changer la couche du bébé de la voisine faire tout ça :lol: :
Mise en Français des menus de Scite. Ajout de l'addon OrganizeInclude (faire SHIFT+CTRL+ALT+I sous scite). Mise à jour de la dernière version de Koda. Mise en Français des menus contextuel de l'explorer. Mise en Français du template de nouveau fichier .au3. Mise en Français du nom des mois et des jours de la semaine dans les UDF Date.au3 et GuiMonthCal.au3.
Vous l'avez compris, cet outil est destiné à vous simplifier la vie. Nous verrons plus tard à quoi servent OrganizeInclude et Koda.
---> Télécharger le programme d'installation du pack (15Mo). <---
Si vous souhaitez supprimer toutes traces de ce pack, réinstallez-le, validez la suppression de la version antérieure et arrêtez vous à l'étape proposant l'installation (Pensez à sauvegarder vos paramètres perso et/ou UDF perso).
Voilà pour cette première partie, vous avez donc les outils nécessaires pour coder comme un dieu. :D
Bien, maintenant «AutoIt v3» apparaît normalement dans vos programmes...
]]>
Pas d'inquiétudes pour ceux qui ont utilisés le pack Autoit-fr. Ils ont bien les 2 packages d'installés, et même plus :-°
Présentation des OutilsPour plus de clarté dans la lecture de ce tutoriel, cette sous-partie a été déplacée dans la partie ANNEXE de ce tutoriel. Nous vous conseillons cependant d'aller y faire un tour, si ce n'est succintement.
Vous constatez que vous disposez de nombreux outils tous plus utiles les uns que les autres.
Ils vous seront plus ou moins représentés tout au long de ce tutoriel.
Attention, à partir de cette ligne , nous ne somme plus responsables des problèmes liés à la lecture de ce tutoriel :diable: .
(Ou plus simplement, on va vraiment attaquer!)]]>
Cependant, Il existe une traduction partielle disponible en ligne
Et quand vous bloquez, vous pouvez toujours poser vos questions sur le forum de la communauté française:
http://autoitscript.fr ou encore http://autoit.fr
Cette dernière est très active et il existe déjà de nombreux tutoriels disponibles pour en apprendre encore plus. Dès que vous aurez terminé ce tutoriel et lorsque vous aurez un problème, je vous conseille vivement d'aller y faire un tour. Si vous respectez les règles du forum (de simples règles de présentation et de courtoisie), les réponses arriveront rapidement comme sur un plateau ^^
Enfin, sachez que vous pouvez vous renseigner sur le forum américain pour vos questions les plus poussées (avec plus de 20 000 membres, il y a d'autant plus d'experts ...). Cela dit, pour la plupart de vos problèmes, la communauté française suffira.]]>
Toutes les images des fenêtres et boites de dialogue sont en Anglais (traduction oblige) donc les différentes informations affichées le seront aussi. Certains termes utilisés seront "francisés", pour correspondre à ce que vous verrez sur votre machine, mais d'autres non !
Pour commencer, ouvrez un dossier dans lequel vous désirez créer votre script. Faites un clic droit dans le dossier et sélectionnez "Nouveau", puis "AutoIt v3 Script".uploads/fr/files/133001_134000/133543.pngUn nouveau fichier est créé, et vous êtes invité à le renommer en quelque chose de plus approprié. Remplacez 'Nouveau AutoIt v3 Script.au3' par 'helloworld', tout en laissant l'extension '.au3' si elle est visible.uploads/fr/files/133001_134000/133544.pngMaintenant que nous avons créé le fichier que nous voulons éditer afin d'en faire quelque chose d'utile, faites un clic droit sur helloworld.au3 et sélectionnez "Edit Script". uploads/fr/files/133001_134000/133548.pngL'éditeur SciTE s'ouvrira et vous verrez quelque chose comme ceci :uploads/fr/files/133001_134000/133545.pngLe code que vous voyez est simplement une suite de commentaires que vous pouvez utiliser pour organiser vos scripts. Toutes les lignes qui commencent par un point virgule ; sont considérés comme des commentaires et seront donc ignorées.; est similaire à la déclaration REM dans un traitement par lots DOS, ou encore à // en Php.
Vous pourrez quelque fois rencontrer ;~ qui introduit également un commentaire ou plus fréquemment #comments-start qui peut être réduit à #cs et #comments-end qui peut être réduit à #ce si vous avez beaucoup de texte à commenter.
Maintenant, nous allons dire à AutoIt d'afficher une boite de dialogue - Pour cela nous allons utiliser la fonction MsgBox.En dessous des lignes de commentaires, tapez ceci :
MsgBox(0, "Tutoriel", "Hello World!")
Toutes les fonctions ont des paramètres, MsgBox en a trois : un flag (indicateur), un titre et un message. Le flag est un nombre qui change la manière d'afficher la MsgBox - nous utiliserons 0 pour l'instant. Le titre et le message sont tous deux une String (chaîne de caractères) - quand on utilise des Strings dans AutoIt il faut encadrer le texte avec de simples (Apostrophe) ou doubles guillemets. "Ceci est du texte" ou 'Ceci est du texte' - les deux fonctionneront parfaitement. Ceci et ce qui suit est d'ailleurs vrai pour la plupart des fonctions d'Autoit incluant une commande à texte.Astuces :
pour inclure une apostrophe dans une chaîne encadrée par des guillemets simple, il faut la doubler.
MsgBox(0, "Tutoriel", 'Ceci est une partie d''un texte')
pour inclure des doubles guillemets dans une chaîne encadrée par des guillemets doubles, il faut le doubler.
MsgBox(0, "Tutoriel", MsgBox(0,"", "Avec AutoIt c'est ""simple"""))
Maintenant enregistrez le script et quittez l'éditeur. Vous venez d'écrire votre tout premier script AutoIt !
Pour lancer, double-cliquez simplement sur le fichier helloworld.au3 (vous pouvez aussi faire un clic droit et sélectionner Run Script).Vous devriez voir ceci :uploads/fr/files/133001_134000/133546.pngMaintenant, examinons le paramètre flag pour la fonction MsgBox. Dans la page d'aide de AutoIt, nous pouvons voir différentes valeurs listées qui changent la manière d'afficher la MsgBox. La valeur 0 affiche une simple boite de dialogue avec un bouton OK. Une valeur de 64 affiche la boite de dialogue avec une icône d'information.Éditez le script (un clic droit sur le fichier helloworld.au3, puis Edit Script), et remplacez le 0 par 64. Vous avez donc :
MsgBox(64, "Tutoriel", "Hello World!")
Enregistrez le script puis lancez le (vous pouvez aussi appuyer sur F5 dans la fenêtre d'édition pour lancer le script à partir de l'éditeur). :uploads/fr/files/133001_134000/133547.pngN'hésitez pas à expérimenter avec différentes valeur pour le paramètre flag afin de voir quel genre de résultat vous obtiendrez.Attention : Si vous voulez combiner plusieurs valeurs de flag, vous n'avez qu'à tout simplement additionner les valeurs souhaitées. Vous pouvez aussi les écrire comme ceci :
MsgBox(4 + 32, "Tutoriel", "Vous allez bien ?")
La commande msgbox possède plusieurs groupes de valeurs pour le flag.
Chaque groupe permet d'influencer les boutons (nombre et fonction), le bouton par défaut, l'icône affichée, le comportement de la fenêtre, etc ...
Il existe aussi un groupe spécial qui permet même de savoir quel bouton à été appuyé afin de gérer une action en fonction d'un choix.]]>
Tout d'abord, c'est quoi une variable?
Une variable est un endroit ou l'on stocke une donnée en mémoire afin de pouvoir y accéder rapidement. Vous pouvez penser à une boite aux lettres qui vous permet soit de mettre du courriel, soit d'en retirer, ou encore de lire le courriel sans l'enlever de la boite aux lettres. Par exemple, vous pouvez créer une variable pour stocker la réponse d'une question posée à l'utilisateur, ou le résultat d'une équation mathématique.
Chaque variable a son propre nom unique ( De même pour une boîte aux lettres ), doit commencer par le caractère [$]dollar, et ne peut contenir que des lettres, des nombres et le caractère [_]tiret bas.
Quelques exemples$var1$my_variable $ce_tuto_est_vraiment_genial
Quand vous créez une variable, son nom doit être significatif . Si vous créez des centaines de variable dans un code et que vous ne savez pas ce que représente chaque variable, vous allez avoir beaucoup de mal à le comprendre :) .
La Portée d'une variable
Il y a trois différentes méthodes pour déclarer une variable :
Une déclaration s'effectue grâce aux mots-clés Dim, Global et Local
La différence entre Dim, Local et Global est leur portée dans le script :
Dim = Portée locale si la variable n'existe pas déjà globalement (Dans ce cas ré-utilise la variable globale !).Global = Force la création d'une variable de portée globale.Local = Force la création d'une variable de portée locale ou interne à une fonction.Dans la plupart des langages,une variable doit être déclarée. Cependant, avec Autoit, on peut s'en passer. Il suffit d'écrire le nom de la variable, sans passer par Local, Gloval ou Dim.
Certaines personnes préfèrent les déclarations préalables pour rester habitué à ne pas les oublier dans d'autres langages. N'est ce pas magique?Pour simplifier
Dim = Création d'une variable (redéfinissable) dont la valeur ce retrouve uniquement dans le script en cours (Cette variable ne peut être récupérée dans un Include, ou par un Include).
Local = Même chose que précédemment, mais peut aussi limiter la portée de la variable dans une fonction (Dans ce cas, faire la déclaration dans la fonction).
Global = Création d'une variable (redéfinissable) dont la valeur ce retrouve partout, y compris dans les Includes.
Vous pouvez ajouter le mot Const après Local, Global, ou Dim. Dans ce cas, la variable devient une constante, c'est à dire qu'elle ne changera jamais.
ExemplesDim$var1
Ici on declare localement la variable $var1Dim$var1, $myvariable
Ici, on déclare les 2 variables $var1 et $myvariable$var1 = "create and assign"
On assigne une chaîne de caractères à la variable $var1 sans l'avoir déclarée premièrement.Global Const$const1 = 1
La variable $const1 aura maintenant pour valeur 1 et tout le long du code elle ne pourra pas en changer.]]>
Les Actions Sous Conditions
Comment fonctionnent les actions sous condition ?
Un des piliers de la programmation tout language confondu est "l'action sous condition".
Cela se présente sous la forme :
SI (proposition-à-vérifier est vraie ou fausse) ALORS :
...
on fait ça
...
SINON
...
on fait ça
...
FINI
Toute la profondeur d'un programme est basée sur cette architecture.
En Autoit on a :
If (proposition-à-verifier est vraie ou fausse) Then
; Actions à effectuer
Else ;Si n'importe quoi d'autre
; Actions à effectuer
EndIfAfficher un message personnalisé en fonction du jour
Que pensez vous d'un mini-tp? C'est très simple, vous demandez à l'utilisateur le jour, et vous lui répondez en fonction de ce jour!
On demande à l'utilisateur de rentrer le jour d'aujourd'hui : La fonction InputBox semble tout indiquée.
Pour savoir comment l'utiliser, utilisez l'aide comme nous vous l'avons appris. (Pour ceux dont la mémoire joue des tours, il faut appuyer sur F1 dans Scite4Autoit.)On récupère la variable $jour, et on la traite.
Essayez de faire ce programme tout seul, sinon voilà une solution :
$jour = InputBox("Tutorial", "Quel jour sommes nous ?")
If ($jour = "Vendredi") Then
msgbox(0,"Tutorial","c'est bientôt le weekend !")
Else
If ($jour = "Lundi") Then
msgbox(0,"Tutorial","Bon début de semaine !")
Else
msgbox(0,"Tutorial","Comment se passe la semaine ?")
EndIf
EndIfVoila en quelques lignes comment agit le programme :Que se passe-t-il si nous rentrons "Lundi" ?
La première condition If ($jour = "Vendredi") est fausse, on saute donc les actions présentes dans le "If" et on continue dans le "Else".
On arrive alors à un deuxième si-alors, la condition ($jour = "Lundi") est vraie ! On effectue donc les actions présentes dans le If, c'est à dire afficher "Bon début de semaine !", et on saute les actions présentes dans le Else.
Que se passe-t-il si nous rentrons Mardi ?
La première condition If ($jour = "Vendredi") est fausse, on continue dans le Else
On arrive à la seconde condition If ($jour = "Lundi") qui est fausse également, on continue donc dans le Else, et on affiche donc "Comment se passe la semaine ? " .
Que se passe-t-il si nous rentrons Vendredi ?
La première condition If ($jour = "Vendredi") est vraie !
On effectue donc les actions présentes dans le If, c'est à dire afficher "C'est bientôt le weekend !", et on saute le Else.
Les Opérateurs
Nous avons vu le = dans l'exemple précédent, mais il y'en a d'autres :
Image
Exemple 1 :
L'utilisateur doit rentrer le bon mot de passe pour lancer le programme.
Code:
$pass = "mot de passe"
$input = InputBox("Tutorial", "Entrez le mot de passe :")
If ($input <> $pass) Then
MsgBox(0,"Tutorial", "Mauvais mot de passe !")
Else
MsgBox(0,"Tutorial", "Le mot de passe est correct !")
EndIf
Exemple 2 :
Notre programme vérifie si le nombre entré par l'utilisateur est bien positif ou nul.
Code:
$nombre = InputBox("Tutorial", "Entrez un nombre :")
If ($nombre >= 0) Then
MsgBox(0,"Tutorial", "Ce nombre est positif.")
Else
MsgBox(0,"Tutorial", "ce nombre est négatif.")
EndIf
Il est également possible de faire des propositions plus élaborées grâce aux opérateurs ET, OU qui se traduisent en Autoit par AND , OR.
Exemple 3 :
L'utilisateur doit rentrer un bon mot de passe parmi 2 possibles.
Code:
$pass1 = "mot de passe"
$pass2 = "autoit fr"
$input = InputBox("Tutorial", "Entrez le mot de passe :")
If ( ($input <> $pass) AND ($input <> $pass1) ) Then
MsgBox(0,"Tutorial", "Mauvais mot de passe !")
Exit
Else
MsgBox(0,"Tutorial", "Le mot de passe est correct !")
...suite...
EndIf
Notez que If $input = $pass OR $input = $pass1 Then marche également.Exemple 4:
Notre programme vérifie si le nombre entré par l'utilisateur est bien compris entre 0 et 10.
Code:
$nombre = InputBox("Tutorial", "Entrez un nombre :")
If (($nombre >= 0) AND ($nombre <= 10)) Then
MsgBox(0,"Tutorial", "Ce nombre est compris entre 0 et 10.")
Else
MsgBox(0,"Tutorial", "Ce nombre n'est pas compris entre 0 et 10.")
EndIf
Astuce pour l'action sous Conditions
Si une proposition est dure à trouver, essayez la technique suivante : (lire attentivement, ce n'est pas forcement très clair à la première lecture :) )
Vous n'arrivez pas à trouver la proposition (1) à mettre pour que l'action s'effectue,
essayez alors de trouver la proposition (2) à mettre pour que l'action NE s'effectue PAS
Il suffira alors d'un peu d'astuce pour trouver la (1) à partir de la (2).
Essayons sur l'exemple 3 :
Dans cet exemple nous voulions afficher un message d'erreur si le mot de passe entré par l'utilisateur ne correspondait à aucun des 2 mots de passes enregistrés dans le programme, et continuer dans le cas contraire.
Or, nous n'arrivons pas à trouver la proposition correspondante.
Cherchons donc la proposition pour que le message d'erreur ne s'affiche pas.
=>Le programme ne doit pas afficher d'erreur si le mot de passe fourni par l'utilisateur correspond à l'un des 2 mots de passes enregistrés dans le programme.
On aurait donc la proposition suivante : If ( ($input = $pass1) OR ($input = $pass2) ) )(2)
Cette proposition peut être plus facile à trouver.
La proposition (1) se trouve en inversant la (2), en utilisant la correspondance suivante :
Image
( ($input = $pass1) OR ($input = $pass2) ) (2) ==> ( ($input <> $pass) AND ($input <> $pass1) ) (1)
On retrouve bien notre proposition.
On aurait donc pu écrire notre exemple 3 de la manière suivante :
Code:
$pass1 = "mot de passe"
$pass2 = "autoit fr"
$input = InputBox("Tutorial", "Entrez le mot de passe :")
If ( ($input = $pass1) OR ($input = $pass2) ) Then
MsgBox(0,"Tutorial", "Le mot de passe est correct !")
Else
MsgBox(0,"Tutorial", "Mauvais mot de passe !")
EndIf]]>
Qu'est-ce qu'une boucle ?
Les boucles permettent de répéter une même action plusieurs fois, en n' écrivant qu'une seule fois la procédure.
3 genres de boucles s'offrent à vous, plusieurs critères permettent de choisir la plus adaptée à votre cas.
Boucle de type "Pour" (For - Next) :
Cette boucle s'utilise lorsque le nombre de fois que nous devons parcourir la boucle est DÉTERMINÉ.
Que ce soit une constante, ou une valeur contenue dans une variable, si ce nombre est accessible par le programme alors cette boucle est la plus adaptée.
Fonctionnement :
Cette boucle fonctionne à l'aide d'un compteur qui utilise une variable généralement appelée $i.
Code:
For $i = To Step
; Actions à effectuer
Next
Exemple 1
Code:
For $i = 0 To 10
msgbox(0,"Tutorial", $i)
Next
Ceci nous affichera : 0,1,2,3,4,5,6,7,8,9,10 successivement.
Et si je ne veux afficher que 0,2,4,6,8 10, je fais comment?
Il suffit de rajouter un "Step 1" à la fin de la ligne For Comme ceci:
For $i = 0 To 10 Step 2
msgbox(0,"Tutorial", $i)
Next
0n a maintenant : 0,2,4,6,8,10
Exemple 2
Compte à rebours :
Je voudrais que vous fassiez un mini-mini-tp. (Ne prenez pas peur ;))
Très simple, il faut demander à l'utilisateur de rentrer un nombre, puis le programme va afficher une message box avec ce nombre et quand l'utilisateur cliquera dessus, le nombre du dessous apparaîtra... Magique? Non! (Oh,Oh,Oh, It's Magic, you know...)
Fini? Ca devrait ressembler à quelque chose comme ça:
Code:
$depart = InputBox("Tutorial", "Entrez un nombre :")
For $i = $depart To 1 Step -1
MsgBox(0,"Tutorial", $i)
Next
MsgBox(0,"Tutorial", "ZERO !")
Vous n'avez pas fait la même chose ? Ce n'est pas grave, je vous donne une chance de vous rattraper plus bas ! ;)
Boucle de type "Tant que" :What is this?
Cette boucle s'utilise quand le nombre de fois que l'action doit être effectuée est inconnu. Si la proposition est fausse dès le départ, la boucle ne se lance pas.
Cette boucle n'a pas besoin de compteur pour fonctionner, la boucle est simplement effectuée tant que la condition reste vraie.
Fonctionnement :
Code:
Tant que (condition est vraie)
On effectue ces actions
Fin
Ce qui se traduit en Autoit par :
While [signifie littéralement tant que] (proposition est vraie)
;Actions à effectuer
WEndExemple
Les Boucles sont très utilisées pour attendre une action de l'utilisateur. En effet, il est impossible de savoir exactement quand l'utilisateur va enfin se décider à faire quelque chose. Alors c'est au programme de l'attendre (L'utilisateur est beaucoup plus long, si si je vous assure :lol: )
Cesses tes bavardages inutiles, et continue ton tutoriel!
Ok les amis, Restons Calmes ! :-°
Imaginons que la variable $quitter prenne la valeur 1 quand l'utilisateur décide de quitter le programme.
On a donc
While ( $quitter <> 1 )
;Actions du programme
WEnd
Très souvent, on va utiliser une boucle sans fin, c'est à dire que théoriquement elle ne s'arrêtera jamais.
Pour faire une boucle sans fin, on peut déclarer une boucle tant-que de la manière suivante :
While 1
;action à répéter sans fin
WEnd
Cette Boucle est ce que l'on peut appeler la partie principale du programme. Celui ci va se balader dans la boucle en permanence, et si il rencontre des If valables (Cf Actions Sous Conditions), il va faire différentes actions.
Ne Copiez Pas tel quel le code ci-dessus, en effet, le programme va peut-être faire planter votre ordinateur car il va en permanence utiliser votre CPU car aucune action n'est inscrite dans ce code. Essayez pour voir, mais que ceux qui ont des ordinateurs de l'an 2008 (Totalement Dépassés :D ) ne viennent pas se plaindre!
On va donc tout simplement dire au programme de faire des pauses de temps en temps.
Je sais que ce chapitre est très difficile, (d'ailleurs je vous conseille de faire une pause après), mais voilà le code que j'ai utilisé afin de savoir combien de tours faisait le programme en 1 Seconde:
Local $t = TimerInit(),$i = 0 ; Declaration des Variables
While TimerDiff($t)<=1000 ; Boucle Principale. Tant que le temps est inferieur à une seconde, on additionne 1 à la variable $i
$i = $i + 1
WEnd
MsgBox(65,"Tutoriel",$i);On affiche $i
Ici il n'y a qu'une chose de nouvelle , la gestion des Timer's. Ces derniers s'utilisent de cette manière :
Quand on le veux, on initialise le temps. Puis on demande par une boucle le temps écoulé depuis l'initialisation. Si vous ne voulez pas tout retenir, ne retenez pas ça.
Ce qu'il faut savoir, c'est que chez moi, en 1 seconde, le programme fait 175000 fois la boucle.
Maintenant, nous allons voir une nouvelle fonction:
Sleep(Time)
Time est un Entier en Milli-secondes. Pour pouvoir verifier, n'oubliez pas d'appuyer sur F1 dans Scite pour acceder à la documentation.
Par exemple:
Sleep(1000)
A la differences des fonctions timer[...](), Sleep() Va Mettre en pause le programme, ou littéralement le plonger en léthargie. Pour comprendre, rajoutez Sleep(10) dans le code précédent.
Et alors , c'est pas 10 malheureuses millisecondes qui vont changer le monde!
Oh que si, essayez!
Chez moi, le programme ne fait plus que 65 tours au lieu de 175000. Ceci va permettre de libérer de la puissance pour l'ordinateur en restant tout à fait competitif. Ne vous inquiétez pas, l'utilisateur ne va pas s'aperçevoir du changement, mais l'ordinateur si!
Donc, à partir de maintenant, vous allez me faire ce plaisir, vous rajouterez un Sleep(10) dans toutes vos boucles While.
On peut également retrouver la boucle "Pour" de cette manière :$i =
While ($i <> )
;actions à effectuer
$i = $i +
WEndBoucle "Faire-jusqu'à.."
Cette boucle répète une action jusqu'à ce que la condition à atteindre devienne vraie.
Elle est utilisée lorsque le nombre de fois que l'action doit être effectuée est inconnue, mais dans ce cas, l'action doit être effectuée AU MOINS une fois.
Fonctionnement :Do
;actions à effectuer
Until (proposition)
Quand "proposition" devient VRAI alors la boucle s'arrête.
Si la proposition est vraie dès le premier passage, l'action s'effectue quand même une fois. En effet la vérification ne se fait qu'à la fin de la boucle.
Exemple :
On veut demander un mot de passe à l'utilisateur pour lancer le programme.
Tant qu'il se trompe on lui redemande le mot de passe. On ne sait donc pas combien de fois l'utilisateur va se tromper
Une boucle while ne convient pas car l'action doit être effectuée au moins une fois.
Code:
Do
$pass = "mot de passe"
$input = InputBox("Tutorial", "Entrez le mot de passe :")
If ($input <> $pass) Then
MsgBox(0,"Tutorial", "Mauvais mot de passe !")
Else
MsgBox(0,"Tutorial", "Le mot de passe est correct !")
EndIf
Until ($input = $pass)
Ce code ne devrait pas vous poser de réels problèmes, et ce sous-chapitre est déjà assez étoffé pour le remplir encore...
Passons à la suite, voulez vous? N'hesitez pas à faire une pause pour vous éclaircir les idées Oo)]]>
Func Le_nom_de_ma_fontion ($param1, $param2 = "")
; code contenu dans la fonction
Return 1
EndFunc
Plusieurs remarques concernant ce code :
Le nom de la fontion peut comporter des lettres, des chiffres et le "tiret du bas". _Le premier paramètre de la fonction est $param1. Dans le code de la fonction, vous pouvez (et même devez, sinon ça ne sert à rien ^^) utiliser cette variable.Le deuxième paramètre est déclaré avec un = : cela signifie qu'il est optionnel et qu'il prend comme valeur par défaut une chaîne vide "". Vous devez impérativement mettre les paramètres optionels après les paramètres obligatoires.
Les paramètres optionnels peuvent prendre des valeurs bien définies (chaîne de caractère, nombre,...) mais jamais des valeurs dépendant d'une variable (du genre "$param2 = 3*$param1"). Vous pouvez cepandant utiliser le mot-clé Default et utiliser une condition dans votre fonction pour définir la valeur souhaitée ("$param2 = Default" dans la déclaration de la fonction puis "If $param2 = Default Then $param2 = 3*$param1").La fonction contient "Return 1" : cela veut dire que la fonction retourne la valeur 1. Vous n'êtes pas obligés de mettre cette ligne : dans ce cas, la fonction retourne rien (une chaîne vide "").Si vous mettez du code après "Return", il ne sera pas pris en compte car "Return" dit à AutoIt de sortir de la fonctionAppeler une fonction
Une fois que vous avez déclaré la fonction, vous pouvez l'appeler dans votre script.
Dois-je déclarer ma fonction tout en haut du script pour pouvoir l'utiliser ?
Non. Vous pouvez (et c'est même fortement recommendé :lol: ) appeler à la première ligne de votre script une fonction que vous ne déclarez qu'à la fin.
Pour utiliser votre fonction, ça marche comme avec les fonctions déjà intégrées à AutoIt. Il suffit de faire :
$valeur_retournee = Le_nom_de_ma_fontion (valeur_du_param1, valeur_du_param2)"$valeur_retournee =" permet d'assigner à la variable $valeur_retournee... la valeur retournée par la fonction. Vous n'êtes pas obligé d'assigner cette valeur à une variable.
Concrètement, imaginons un fonction qui calcule la somme de ses 2 paremètres (je manque cruellement d'imagination :lol: ). Il faut la déclarer comme ceci :
Func Somme ($premier_nombre, $deuxieme_nombre = 0)
Return $premier_nombre + $deuxieme_nombre
EndFunc
NB : vous n'êtes pas obligé de mettre une valeur par défaut de 0 pour le deuxième paramètre, je l'ai juste mise pour l'exemple.
Et dans un code, cela donne :
$somme = Somme (3, 4) ; assigne 7 à la variable $somme
MsgBox(0, "", "La somme vaut : " & $somme) ; affiche la somme dans une petite fenêtre
$somme = Somme (3) ; fait la somme entre 3 et 0 (zéro est la valeur par défaut)
MsgBox(0, "", "La somme vaut : " & $somme)
MsgBox(0, "Somme de 5.4 et 6", "La somme vaut : " & Somme (5.4, 6)) ; imbrication directement dans une autre fonction
Somme (1, 2) ; cette ligne ne sert à rien car on ne récupère pas la valeur retournée
Func Somme ($premier_nombre, $deuxieme_nombre = 0)
Return $premier_nombre + $deuxieme_nombre
EndFuncUtilisation de variables dans une fonction
Pour reprendre l'exemple de la fonction précédente (elle est bien pratique ;)), si vous voulez être plus clair, vous pouvez passer par une variable intermédiaire :
Func Somme ($premier_nombre, $deuxieme_nombre = 0)
Local $somme
$somme = $premier_nombre + $deuxieme_nombre
Return $somme
EndFunc
Vous pouvez constater que la variable $somme a une portée locale (utilisation de Local) : c'est très important de le préciser car comme cela, dès qu'on sort de la fonction, la mémoire affectée à cette variable est libérée. C'est sûr qu'une variable contenant juste une somme ne prend pas beaucoup de place, mais si cette variable contient un texte très long et que vous appelez la fonction des milliers de fois votre programme va ramer, et votre ordi' risque fortement de surchauffer :colere: .
Autre avantage à déclarer localement : si par hasard dans votre code vous avez une variable globale nommée $somme, elle ne sera pas modifiée lors de l'utilisation de la fonction ;) : ce code vous en apporte la preuve :
Global $somme = 1
Somme(2)
MsgBox(0,"",$somme)
Func Somme($premier_nombre, $deuxieme_nombre = 0)
Local $somme
$somme = $premier_nombre + $deuxieme_nombre
Return $somme
EndFunc
Une fenêtre vous affiche le chiffre 1, valeur affectée à la variable globalement, alors que dans la fonction "Somme", $somme vaut 2
Modifier une variable globale
C'est bien de savoir utiliser des variables locales dans votre code, mais il se peux que vous ayez envie de modifier une variable globale dans votre fonction.
Mais ce que tu nous dis ne sert à rien : il suffit juste de ne pas mettre "Local" dans la fonction, non ?
C'est vrai que si l'on veut modifier une variable globale, on peut simplement ne pas la déclarer localement dans son script :
Global $nombre_global = 1
Incremente()
MsgBox(0,"",$nombre_global)
Func Incremente()
$nombre_global += 1 ; équivalent à $nombre_global = $nombre_global + 1
EndFunc
Seulement, si vous voulez que la fonction serve pour des variables différentes, vous êtes bien embêtés :diable:
Heureusement, le mot-clé ByRef existe :zorro:
Heu... et comment ça marche ?
Ce mot-clef s'utilise lors de la déclaration des paramètres de la fonction :
Func Le_nom_de_ma_fontion(ByRef $param)
Ce qui donne dans un exemple :
Global $nombre_global1 = 1, $nombre_global2 = 5
Incremente($nombre_global1)
MsgBox(0, "premier nombre", $nombre_global1)
Incremente($nombre_global2)
MsgBox(0, "deuxième nombre", $nombre_global2)
Func Incremente(ByRef $variable_interne)
$variable_interne += 1
EndFunc
Dans la fonction, on utilise donc $variable_interne, mais c'est $nombre_global1 ($nombre_global2 dans le deuxième appel de la fonction) qui est modifié.]]>
Macro reference.
Liste non-exhaustive des macros les plus utilisées.@MyDocumentsDir : Retourne le chemin complet du repertoire "Mes Documents"@ComputerName : Retourne le nom de l'ordinateur@CRLF : Equivaut à un retour chariot (appui sur la touche ENTRER)@DesktopDir : Retourne le chemin complet du Bureau@DesktopHeight : Retourne la hauteur de votre resolution d'ecran@DesktopWidth : Retourne la largeur de votre resolution d'ecran@HOUR : Retourne l'heure@HotKeyPressed : Retourne la dernière touche appuyée par l'utilisateur@ScriptDir : Retourne le chemin complet du script@ProgramFilesDir : Retourne le chemin complet du repertoire "Program Files"@OSVersion : Retourne la version de votre OS@SystemDir : Retourne le chemin complet de votre repertoire system@TempDir : Retourne le chemin complet de votre repertoire temporaire
Pour tester la puissance des macros, je vous laisse essayer ce script:
MsgBox(64,"Informations sur tous vos repertoires","Repertoire Système : " & @SystemDir & @CRLF & _
"Mes Documents : " & @MyDocumentsDir & @CRLF & _
"Dossier Temporaire : " & @TempDir & @CRLF & _
"Demarrage : " & @StartMenuDir & @CRLF & _
"Program Files : " & @ProgramFilesDir & @CRLF )
Vous pouvez remarquer l'utilisation de @CRLF afin de revenir à la ligne, ainsi qu'un nouveau moyen pour que vos scripts soient plus lisibles. En effet, quand une ligne devient trop longue, on prefere quelques fois la diviser en plusieurs lignes.
Pour se faire, il suffit d'ecrire : '& _ ', qui est le caractère d'incrémentation de variable par défaut en Autoit.
Si il vous faut n'en retenir qu'une, ce serait @ScriptDir. En effet, à chaque fois que vous allez devoir intéragir avec un fichier, vous allez très souvent utiliser cette variable. Vous souhaitez mettre une image dans votre script? C'est encore la même que vous allez utiliser si votre image se situe dans le même dossier que votre script.
]]>
Beep ( [ Fréquence [, Durée ]] )
qui permet de faire jouer de la musique à la Tour.
Avantage, les bruits indésirables >_< deviennent de la musique! :ange: , et pas besoin d'avoir ses enceintes allumées !
La musique sort de la tour, par un système d'haut-parleurs interne, alors n'exécutez pas ce code si quelqu'un dort à proximité! :p Exemples
Beep(262, 200)
Voici le début de "Joyeux Anniversaire"
Beep(262*2, 500)
Beep(262*2, 200)
Beep(294*2, 500)
Beep(262*2, 1000)
Beep(349*2, 500)
Beep(330*2, 2000)
Sleep(500)
Beep(262*2, 500)
Beep(262*2, 200)
Beep(294*2, 500)
Beep(262*2, 1000)
Beep(392*2, 500)
Beep(349*2, 1000)
Comme je suis sympa, je vous met les fréquences, pour que vous puissiez faire vos propres morceaux de musique!
Do: 261,6 Hz
Do#: 277.2 Hz
Ré: 293.7 Hz
Ré#: 311.1 Hz
Mi: 329.7 Hz
Fa: 349.2 Hz
Fa#: 370.0 Hz
Sol: 392.0 Hz
Sol#:415.3 Hz
La: 440 Hz
La#: 466.2 Hz
Si: 493.9 Hz
Do: 523.2 Hz
Il est maintenant temps de passer aux choses sérieuses! Allons, cessons les enfantillages voulez vous!]]>
; ----------------------------------------------------
; -------------------- Section I --------------------
; ----------------------------------------------------
; Version AutoIt : 3.2.8.1
; Langue : Francais
; Plateforme : Win9x/XP
; Autheur : 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
#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 ###################
Ce script est composé de 6 sections distinctes.
Nous allons détailler chaque section dans la suite de ce post.
Section I Présentation de votre script.Section II Déclarations des directives pour AutoItWrapper.Section III Déclarations des Includes, variables, et autres.Section IV Construction de votre GUI (Graphic User Interface).
Section V boucle d'attente d'une action sur la GUI.
Section VI Définition des fonctions utilisées dans le script.Les Sections I et II ne sont pas indispensables, mais il faut apprendre à coder proprement, et ceci est une étape à franchir.
Voyons maintenant section par section comment ça fonctionne.]]>
; 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 pour le Site Du Zero.
;
;
;
; Version 1.0 : 21//2007
; - Première Version.
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'a dit que les lignes commencant par ; étaient des commentaires, alors on peut tout enlever cette connerie !
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.
Maintenant que les informations sont données, on peut passer aux choses sèrieuses... (Ou pas :ange: )]]>
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) 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 avec des options votre programme. Toutes les lignes ci-dessous sont des directives que lui seul comprend.
; 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
Rassurez vous, ces lignes ne sont pas à remplir manuellement. Quand vous cliquez sur "Compile With Options", une fenêtre s'ouvre pour vous permettre de tout choisir sans toucher au code, alors n'hesitez pas à combiner differentes possibilités.Si vous mettez ces lignes dans votre code, il faudra quand meme cliquer sur "Compile With Options" et non sur "Compile Script" pour que toutes vos options soient prises en compte.
]]>
; Déclarations Diverses.
#include
#NoTrayIcon
; Déclaration des variables.
Global $Largeur = 400, $Hauteur = 100, $Titre = "Form1 "
Local $Ver = "V1.0"
- La première ligne, #include sert à dire au programme, que nous allons avoir besoin d'utiliser des fonctions stockées dans cet UDF (User Définition File), et donc de le rajouter lors l'utilisation et de la compilation. En effet, certains utilisateurs expérimentés creent leurs propres fonctions et les partagent avec les autres. C'est ce qu'on appelle un UDF. Les plus utilisées sont inclus dans Autoit à l'origine, et ont une couleur bleu ciel dans Scite au lieu du bleu habituel. Vous pouvez les trouvez facilement, ce sont celles qui commencent par un _ . Par Exemple: _FileToArray est un UDF, StringSplit est une fonction de base. Tous les UDFs sont enfait 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 creez un quelconque programme, une icone en forme de A s'affichera dans le SysTray (Barre Système en bas à droite de votre écran) qui vous permettra de quitter à n'importe quel moment le programme. Il est possible de modifier cette icone ainsi que le menu, mais ceci necessite des fonctions avanacées que nous verrons plus tard. Il vaut donc mieux l'enlever pour l'instant.
Tout 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 lignes 6 et 7 servent à déclarer des variables.
Nous avons déjà vu comment déclarer une variable dans le chapitre précédent, ceci ne devrait pas vous poser trop de problèmes pour l'instant.]]>
#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 ###
Ce code vous affichera une fenêtre vide, du nom de : Form1.
- La première ligne indique que nous allons utiliser des fonctions de l'UDF : GUIConstants.au3.
- 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).*]]>
Fin
#EndRegion ################### Fonctions ###################
Je ne détaillerais pas la fonction Fin() car elle est suffisamment commentée.
Ce qu'il faut retenir, c'est que si on a besoin de faire une tache régulièrement dans un code (Lancer l'exécution d'une action depuis plusieurs endroit 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.]]>
Premièrement, notre programme devra tirer un nombre au hasard.On va répéter ces actions tant que l'utilisateur n'a pas trouvé le bon nombre
-On demande à l'utilisateur un nombre
-Si le nombre entré est supérieur au nombre caché, on l'indique à l'utilisateur
-Si le nombre entré est inférieur au nombre caché, on l'indique à l'utilisateur
Vous savez tout ce qu'il faut savoir, vous savez ce que va faire le programme, il est temps de passer au codage ! :zorro:]]>
Les Boucles, révisez les un peu plus haut avant de vous lancer. A vous de choisir la plus appopriée pour ce script.Les Variables, bien sûr, à réviser également.Les commandes informatives (InputBox et MsgBox).La commande Random (je vous l'explique un peu plus bas).Les Opérateurs
Sauf erreur, avec tous ces outils en main, vous n'avez aucune chance de vous louper !
La commande Random
La commande Random s'utilise comme cela :
Random (valeur_minimale_possible , valeur_maximale_possible)
Par exemple, si je veux afficher un nombre au hasard allant de 1 à 10 dans un MsgBox, voici le code adéquat :
$chiffre_hasard=Random (1, 10, 1)
;~(flag) j'ai ajouté le numéro "1" pour préciser que le nombre à tirer au hasard doit être entier.
MsgBox ("Tutoriel","Salut ! Le nombre est " & $chiffre_hasard & ".")
Voila, je ne vous en dis pas plus ! ]]>
Vous êtes vraiment certain?
$chiffreH=Random ( 0, 100, 1)
MsgBox (1, "Tutoriel Zero", "Bonjour ! Bienvenue au jeu du Plus ou du Moins !Le but du jeu est le suivant : Je tire un nombre au hasard, puis je vous donne les indications 'plus' ou 'moins' pour vous aider. Vous êtes prêt ?")
Do
$reponse=InputBox ("Tutoriel Zero", "Rentrez un nombre de 0 à 100")
If ($reponse > $chiffreH) Then
MsgBox (1, "Tutoriel Zero", "Pas mal... mais c'est un peu moins !")
EndIf
If ($reponse < $chiffreH) Then
MsgBox (1, "Tutoriel Zero", "Pas mal... mais c'est un peu plus !")
EndIf
Until ($reponse=$chiffreH)
MsgBox (1, " WoOoW!", " Vous avez réussi ! Extraordinaire !")
Je pense que le code se passe de tout commentaire, mais si vous avez fait autre chose et que ça marche, c'est totalement possible !
]]>
exemple :
Vous avez trouvé le nombre caché en 8 coups !
* Voire même pour les plus compliqués pour les plus perfectionnistes, ajouter un niveau de difficulté englobant :
- La valeur maximale que peut prendre le nombre mystère. Cela pourra augmenter (ou bien diminuer) la difficulté.
- Le nombre d'essais pour trouver le nombre au maximum.
* Demandez à l'utilisateur s'il veut recommencer le jeu.
Ça en fait des choses à faire, hein ?
]]>
InternetLe FTP (File Transfer Protocol)C'est quoi encore?
Bref rappel: un FTP est, comme son nom l'indique, un protocol de transfert de fichier. Il permet, depuis un ordinateur, de copier des fichiers vers un autre ordinateur. Aussi il permet d'administrer un site web, ou encore de supprimer ou de modifier des fichiers sur cet ordinateur.
Grâce à Autoit, on va directement placer des fichiers sur le ftp voulu de part notre script.
Allez, c'est parti :pirate:
Premièrement, nous avons besoin de l'UDF FTP.au3 (qui pour rappel se trouve dans le dossier include, dans autoit)
Voici ce qu'il contient:
_FTPOpen()
_FTPConnect()
_FTPPutFile()
_FTPDelFile()
_FTPRenameFile()
_FTPMakeDir()
_FTPDelDir()
_FTPClose()
Placer un fichier sur son FTP:
Comme mentionné ci-dessus, on inclu l'udf:
#include
Ensuite, on va regrouper toutes les infos nécessaires sous forme de variable. Je parle ici de l'adresse du ftp, du login et du mot de passe.
#include
$server = 'ftp://serveur.com'
$username = 'Login'
$pass = 'Pass'Rappel: vous pouvez nommer les variables comme bon vous semble. Seulement, jusqu'a la fin du script, utilisez les mêmes
Maintenant, utilisons les fonctions contenues dans le FTP.au3 pour s'y connecter.
#include
$server = 'ftp://serveur.com'
$username = 'Login'
$pass = 'Pass'
$Open = _FTPOpen('Mon FTP')
$Conn = _FTPConnect($Open, $server, $username, $pass)Attends un peu mon pti' bonhomme, pourquoi vois je: wininet.dll dans les fonctions que tu viens d'utiliser?
Euhhh, oui :-° Wininet.dll est enfait un module qui contient des fonctions liées a internet utilisées par Windows. On va donc pas s'étendre sur le sujet et se contenter de l'inclure:
#include
DllOpen('wininet.dll')
$server = 'ftp://serveur.com'
$username = 'Login'
$pass = 'Pass'
$Open = _FTPOpen('Mon FTP')
$Conn = _FTPConnect($Open, $server, $username, $pass)
Maintenant que tout est prêt, on place le fichier sur le serveur et on clot la connection:
#include
DllOpen('wininet.dll')
$server = 'ftp://serveur.com'
$username = 'Login'
$pass = 'Pass'
$Open = _FTPOpen('Mon FTP')
$Conn = _FTPConnect($Open, $server, $username, $pass)
$Ftpp = _FtpPutFile($Conn, 'LE_NOM_DU_FICHIER_SUR_PC', 'LE_NOM_DU_FICHIER_SUR_FTP')
$Ftpc = _FTPClose($Open)
Pour le _FtpPutFile, mentionnez donc le vrai nom du fichier (ex: coucou.txt) et le nom qu'il aura quand il sera sur le ftp, vous pouvez très bien laisser le même (coucou.txt) ou un autre (coucou_ftp.txt)
Avoir une réponse du transfert:
MsgBox(0, "Error", $Ftpp) ; 1 = OK , 0 = ErreurAutres possibilités:*_FTPDelFile(), _FTPMakeDir(), _FTPDelDir() marche tous comme suit:
_Fonction($FTPSession, $FileorDir)
Exemple:
_FTPDelDir($Conn, "dossier")*_FTPRenameFile() marche comme suit:_FTPRenameFile($Conn, "Nom", "NouveauNom")Partie Bonus
Multiples autres UDF ont été conçus sur le forum anglais pour avoir plus de possibilités. :magicien:
En voici un que vous pouvez avoir ici: .FTP.au3 qui contient plusieurs autres fonctions:
_FTPGetFileSize()
_FtpSetCurrentDir()
_FTPFileFindFirst()
_FTPFileFindNext()
_FTPGetFoldercontents ()
Exemple pour _FTPGetFoldercontents ():
#include
#include <.FTP.au3>
$server = 'ftp://ftp.url.net'
$username = '*******'
$pass = '******'
$ftp = _FTPOpen('Coucou')
$Ftpc = _FTPConnect($ftp, $server, $username, $pass)
if @error then
msgbox(0,"Error","Connect Error")
Exit
EndIf
_FTPGetFolderContents($ftp,"/test/","",1) ;Les fichiers dans le répertoire 'test'
$Ftpc = _FTPClose($ftp)
Mettre "" pour avoir la racine du ftp à la place de "/test/"
On a besoin de l'UDF Array.au3 ici
]]>
Cette partie sera très utile quand vous commencerez a programmer. Si vous souhaitez juste démarrer a programmer en Autoit sans se faciliter la vie, ou en utilisant un autre éditeur que Scite, vous pouvez sauter
Pour faciliter votre compréhension,les outils sont cachés.Voici les outils disponibles suite à l'installation de AutoIt (Groupe AutoIt V3) dans le menu démarrer :AutoIt Help File
Le fichier d'aide (Aussi accessible avec la touche F1 à partir de Scite)Check For Updates
Cet utilitaire vous permettra de voir si vous avez la dernière version de AutoIt, ou de télécharger et installer une version bêta.AutoIt Window Info
Utilitaire, qui permet de trouver les informations sur des contrôles graphiques (Fenêtre, bouton, champs ...) afin de pouvoir les piloter, ou de lire les données à partir de votre script.Exemples
Répertoire contenant plusieurs scripts au3.
Il peut être des plus intéressent de consulter ces scripts, pour comprendre l'utilisation de certaines commandes.Compile Script to .exe
Utilitaire, qui vous permet de créer à partir de votre script au3, un exécutable, ou script compiler (a3x), avec l'icône de votre choix, et la possibilité de compiler pour rendre le script compatible avec Windows 98 (Option : Compile for ANSI)Run Script
Bon ben le programme AutoIt lui même en personne. o_O SciTE Script Editor
L'éditeur avec coloration syntaxique du code AutoIt.
Scite permet aussi de travailler sur d'autre langage, puisque ce n'est qu'un éditeur de texte, mais il intègre une gestion de la coloration de la syntaxe, et de lancer des commande pour créer, lancer, faire des actions diverses et variée.
La version de Scite installée avec AutoIt est vraiment super light, c'est pour cela que je conseille l'installation de Scite4AutoIt.
Dans la partie Extra, vous trouverez encore quelques petits outils :
AutoItX
Pour utiliser l'activeX AutoIt dans d'autres scripts (VBS, Batch, ...)Browse Extras
Pour accédez au répertoire des extras.Decompile .exe to Script
Utilitaire pour décompiler des EXE antérieurs à la version 3.2.5.1 de AutoIt.
Obsolète pour les nouvelles versions de AutoIt.v2 to v3 Converter
Si jamais, vous tombez sur des scripts créer avec AutoIt V2, vous pouvez les mettre à jour avec ce soft.Maintenant les outils installés avec Scite4Autoit3:
Pour commencer, voyons les outils disponibles dans le menu démarrer (Groupe AutoIt V3/SciTE) :
GettingStarted
Aide de Scite. Contient les informations relative à Scite, et aux outils intégrés (AutoItWrapper, Tidy, ...)SciTe
The programme. Et oui encore lui !!! C'est l'éditeur en lui-même.SciteConfig (CTRL+1 dans Scite)
Utilitaire de configuration de Scite.
Permet de modifier la coloration syntaxique, de choisir les outils disponibles dans le menu Outils, et bien évidement de configurer une partie de Scite.
Cela permet de paramétrer la sauvegarde automatique des scripts modifiés, et de conserver un certains nombres de versions par exemple.
Vous pouvez aussi tester vos scripts sur des versions bêta, histoire de voir si il n'y à pas un bug corrigé depuis la dernière version finale.ScriptWriter (ALT+F6 dans Scite)
Utilitaire qui enregistre les actions faites au clavier et à la souris, de manière à les reproduire automatiquement ultérieurement. Ultra utile pour reproduire des actions simples. Un petit exemple, vous lancer cet utilitaire, puis:
Aller sur internet, puis sur un site, taper son pseudo et mot de passe, cliquer sur Ok.
Enregistrez , lancer le script .au3 et magique, votre souris bouge toute seule et reproduit vos actions!Switch-Definitions
Permet de 'Switcher' entre les définitions de la version courante, et la version bêta de AutoIt.Tidy (CTRL+T dans Scite)
Magnifique utilitaire, qui permet de contrôler, nettoyer et de bien présenter votre script pendant l'écriture de celui-ci.
Cet utilitaire est aussi accessible dans le menu Outils de Scite.
Voilà pour les outils accessibles facilement.
Mais ce n'est pas fini (Loin s'en faut), car Scite4AutoIt regorge d'utilitaires tous plus utiles les uns que les autres.
Pour cela, rendez vous dans le répertoire d'installation de Scite4AutoIt :
C:\Program Files\AutoIt3\SciTE
Répertoire api
Répertoire dans lequel on peut rajouter la liste des commandes d'un langage, afin d'avoir l'auto-complétion du code.Répertoire AutoIt3Wrapper
Répertoire qui contient le fameux Resource Hacker, et les outils qui vont bien pour modifier les ressources de votre exe à la compilation.
Notez au passage que le fichier Directives.au3 contient la liste des directives exploitables dans la saisie de votre code pour agrémenté votre compilation.Répertoire AutoItMacroGenerator (CTRL+A dans Scite)
Contient un utilitaire pour enregistrer des macros pour AutoIt (Et oui encore un).Répertoire CodeWizard (ALT+W dans Scite)
Vous cherchez comment faire pour créer une MsgBox bien particulière, un SplashScreen, ou un InputBox à mot de passe, ou encore quel est le code pour telle couleur, etc ...
Et bien CodeWizard est là.Répertoire cSnippet (CTRL+ALT+S dans Scite)
Vous en avez marre de faire du copier coller de vos anciens scripts, pour récupérer des lignes de code que vous utilisez régulièrement.
Code Snippet est là pour vous sauver la mise (Accessible aussi par le menu outil de Scite).
Sélectionner votre code dans AutoIt, puis dans la fenêtre de Code Snippet cliquer sur le deuxième bouton (Copy from Scite), puis remplissez le champ Snippet Name (Le nom de votre bout de code), et classé le dans une catégorie.
Pour finir de sauvegarder ce bout de code, un clique sur Save Snippet (En bas à gauche), et le tour est joué.
Pour récupérer un code; deux cliques sur le code que vous désiré, puis 'Insert Into Scite'.Répertoire Defs
Les définitions de Scite (Pour l'auto complétion, les abréviations, ...)
Faire : Menu Options puis Ouvrir fichier d'abréviation, pour avoir la liste des abréviations disponibles.Répertoire FuncPopUp (Shift +F1 Dans Scite)
Affiche les explications des fonctions disponibles en cour de frappe, ou à la sélection.Répertoire GUIBuilder
Utilitaire pour créer une GUI avec ses contrôles (Préférer Koda).Répertoire Koda (ALT+M dans Scite)
Utilitaire pour créer une GUI avec ses contrôles,dans le style des meilleurs logiciel de développement.
Je ne détaillerais pas dans ce post l'utilisation de Koda, car il est tellement complet, que ce serait bien trop long.Répertoire Obfuscator
Utilitaire qui permet de rendre le code AutoIt quasiment illisible pour un être humain, mais tout à fait fonctionnel pour la machine.
Cet utilitaire était destiner à la base, à rendre un code décompiler inexploitable par une personne tiers.
Obsolète pour des scripts compilés après la version 3.2.5.1.Répertoire OrganizeIncludes
Utilitaire qui est sensé analyser votre code, pour voir si vous n'avez pas oublié les Includes nécessaires (Pas tester).Répertoire ScriptWriter
Utilitaire de création de macro (Le troisième).
Cela dit, ScriptWriter possède des fonctions uniques, que les autres n'ont pas.Répertoire Tidy (CTRL+T Dans Scite)
Déjà vu précédemment.
Voilà pour ce petit tour d'horizon des utilitaires fournis avec Scite4AutoIt.
Je n'ai pas décrit toutes les fonctionnalités supplémentaires, que vous trouverez entre autre dans le menu options, mais n'hésitez pas à les testées, et à fouiller.
Vous constatez que ce produit est riche, et surtout complet.
Alors n'hésitez pas à l'installer avec AutoIt, car il vous rendra bien des services. :diable:]]>
communauté Française d'Autoit.
Adieu ! Au revoir !
]]>