AutoIt: Grundlagen: Variablen

Aus Wikibooks
Zur Navigation springen Zur Suche springen

< AutoIt

Wer sich an seine Schulzeit zurück erinnert kann vielleicht etwas mit dem Begriff „Variable“ anfangen. Im Mathematikunterricht wurde uns gelehrt dass Variablen „Platzhalter“ sind. Dies ist auch in der Programmierung so. Aber anders als in der Mathematik können in Variablen nicht nur Zahlen, sondern auch Worte und Zeichen hinterlegt werden. Diese hinterlegten Werte können nach belieben gelesen und verändert werden. Somit sind Variablen ein zentraler Punkt in der Programmierung.

Jede Variable hat seinen eigenen Bezeichner den der Programmierer selber festlegen kann. Variablen werden stetig mit einem Dollarzeichen ( $ ) eingeleitet, danach folgt der Bezeichner. Für den Bezeichner dürfen alle Zahlen sowie Groß- und Kleinbuchstaben von A bis Z verwendet werden. Als einziges Sonderzeichen steht uns auch der Unterstrich ( _ ) zur Verfügung. Mithilfe eines Gleichheitszeichen können wir der Variable einen Wert zuweisen.

1 $var = 123
2 MsgBox(0, '', $var)
3 
4 $var = 'Text'
5 MsgBox(0, '', $var)


Variablen deklarieren[Bearbeiten]

Mit der Deklaration einer Variable ist in AutoIt gemeint ihr einen Gültigkeitsbereich und gegebenenfalls einen Wert zuzuordnen. Variablen sind nämlich nicht überall ansprechbar. Je nach ihrem Gültigkeitsbereich können auf bestimmte Variablen nur in besonderen Situationen angesprochen werden. AutoIt unterscheidet konkret nur zwischen globale und lokale Variablen.

Globale Variablen[Bearbeiten]

Wie der Name vielleicht schon vermuten lässt können globale Variablen überall aus dem Skript angesprochen werden. Um eine globale Variable zu deklarieren steht uns das Schlüsselwort „Global“ zur Verfügung. Eine globale Variable muss nur einmal im ganzen Skript als global markiert sein. Danach steht diese ständig zur Verfügung.

1 Global $var
2 
3 ; Die Funktion IsDeclared zeigt uns an ob eine Variable deklariert wurde.
4 ; Der Rückgabewert der Funktion beträgt für globale Variablen gleich 1.
5 MsgBox(0, '', IsDeclared('var'))
6 
7 ; Da wir der Variable noch keinen Wert zugewiesen haben ist diese leer.
8 MsgBox(0, '', $var)

Lokale Variablen[Bearbeiten]

Im Gegensatz zu globalen Variablen lassen sich lokale Variablen nicht überall im Skript ansprechen. Allerdings gilt diese Regelung nur, wenn die Variable in einer eigenen Funktion lokal deklariert wird. Um eine lokale Variable zu deklarieren steht uns in AutoIt das Schlüsselwort „Local“ zur Verfügung.

 1 Global $GlobaleVariable = 123
 2 
 3 
 4 ; Hier rufen wir unsere selbst geschriebene Funktion auf.
 5 EigeneFunktion()
 6 
 7 ; Der Rückgabewert 0 zeigt uns an, dass die Variable noch nicht existiert.
 8 ; Da wir lokale Variable in einer eigenen Funktion untergebracht haben,
 9 ; wird diese nach dem verlassen der Funktion wieder gelöscht.
10 MsgBox(0, 'Skript - IsDeclared', IsDeclared('LokaleVariable'))
11 
12 ;~ MsgBox(0, 'Skript - Lokale Variable', $LokaleVariable) ; Dies würde eine Fehlermeldung erzeugen...
13 
14 
15 ; Wie man eigene Funktionen schreibt und verwendet wird noch auf einer eigenen Seite erklärt.
16 Func EigeneFunktion()
17 	Local $LokaleVariable = 'Text'
18 
19 	; Der Rückgabewert -1 zeigt uns an, dass die Variable nur lokal zur Verfügung steht.
20 	MsgBox(0, 'Eigene Funktion - IsDeclared', IsDeclared('LokaleVariable'))
21 
22 	; Hier wird sowohl die globale, als auch die lokale Variable abgerufen.
23 	MsgBox(0, 'Eigene Funktion - Globale Variable', $GlobaleVariable)
24 	MsgBox(0, 'Eigene Funktion - Lokale Variable', $LokaleVariable)
25 EndFunc

