Une variable est juste un emplacement mémoire où vous stockez une donnée de telle sorte qu'elle soit accessible rapidement. Pensez à une boîte aux lettres dans la mémoire où vous pouvez placer ou retirer une information. Par exemple, vous pourriez créer une variable pour stocker le nombre de réponses d'un utilisateur, ou le résultat d'une équation mathématique.
Chaque variable a un nom (comme une boite aux lettres), ce nom doit commencer par le caractère $ et ne doit contenir que des lettres, des chiffres et le caractère de soulignement '_' . Voici quelques exemples de noms :
$Var1
$vVariable
$ma_Variable
Notez que tous les noms de variables sont insensibles à la casse: $maVariable est la même que $MavARiAblE.
Chaque variable est stockée comme une information 'variant' .
Les variables sont déclarées et créées avec les mots clé Local et Global - Dim peut aussi être utilisé, mais ce n'est pas recommandé.
Local $vVariable
Ou bien, vous pouvez déclarer plusieurs variables simultanément:
Global $vVariable1, $vVariable2
Vous pouvez aussi assigner une variable sans la déclarer auparavant, mais beaucoup préfèrent les déclarations explicites.
$vVariable = "Create and Assign"
Les constantes sont déclarées et créées en utilisant le mot-clé Const et doivent être initialisées avec une valeur:
Const $iConst1 = 1, $iConst2 = 12
Les constantes peuvent etre déclarées et initialisées en utilisant le mot clé Enum
Enum $iConst1 = 1, $iConst2, $iConst3 ; 1, 2, 3
Enum Step 2 $iIncr0, $iIncr2, $iIncr4 ; 0, 2, 4
Enum Step *2 $iMult1, $iMult2, $iMult4 ; 1, 2, 4
Lorsqu'une constante a été assignée, elle ne peut plus être modifiée.
La portée d'une variable dépend de l'emplacement et de la façon dont vous la déclarez. Si vous déclarez une variable au début de votre script et en dehors de toute fonction elle existera sur une portée globale et pourra être lue ou modifiée dans n'importe quelle partie de votre script.
Si vous déclarez une variable à l'intérieur d'une fonction elle a une portée locale et ne peut être utilisée que dans cette même fonction. Les variables créées dans une fonction sont automatiquement détruite quand la fonction se termine.
Par défaut, quand les variables sont déclarées en utilisant le mot clé Dim ou assignées dans une fonction, elles ont une portée locale, à moins qu'il n'existe une variable globale du même nom (dans ce cas, la variable globale est utilisée). Ceci peut être modifié en utilisant les mots clé Local et Global lors de la déclaration des variables pour forcer leur portée comme vous le souhaitez.
AutoIt a 2 types de variables pour grouper des données: Array and Map.
Les tableaux (Array) sont beaucoup plus rapides pour un accès aléatoire et peuvent avoir plusieurs dimensions - une dimension est fixée lors de la déclaration initiale (mais elle peut être modifiée à l'aide de ReDim). Les tableaux sont indexés en utilisant des valeurs entières se référant à l'ordre des éléments et commençant à l'élément [0] - les éléments peuvent être extraits en utilisant l'index entier ou en itérant avec une simple boucle For ... Next.
Les tables (Map) sont meilleures pour les accès de type enregistrement/dictionnaire et ont une dimension unique. Elles sont indexés à l'aide de clés entières ou de chaînes (les entiers ne font pas référence à l'ordre des éléments) et sont redimensionnées dynamiquement à mesure que les valeurs sont ajoutées ou supprimées. Une valeur ne peut être atteinte qu'avec sa clé d'origine - ces clés peuvent être itérées à l'aide de la fonction MapKeys.
Les tableaux et les tables utilisent une syntaxe similaire, il est donc nécessaire de veiller à ce que la variable soit d'un type de données correct - cela est déterminé par la première ligne de déclaration de la variable:
L'utilisation d'aucune dimension [ ] déclare une table:
Local $vVar[] ; Une table
L'utilisation d'une dimension entre crochets declare un tableau:
Local $vVar[3] ; Un tableau
En assignant des valeurs aux éléments lors de la déclaration fait de la variable un tableau - ces trois lignes sont équivalentes:
Local $vVar[3] = [1, 2, 3] ; Un tableau
Local $vVar[] = [1, 2, 3] ; Un tableau
Local $vVar = [1, 2, 3] ; Un tableau
Un tableau est une variable contenant une série d'éléments. Vous pouvez accéder à un élément de cette variable par un index numérique relatif à la position de l'élément dans le tableau - dans AutoIt, le premier élément d'un tableau est toujours l'élément [0]. Les éléments d'un tableau sont enregistrés dans un ordre précis et peuvent être triés.
Un exemple:
Si vous vouliez stocker une liste de noms: "Jasper", "Beethoven", "Pinky" et "Fidget", vous pourriez utiliser quatre variables distinctes pour le faire, mais utiliser un tableau est plus efficace:
Local $aArray[4]
$aArray[0] = "Jasper"
$aArray[1] = "Beethoven"
$aArray[2] = "Pinky"
$aArray[3] = "Fidget"
Pour accéder à une valeur spécifique d'un tableau, vous utilisez l'index numérique:
$sString = $aArray[2] ; $sString contient "Pinky"
L'index numérique peut aussi être substitué par une autre variable or une expression, aussi vous pouvez inventer des méthodes complexes pour assigner les éléments d'un tableau ou accéder à ces éléments.
Les éléments d'un tableau entier peuvent être itérés en utilisant une boucle For...Next:
; UBound retourne le nombre total d'éléments - Comme le premier est [0] l'index le plus grand est 1 de moins
For $i = 0 To UBound($aArray) - 1
ConsoleWrite(aArray[$i] & @CRLF)
Next
$aArray[0][0] = "Upper-Left"
$aArray[1][0] = "Lower-Left"
$aArray[0][1] = "Upper-Right"
$aArray[1][1] = "Lower-Right"
(Ces valeurs ne sont que des exemples)
Vous pouvez utiliser jusqu'à 64 dimensions dans un tableau. Le nombre total d'entrées ne peut pas dépasser 2^24 (16 777 216).
Les tableaux doivent être déclarés avant d'être utilisés, en définissant leur portée avec les mots-clés 'Global/Local/Static' et en spécifiant leur taille et/ou quelques assignations d'éléments.
Local $aArray1[2] ; Tableau avec 2 éléments, aucun assigné
Local $aArray[] = [8, 4, 5, 9, 1] ; Tableau avec 5 éléments, tous assignés
Local $aArray[7] = [3, 7.5, "string"] ; Tableau avec 7 éléments, seulemnt les 3 premiers sont assignés
Un élément de tableau peut contenir n'importe quel type de donnée AutoIt:
$aArray[0] = 1
$aArray[1] = True
$aArray[2] = "Texte"
$aArray[3] = $aAutreTableau
Un tableau stocké dans un autre tableau peut être atteint directement, mais cette méthode est légèrement plus lente que d'y accéder par d'autres types de donnée:
Local $aInternal[3] = ["A", "B", "C"] ; Déclare un tableau
Local $aContainer[1] = [$aInternal] ; Déclare a tableau conteneur hébergeant le premier tableau
$sString = ($aContainer[0])[1] ; $sString contient "B"
; Notez la nécessité d'inclure la première définition d'élément de tableau entre (...)
Une table est une variable contenant une série d'éléments de donnée, chacun consistant en une paire clé/valeur. Un élément ne peut être atteint que par sa clé, qui peut être une chaîne ou un nombre entier. Cependant une clé de type nombre entier n'est pas relative à une position de l'élément dans la table - les éléments ne sont pas dans un ordre défini et ne peuvent pas être triés. Les clés de type chaîne, presque exclusivement dans AutoIt, sont sensibles à la casse - "MyKey" n'est pas la même clé que "mykey".
Un exemple:
Vous voulez stocker un certain nombre de variables dans une collection de sorte que vous puissiez les passer à une fonction comme un seul paramètre. L'utilisation d'une table vous permet d'utiliser des clés de type chaîne pour faire des références à la valeur contenue - tels que les ControlIDs d'une série de contrôles indexés par leurs noms. Notez que les éléments peuvent être adressés soit par [] soit par '.':
Local $mControls[]
$mControls["Input"] = GUICtrlCreateInput(....)
$mControls.Combo = GUICtrlCreateCombo(...)
$mControls["Button"] = GUICtrlCreateButton(...)
Pour accéder à une valeur spécifique d'une table, vous utilisez la clé - la notation utilisée n'a pas besoin d'être celle utilisée initialement:
$idControlID = $mMap.Input ; Variable qui contient le ControlID pour Input
$idControlID = $mMap["Combo"] ; Variable qui contient le ControlID pour le Combo
Les clès de type nombre entier doivent utiliser la notation [] et ne sont pas les mêmes que leur équivalent chaîne:
$mMap[3] = "Integer 3" ; Ces clés sont différentes
$mMap["3"] = "String 3"
Les tables doivent être déclarées avant d'être utilisées, en définissant leur portée avec un des mot-clés 'Global/Local/Static'.
Local $mControls[]
L'élément d'une table peut contenir n'importe quel type de donnée d'AutoIt:
$mMap["Integer"] = 1
$mMap.Boolean = True
$mMap["String"] = "Texte"
$mMap.Array = $aArray
$mMap["Map"] = $mAnotherMap
Une table interne peut être atteinte directement:
Local $mInternal[] ; Déclare une table
$mInternal["Internal"] = "AutoIt3" ; Assigne un élément
Local $mContainer[] ; Déclare une table conteneur
$mContainer.Bin = $mInternal ; Assigne la première table comme un élément
; Toutes les valeurs suivantes sont "AutoIt3"
$sString = $mContainer["Bin"]["Internal"]
$sString = $mContainer.Bin.Internal
$sString = $mContainer["Bin"].Internal
$sString = $mContainer.Bin["Internal"]