• 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

Les fonctions

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

Bon, on va maintenant voir comment simplifier un peu notre code. En effet, il arrive très souvent qu'un bout de code soit requis plusieurs fois dans le script. Plutôt que de recopier les lignes, on va utiliser une fonction.

Utilisation des fonctions

Une fonction est un bout de code destiné à être executé plusieurs fois, on le met donc dans ce qu'on appelle une fonction qu'il suffira d'appeler pour executer le code.

Avec Autoit, vous pouvez déclarer une fonction contenant un bout de code qui sera exécuté lorsque vous appellerez la fonction. Vous pouvez définir des paramètres qui changeront le comportement de la fonction. Voici la syntaxe pour déclarer une fonction :

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ères, nombre...) mais jamais des valeurs dépendant d'une variable (du genre "$param2 = 3*$param1"). Vous pouvez cependant 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 ne retourne rien (une chaîne vide "").

Appeler 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 recommandé :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)

Concrètement, imaginons une fonction qui calcule la somme de ses deux paramè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
EndFunc

Les Includes et les UDF

Oui mais si j'ai une centaine de fonctions dans mon script, je ne vais pas me casser la tête à toutes les copier/coller dans mon script !!!

Eh bien, les #include sont là pour ça !!! Je vais commencer par vous montrer que vous savez pratiquement déjà utiliser un include.
Créez tout d'abord un nouveau script .au3, dans lequel vous mettrez uniquement votre fonction. Un exemple visuel, on crée notre fichier fonctions.au3, il contient ce code :

Func calcule_minutes()
  Return (@Hour*60)+@Min
EndFunc

Ce code ne devrait pas poser de problèmes. La fonction n'a besoin d'aucun paramètre pour fonctionner. Le Return permet de retourner une valeur, qui ici est @Hour, une macro qui retourne l'heure multipliée par 60 et additionée à @Min qui retourne la minute. En gros, s'il est 16h59, la fonction nous retourne le nombre de minutes soit 16 * 60 + 59 = 1019 minutes.

Maintenant, on va utiliser cette fonction dans notre script principal. On aurait pu mettre cette fonction directement dans le script principal, mais imaginez que vous souhaitez coder une grosse application, vous risquez de vous perdre parmi vos quelques 100 fonctions. Si vous regroupez par exemple toutes les fonctions concernant la date dans un fichier, toutes les fonctions concernant les fichiers d'un autre, vous vous y retrouverez plus facilement.
Vous enregistrez la fonction dans le dossier de votre choix, puis vous mettez au début de votre script principal ceci :

#include"Chemin d'accès de la fonction\fonctions.au3"

Ensuite, vous pouvez appeler à tout moment dans votre script principal les fonctions présentes dans le fichier fonctions.au3, comme si elles étaient dans votre script. Pour vous expliquer, lors de l'exécution de votre programme, Autoit va simplement copier/coller toutes vos fonctions incluses grâce à #include en haut de votre script.

En bref, les includes servent à rendre votre script plus court en séparant les fonctions de votre script principal, qui a besoin du fichier pour marcher. En effet, si vous supprimez le fichier fonctions.au3, alors votre script principal ne marchera plus.

Les UDF

Il existe bien entendu des librairies déjà écrites, comme en C++ ou en Java, qui sont des listes de fonctions déjà écrites par les développeurs d'Autoit, et c'est ce que nous appelons UDF. Un UDF est un regroupement de plusieurs fonctions très utiles que certains développeurs ou utilisateurs d'Autoit ont partagé pour éviter que vous ayiez à les réécrire.

Ces UDF (User Defined Functions) sont des fichiers .au3 contenant une multitude de fonctions et il vous suffira d'inclure ce fichier pour utiliser la fonction. Les librairies de base d'Autoit sont déjà inclues dans votre code. Par exemple, en C, vous avez pris l'habitude de toujours inclure les Includes de bases.

#include <stdio.h>
#include <stdlib.h>

En Autoit, tout est déjà fait. C'est pour cela que vous avez pu utiliser MsgBox et InputBox par exemple sans vous soucier de savoir d'où elles venaient.