Das „Dim“ Schlüsselwort[Bearbeiten]

Mithilfe des Schlüsselwortes „Dim“ können wir ebenfalls eine Variable deklarieren. Jedoch wird auch hier die Variable entweder global oder lokal definiert. Der einzige Unterschied jedoch ist, dass das Schlüsselwort „Dim“ anhand der gegebenen Umständen selber aussucht wie die Variable deklariert werden soll. Unter folgenden Voraussetzungen kannst du erkennen ob eine mit „Dim“ deklarierte Variable nun global oder lokal definiert wurde:

  1. Wenn die Variable vorher schon als global definiert wurde, so wird die Variable erneut mit leerem Inhalt global deklariert.
  2. Wenn die Variable vorher schon als lokal definiert wurde, so wird die Variable erneut mit leerem Inhalt lokal deklariert.
  3. Wird die Variable mit „Dim“ außerhalb einer Funktion deklariert, so ist diese global verfügbar.
  4. Wird die Variable mit „Dim“ innerhalb einer Funktion deklariert, so ist diese lokal verfügbar.
 1 Global $globalVar
 2 Dim $dimGlobalVar
 3 
 4 
 5 MyFunc()
 6 
 7 
 8 Func MyFunc()
 9 	Local $localVar
10 	Local $dimLocalVar
11 
12 	MsgBox(0, 'Globale Variable', IsDeclared('globalVar'))
13 	MsgBox(0, 'Lokale Variable', IsDeclared('localVar'))
14 	MsgBox(0, 'Dim - Globale Variable', IsDeclared('dimGlobalVar'))
15 	MsgBox(0, 'Dim - Lokale Variable', IsDeclared('dimLocalVar'))
16 EndFunc

Hinweis[Bearbeiten]

Prinzipiell verhält sich das „einfache“ erstellen einer Variable genauso als ob wir die Variable mit „Dim“ deklarieren. Der einzige Unterschied jedoch ist, dass wir die Variable nicht deklarieren sondern nur erstellen.

1 Dim $var1 ; Variable wird deklariert.
2 $var2 = 0 ; Variable wird erstellt.

Dabei handelt es sich nur um einen kleinen Unterschied der etwas mit einer einstellbaren AutoIt Option zu tun hat. Für den Anfänger jedoch irrelevant. Jedoch solltest du wissen dass es dort eine Unterscheidung gibt.

Warum sollte ich eine Variable deklarieren?[Bearbeiten]

Dies hat verschiedene Gründe. Einmal gehört es zum guten Programmierstil den Gültigkeitsbereich einer Variable festzulegen. Zum anderen können damit Fehlerquellen direkt von Anfang an eingedämmt werden. Zwar ist es prinzipiell möglich Variablen zu verwenden ohne ihnen speziell ein Gültigkeitsbereich zuzuordnen, jedoch Fehleranfälliger. Siehe dazu folgende Situation:

Du programmierst für einen Freund (welcher ebenfalls Programmierer ist) eine kleine Funktion:

1 Func MyFunc()
2 	$var = 123
3 	MsgBox(0, 'MyFunc', $var)
4 EndFunc

Dein Freund versucht nun deine Funktion in sein geschriebenes Programm zu integrieren. Das klappt auch ganz gut, jedoch stellt dein Freund fest dass nun irgendwas mit seinem Programm nicht stimmt...

 1 $var = 777
 2 
 3 MyFunc()
 4 
 5 MsgBox(0, 'Skript', $var)
 6 
 7 
 8 
 9 Func MyFunc()
10 	$var = 123
11 	MsgBox(0, 'MyFunc', $var)
12 EndFunc

Was ist denn jetzt los? Sollte die Message Box in Zeile 5 nicht eigentlich eine 777 ausgeben?

Vielleicht hast du ja schon den Fehler erkannt. Da sich eine erstellte Variable wie eine mit „Dim“ deklarierte Variable verhält, wird in der Funktion auf die globale Variable zugegriffen. Das bedeutet dass der bereits vorhandene Wert einfach überschrieben wird. Nun gut, versuchen wir doch einfach mal den Fehler mithilfe von „Dim“ zu bereinigen:

 1 Dim $var = 777
 2 
 3 MyFunc()
 4 
 5 MsgBox(0, 'Skript', $var)
 6 
 7 
 8 
 9 Func MyFunc()
10 	Dim $var = 123
11 	MsgBox(0, 'MyFunc', $var)
12 EndFunc

Tja, leider ist der gleiche Fehler immer noch vorhanden. Aus diesem Grund wird „Dim“ auch nur in einigen Ausnahmefällen verwendet. Um solche Fehler zu vermeiden werden Variablen grundsätzlich nur mit „Global“ sowie „Local“ deklariert. Das Skript muss also folgendermaßen aussehen:

 1 Global $var = 777
 2 
 3 MyFunc()
 4 
 5 MsgBox(0, 'Skript', $var)
 6 
 7 
 8 
 9 Func MyFunc()
10 	Local $var = 123
11 	MsgBox(0, 'MyFunc', $var)
12 EndFunc

Klar hätte man bei diesem Beispiel einfach einen anderen Bezeichner für einen der beiden Variablen nutzen können. Aber sobald man richtige Projekte startet ist es Schluss mit lustig. Nach knapp 3000 Codezeilen weiß selbst der erfahrenste Programmierer nicht mehr alle Bezeichnungen seiner globalen Variablen. Besonders dann wenn dieser eine Pause von 1 bis 3 Monaten eingelegt hat. Um also solche Fehler zu umgehen, und nicht versehentlich auf globale Variablen zuzugreifen, wird der Gültigkeitsbereich für jede Variable festgelegt.

Konstanten[Bearbeiten]

Eine speziellere Form von Variablen stellen die Konstanten dar. Anders als bei normalen Variablen können die Inhalte von Konstanten nicht verändert werden. Somit ist es nicht möglich eine Konstante, während ihrer Lebenszeit, neu zu deklarieren. Aus diesem Grund muss der zu beinhaltende Wert direkt bei der Deklaration angegeben werden. Auch hier kann man wieder zwischen einer globalen sowie lokalen Variable (in diesem Fall Konstante) unterscheiden. Eine Konstante wird, zusätzlich zu der optionalen Angabe des Gültigkeitsbereich, mit dem Schlüsselwort „Const“ deklariert.

1 Const $var = 123

Globale Konstanten[Bearbeiten]

Globale Konstanten verhalten sich genauso wie globale Variablen. Der einzige Unterschied jedoch ist, dass deren Inhalt nicht verändert werden kann. Eine globale Konstante existiert bis zum Programmende. Bis dahin kann keine neue Variable mit dem gleichen Bezeichner deklariert werden.

1 Global Const $var = 123
2 
3 ;~ $var = 777 ; Dies würde eine Fehlermeldung erzeugen...
4 
5 MsgBox(0, '', $var)

Lokale Konstanten[Bearbeiten]

Lokale Konstanten verhalten sich genauso wie lokale Variablen. Der einzige Unterschied jedoch ist, dass der Inhalt nicht verändert werden kann solange die Konstante existiert. Beim verlassen der Funktion wird auch die Konstante gelöscht.

 1 MyFunc()
 2 MyFunc()
 3 MyFunc()
 4 
 5 
 6 
 7 Func MyFunc()
 8 	; Random erzeugt eine zufällige Zahl.
 9 	Local Const $var = Random()
10 
11 ;~ 	$var = 777 ; Dies würde eine Fehlermeldung erzeugen...
12 	MsgBox(0, '', $var)
13 EndFunc

Konstanten mit dem Schlüsselwort „Dim“[Bearbeiten]

Wie bei den Variablen sucht sich „Dim“, je nach Situation, seinen Gültigkeitsbereich selber aus. Jedoch sollte es vermieden werden Konstanten sowohl nur mit „Const“ als auch mit „Dim Const“ zu deklarieren. Die Problematik dahinter ist die Gleiche wie bei den normalen Variablen.

Konstanten mit dem Schlüsselwort „Enum“[Bearbeiten]

Eine etwas speziellere Möglichkeit um mehrere Konstanten zu definieren stellt das Verwenden des Schlüsselwortes „Enum“ dar. Mithilfe dieses Schlüsselwortes können mehrere Konstanten (mit unterschiedlichen oder gleichen Inhalt) deklariert werden. Dabei ist der Inhalt abhängig von der Position des verwendeten Bezeichners.

1 Enum $a, $b, $c, $d, $e, $f
2 
3 MsgBox(0, '', _
4 	'a = ' & $a & @CRLF & _
5 	'b = ' & $b & @CRLF & _
6 	'c = ' & $c & @CRLF & _
7 	'd = ' & $d & @CRLF & _
8 	'e = ' & $e & @CRLF & _
9 	'f = ' & $f)

Zudem ist es möglich auch Konstanten einzeln einen Wert zuzuweisen. Es muss jedoch beachtet werden dass sich der Inhalt aller nachfolgenden Konstanten ändert.