Par exemple, si on regarde dans le dossier include\ de l'installation Autoit (Pour la plupart : C:\Program Files\AutoIt3\Include\) on voit plusieurs fichiers .au3 qui sont remplis de fonctions. Il y a 2 sortes de fichiers, ceux qui ont 'constant' écrit dans leur nom, et les autres. Les premiers nous sont pour l'instant inutiles, vous pouvez les ouvrir vous verrez qu'ils ne comportent que des déclarations de variables en Global, ils servent en fait pour construire des interfaces utilisateurs (vous verrez comment dans la deuxième partie de ce tutoriel).
Les autres sont plus intéressants. Je vous propose d'ouvrir le fichier String.au3 qui comme vous pouvez le penser contient les différentes culottes répertoriées à ce jour les fonctions de "chaîne de charactère".
Vous voyez qu'il contient 9 fonctions, très bien documentées, avec le nom de leur auteur.

Citation : String.au3

;_HexToString
;_StringBetween
;_StringEncrypt
;_StringExplode
;_StringInsert
;_StringProper
;_StringRepeat
;_StringReverse
;_StringToHex

J'ai choisi de vous montrer _StringBetween qui est très utile. Si vous avez compris ce que j'ai raconté plus haut, le code qui suit ne devrait pas vous poser de problèmes:

#include <String.au3>
#include <Array.au3>

_Main()

Func _Main()
    Local $aArray1 = _StringBetween('[18][20][3][5][500][60]', '[', ']')
    _ArrayDisplay($aArray1, 'Default Search')
EndFunc   ;==>_Main

Ce code utilise 2 includes, le premier String.au3 qui contient la fonction _StringBetween comme vous venez de le voir, et Array.au3 qui contient _ArrayDisplay
N'hesitez pas à aller voir l'aide pour voir comment marche _StringBetween et _ArrayDisplay

Utilisation d'UDF

Les UDFs sont relativement nombreux et permettent des choses diverses et variées, comme par exemple :

  • modifier rapidement des images ;

  • établir des connexions réseau abouties (serveur/client) ;

  • modifier intelligemment la base de registres ;

  • déterminer toutes les caractéristiques d'un ordinateur en réseau ;

  • redémarrer votre LiveBox (et oui, tout peut exister ^^ ) ;

  • récupérer les fichiers présents sur votre serveur de connexion privé (FreeBox, modem personnel, serveur...) ;

  • créer des interfaces graphiques très abouties pour votre programme ;

  • ajouter des animations de fenêtre à vos programmes ;

  • envoyer automatiquement des mails ;

  • détecter une insertion de périphériques

  • ... et la liste est très longue ! Avec toutes les fonctions que certains programmeurs partagent sur le net, elle ne cesse de s'agrandir !

Par exemple, il existe une fonction très utile pour vérifier vos tableaux pendant le développement de votre application : _ArrayDisplay(). Elle affiche le contenu de votre Array. Vous constaterez que son nom commence par le signe _ . C'est une convention pour signifier qu'elle fait partie d'un UDF, vous avez deviné qu'il s'agit de <Array.au3>.
Elle accepte plusieurs paramètres mais un seul est obligatoire : le nom de la variable.
Vous pouvez tester l'exemple ci-dessous.

#include <Array.au3>

Dim $Tableau[2][4] = [[1,3,5,7],[2,4,6,8]]

_ArrayDisplay($Tableau)

Bien entendu, comme je vous l'ai montré en tout début de ce chapitre, vous pouvez créer vos UDF vous même, et certains francais ont essayés, et certaines de leur fonction sont souvent très utilisées.
Si cela vous intéresse, vous pouvez vous-même en télécharger quelques-unes via le lien suivant :

http://www.autoitscript.fr/forum/viewforum.php?f=21

Pour aller plus loin...

Utilisation 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 nombre 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 peut 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:

Euh... et comment ça marche ?

Ce mot-clé 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é.

Je crois qu'après tant d'efforts vous avez bien droit à une petite récompense...

Vous avez mérité que je vous parle d'une petite fonction s'intitulant

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 !

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 mets 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 !

Example of certificate of achievement
Example of certificate of achievement