1 Enum $a = 5, $b, $c, $d = 10, $e, $f
2 
3 MsgBox(0, '', _
4 	'a = ' & $a & @CRLF & _
5 	'b = ' & $b & @CRLF & _
6 	'c = ' & $c & @CRLF & _
7 	'd = ' & $d & @CRLF & _
8 	'e = ' & $e & @CRLF & _
9 	'f = ' & $f)

Um die Inhalte der Konstanten in einem bestimmten Schema zu ändern, können wir das Schlüsselwort „Step“ hinzufügen. Dadurch erhalten wir eine gewisse Entscheidungsfreiheit was das verändern des Inhaltes der Konstanten angeht. Uns stehen 3 Optionen zur Verfügung:

  1. Step + (?) >> Alle nachfolgenden Konstanten erhöhen sich um (?). (Addition)
  2. Step - (?) >> Alle nachfolgenden Konstanten vermindern sich um (?). (Subtraktion)
  3. Step * (?) >> Alle nachfolgenden Konstanten verändern sich um (?). (Multiplikation)

Beispiel Addition[Bearbeiten]

1 Enum Step +2 $a, $b, $c, $d, $e, $f
2 
3 MsgBox(0, '', _
4 	'a = ' & $a & @CRLF & _
5 	'b = ' & $b & @CRLF & _
6 	'c = ' & $c & @CRLF & _
7 	'd = ' & $d & @CRLF & _
8 	'e = ' & $e & @CRLF & _
9 	'f = ' & $f)

Beispiel Subtraktion[Bearbeiten]

1 Enum Step -1 $a, $b, $c, $d, $e, $f
2 
3 MsgBox(0, '', _
4 	'a = ' & $a & @CRLF & _
5 	'b = ' & $b & @CRLF & _
6 	'c = ' & $c & @CRLF & _
7 	'd = ' & $d & @CRLF & _
8 	'e = ' & $e & @CRLF & _
9 	'f = ' & $f)

Beispiel Multiplikation[Bearbeiten]

1 Enum Step *2 $a = 1, $b, $c, $d, $e, $f
2 
3 MsgBox(0, '', _
4 	'a = ' & $a & @CRLF & _
5 	'b = ' & $b & @CRLF & _
6 	'c = ' & $c & @CRLF & _
7 	'd = ' & $d & @CRLF & _
8 	'e = ' & $e & @CRLF & _
9 	'f = ' & $f)

Hinweis[Bearbeiten]

Auch Konstanten die mithilfe von „Enum“ deklariert werden, können einen Gültigkeitsbereich zugeordnet werden. Die Regeln sind die gleichen wie bei normalen Konstanten sowie Variablen.

1 Global Enum ; ...
2 Local Enum ; ...
3 Dim Enum ; ...
4 Enum ; ...

Arrays[Bearbeiten]

Mithilfe von Arrays lassen sich größere Datenmengen unter einem Bezeichner unterbringen. Jedoch ist ein einzelner Zugriff auf bestimmte Daten möglich. Ein Array besteht aus Dimensionen und Indizes. Die Dimension gibt dabei die Größenordnung an (beispielsweise 1D, 2D oder auch 3D). Mit dem Index oder die Indizes können auf einzelne Elemente zugegriffen werden. Ein Array wird ansonsten wie eine normale Variable behandelt.

Die Deklaration eines Arrays[Bearbeiten]

Anders als Variablen lassen sich Arrays nicht einfach erstellen, sondern müssen mit einem der 4 Schlüsselwörtern „Global“, „Local“, „Dim“ und/oder „Const“ deklariert werden. Dabei müssen die Anzahl der Elemente sowie die Dimension des Arrays direkt festgelegt werden.

1 Dim $Array[5] 		; 1-dimensionales(x-Achse) Array mit 5 Elementen.
2 Dim $Array[10][5]	; 2-dimensionales(x-Achse, y-Achse) Array mit 10*5 Elementen.
3 Dim $Array[3][6][9]	; 3-dimensionales(x-Achse, y-Achse, z-Achse) Array mit 3*6*9 Elementen.

Folgendes kann man sich unter einem N dimensionales Array vorstellen:

  • 1D Array >> Hier reicht es aus sich das Array als einfache Liste vorzustellen.
  • 2D Array >> Darunter kann man sich eine Tabelle vorstellen mit x an Spalten und y an Zeilen.
  • 3D Array >> Bei einem 3D Array kann man sich einen Raum darstellen mit der Breite x, der Tiefe y und der Höhe z.
  • 4D Array >> Ein vierdimensionales Array wird zumeist in der Entwicklung von Spielen im zusammenhang mit DirectX-Vektoren genutzt und beschreibt die Breite x, die Höhe y, die Tiefe z und die waagerechte Zeit- und Schattenreferenzvariable k.

Technisch kann in AutoIt ein Array mit bis zu 64 Dimensionen erzeugt werden. Praktisch aber reicht maximal ein 3D Array aus, da alles andere unseren Vorstellungen entrinnen würde.

Auf das Array zugreifen[Bearbeiten]

Der Zugriff auf das Array erfolgt ein wenig anders als wie bei einer Variable. Wir haben bei der Deklaration sowohl die Dimension, als auch die Anzahl der Elemente angegeben. Damit AutoIt nun weiß welches Element gemeint ist, muss mit einem Index (oder bei mehreren Dimensionen mit Indizes) gearbeitet werden. Wichtig ist jedoch, dass das erste Element nicht bei dem Index [1] liegt, sondern bei [0]. Das bedeutet bei [5] Elementen eines 1D Arrays haben wir die Indizes [0], [1], [2], [3] und [4] zur Verfügung. Möchte man auf das dritte Element zugreifen, so muss der Index [2] verwendet werden.

1 Dim $Array[5] ; 5 Elemente
2 $Array[0] = 'Erstes Element'
3 $Array[1] = 'Zweites Element'
4 $Array[2] = 'Drittes Element'
5 $Array[3] = 'Viertes Element'
6 $Array[4] = 'Fünftes Element'
7 ;~ $Array[5] = 'Sechstes Element' ; Dies würde eine Fehlermeldung erzeugen...
8 
9 MsgBox(0, '', $Array[2])

Hinweis[Bearbeiten]

Die Inhalte eines Arrays lassen sich auch direkt bei der Deklaration festlegen.

 1 Dim $Array[] = [1, 2, 3] ; 1D Array mit 3 Elementen.
 2 Dim $Array[][] = [[1, 2], [3, 4]] ; 2D Array mit 2*2 Elementen.
 3 Dim $Array[][][] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]] ; 3D Array mit 2*2*2 Elementen.
 4 
 5 MsgBox(0, '', '[0][0][0] = ' & $Array[0][0][0] & @CRLF & _
 6 			  '[0][0][1] = ' & $Array[0][0][1] & @CRLF & _
 7 			  '[0][1][0] = ' & $Array[0][1][0] & @CRLF & _
 8 			  '[0][1][1] = ' & $Array[0][1][1] & @CRLF & _
 9 			  '[1][0][0] = ' & $Array[1][0][0] & @CRLF & _
10 			  '[1][0][1] = ' & $Array[1][0][1] & @CRLF & _
11 			  '[1][1][0] = ' & $Array[1][1][0] & @CRLF & _
12 			  '[1][1][1] = ' & $Array[1][1][1])

Statische Variablen[Bearbeiten]

Der wesentliche Unterschied zwischen einer normalen und einer statischen Variable ist die Lebenszeit. Eine statische Variable wird mit dem Schlüsselwort „Static“ deklariert. Dazu kann der Gültigkeitsbereich „Global“ oder „Local“ angegeben werden. Da sich jedoch eine statische globale Variable in AutoIt genauso verhält wie eine globale Variable, wird darauf nicht näher eingegangen.

1 Global Static ; ...
2 Static Global ; ...
3 Local Static ; ...
4 Static Local ; ...
5 Static ; ...

Lokale statische Variablen[Bearbeiten]

Normalerweise wird eine lokale Variable, nach dem verlassen einer Funktion, gelöscht. Bei einer lokalen statischen Variable ist dies nicht so, diese existiert dennoch weiter. Jedoch kann nach wie vor nur in der Funktion auf die statische Variable zugegriffen werden. Auch Arrays können statisch deklariert werden.

 1 MyFunc()
 2 MyFunc()
 3 MyFunc()
 4 
 5 ;~ MsgBox(0, '', $var) ; Dies würde eine Fehlermeldung erzeugen...
 6 
 7 Func MyFunc()
 8 	Local Static $var
 9 	$var += 1
10 	MsgBox(0, '', $var)
11 EndFunc

Hinweis[Bearbeiten]

Statische Variablen sind nur im Zusammenhang von Funktionen interessant. Aus diesem Grund wird an dieser Stelle nicht weiter darauf eingegangen.