Dieses Dokument behandelt einige allgemeine Konzepte und Konventionen, die von AutoHotkey verwendet werden, wobei der Schwerpunkt eher auf Erklärungen als auf Code liegt. Es wird nicht vorausgesetzt, dass der Leser Vorkenntnisse in Scripting oder Programmierung hat, aber er sollte offen für neue technische Begriffe sein.
Genauere Informationen zur Syntax finden Sie unter Skriptsprache.
Ein Wert repräsentiert eine einzelne Information innerhalb eines Programms. Zum Beispiel wäre das der Name einer zu sendenden Taste oder eines zu startenden Programms, die Anzahl der Tastendrücke, der Titel eines zu aktivierenden Fensters, oder was auch immer innerhalb des Programms oder Skripts eine Bedeutung hat.
AutoHotkey unterstützt folgende Typen von Werten:
Mit der Type-Funktion kann der Typ eines Wertes ermittelt werden.
Einige andere verwandte Konzepte:
Eine Zeichenkette ist einfach nur Text. Jede Zeichenkette ist eigentlich eine Sequenz, Folge oder Kette von Zeichen. Sie kann aber auch als eine einzelne Entität betrachtet werden. Die Länge einer Zeichenkette entspricht der Anzahl der Zeichen in der Sequenz, während die Position eines Zeichens innerhalb der Zeichenkette lediglich die fortlaufende Nummer dieses Zeichens ist. Gemäß der Konvention von AutoHotkey befindet sich das erste Zeichen auf Position 1.
Numerische Zeichenketten: Eine Kette von Zahlen (oder von anderen unterstützten Zahlenformaten) wird automatisch als Zahl interpretiert, wenn eine mathematische Operation oder ein Vergleich dies erfordert.
Wie literaler (direkt geschriebener) Text in einem Skript geschrieben werden sollte, hängt vom Kontext ab. Zum Beispiel müssen Zeichenketten in einem Ausdruck in Anführungszeichen gesetzt werden. In Direktiven (außer #HotIf) und automatisch-ersetzenden Hotstrings werden keine Anführungszeichen benötigt.
Eine genauere Erklärung der Funktionsweise von Zeichenketten finden Sie unter Zeichenkettenkodierung.
AutoHotkey unterstützt folgende Zahlenformate:
123, 00123 oder -1.0x7B, 0x007B oder -0x1.3.14159.Hexadezimalzahlen müssen mit dem 0x- oder 0X-Präfix beginnen, sofern in der Dokumentation nichts anderes angegeben ist. Dieses Präfix muss nach einem Vorzeichen wie + oder -, falls vorhanden, und vor führenden Nullen stehen. Zum Beispiel ist 0x001 gültig, aber nicht 000x1.
Zahlen, die mit einem Dezimalpunkt geschrieben werden, gelten immer als Floating-Point-Zahlen, auch wenn die Dezimalstelle eine Null ist. Zum Beispiel sind 42 und 42.0 in der Regel gleich, aber nicht immer. Die wissenschaftliche Schreibweise wird ebenfalls erkannt (z.B. 1.0e4 und -2.1E-4), erzeugt aber immer eine Floating-Point-Zahl, egal ob ein Dezimalpunkt vorhanden ist oder nicht.
Das Dezimaltrennzeichen ist immer ein Punkt, auch wenn in den Ländereinstellungen des Benutzers ein Komma angegeben ist.
Wenn eine Zahl in eine Zeichenkette umgewandelt wird, wird sie als Dezimalzahl formatiert. Floating-Point-Zahlen werden mit voller Genauigkeit formatiert (wobei redundante Nullen am Ende verworfen werden), was in einigen Fällen zu einer Ungenauigkeit führen kann. Verwenden Sie die Format-Funktion, um eine numerische Zeichenkette in einem anderen Format zu erzeugen. Floating-Point-Zahlen können auch mit der Round-Funktion formatiert werden.
Details über den Bereich und die Genauigkeit von numerischen Werten finden Sie unter Reine Zahlen.
Ein boolescher Wert kann entweder True (wahr) oder False (falsch) sein. Boolesche Werte werden verwendet, um etwas wiederzugeben, das exakt zwei mögliche Zustände hat, wie z.B. die Wahrheit eines Ausdrucks. Der Ausdruck (x <= y) ist z.B. True, wenn x kleiner gleich y ist. Ein boolescher Wert könnte auch Yes oder No, On oder Off, Down oder Up (z.B. bei GetKeyState) und so weiter repräsentieren.
AutoHotkey hat keinen spezifischen booleschen Wertetyp und verwendet daher den Integerwert 0 für False und 1 für True. In Fällen, wo der Wert entweder True oder False sein muss, wird eine leere Zeichenkette oder 0 als False und alle anderen Werte als True angesehen. (Objekte werden immer als True angesehen.)
Die Wörter True und False sind interne Variablen, die 1 bzw. 0 enthalten. Diese können verwendet werden, um die Lesbarkeit eines Skripts zu verbessern.
AutoHotkey hat keinen Wert, der eindeutig nichts, null, nil oder undefined repräsentiert, wie es in anderen Sprachen der Fall ist.
Anstatt einen "Null"- oder "undefinierten" Wert zu erzeugen, wird ein UnsetError ausgelöst, wenn versucht wird, eine Variable, eine Eigenschaft, ein Array-Element oder ein Map-Element ohne Wert zu lesen. Auf diese Weise lassen sich Fehler leichter erkennen, als wenn ein Nullwert implizit im Code weitergereicht wird. Siehe auch: Uninitialisierte Variablen.
Die optionalen Parameter einer Funktion können weggelassen werden, wenn die Funktion aufgerufen wird. In diesem Fall kann die Funktion ihr Verhalten ändern oder einen Standardwert verwenden. Parameter werden normalerweise weggelassen, indem sie einfach nicht in den Code geschrieben werden, aber sie können auch explizit oder bedingt durch die Verwendung des Schlüsselworts unset weggelassen werden. Dieses spezielle Signal kann nur explizit mit dem Vielleicht-Operator (Var?) weitergegeben werden. Ein ungesetzter Parameter erhält automatisch seinen Standardwert (falls vorhanden), bevor die Funktion ausgeführt wird.
Manchmal wird, vorwiegend aus historischen Gründen, eine leere Zeichenkette verwendet, wo eine andere Sprache Null oder einen undefinierten Wert verwenden würde, z.B. bei Funktionen, die keinen expliziten Rückgabewert haben.
Wenn eine Variable oder ein Parameter als "leer" bezeichnet wird, ist in der Regel eine leere Zeichenkette (eine Zeichenkette mit der Länge 0) gemeint. Dies ist nicht dasselbe wie das Weglassen eines Parameters, obwohl es in einigen Fällen den gleichen Effekt haben kann.
Das Objekt ist der zusammengesetzte bzw. abstrakte Datentyp von AutoHotkey. Ein Objekt besteht aus beliebig vielen Eigenschaften (die abgerufen oder gesetzt werden können) und Methoden (die aufgerufen werden können). Der Name und Effekt jeder Eigenschaft oder Methode hängen vom jeweiligen Objekt oder Objekttyp ab.
Objekte haben die folgenden Attribute:
alpha := [] ein neues Array und speichert eine Referenz in alpha. bravo := alpha kopiert die Referenz (nicht das Objekt) nach bravo, so dass beide auf dasselbe Objekt verweisen. Wenn es heißt, dass ein Array oder eine Variable ein Objekt enthält, enthält es/sie in Wirklichkeit eine Referenz zum Objekt.if obj, !obj oder obj ? x : y.MsgBox(meinObjekt) ein leeres Mitteilungsfenster an. In anderen Fällen kann ein TypeError ausgelöst werden (was in Zukunft die Norm sein wird).Hinweis: Alle von Object abgeleiteten Objekte haben zusätzliche geteilte Verhaltensweisen, Eigenschaften und Methoden.
Ein Objekt kann für folgende Dinge verwendet werden:
Die richtige Verwendung von Objekten (und insbesondere Klassen) kann zu modularem und wiederverwendbarem Code führen. Modularer Code ist in der Regel leichter zu testen, zu verstehen und zu pflegen. So kann z.B. ein Abschnitt des Codes verbessert oder geändert werden, ohne dass die Details anderer Abschnitte bekannt sein müssen und ohne dass entsprechende Änderungen an diesen Abschnitten vorgenommen werden müssen. Wiederverwendbarer Code spart Zeit, da das Schreiben und Testen von Code für gleiche oder ähnliche Aufgaben entfällt.
Dieser Abschnitt baut auf folgenden Konzepten auf, die in späteren Abschnitten behandelt werden: Variablen, Funktionen
Objekte arbeiten nach dem Prinzip der Meldungsübermittlung. Sie wissen nicht, wo sich der Code oder die Variablen eines Objekts tatsächlich befinden, also müssen Sie eine Meldung an das Objekt übergeben, wie z.B. "gib mir foo" oder "gehe zu bar", und sich darauf verlassen, dass das Objekt auf die Meldung reagiert. Objekte in AutoHotkey unterstützen die folgenden grundlegenden Meldungen:
:=.().Eine Eigenschaft ist ein Aspekt des Objekts, der gesetzt und/oder abgerufen werden kann. Zum Beispiel hat Array eine Length-Eigenschaft, die die Anzahl der Elemente im Array widerspiegelt. Beim Definieren einer Eigenschaft kann ihr eine beliebige Bedeutung zugewiesen werden. Grundsätzlich verhält sich eine Eigenschaft wie eine Variable, aber ihr Wert kann beim Abrufen geändert und beim Setzen nirgendwo gespeichert werden.
Jede Meldung enthält folgende Angaben, meistens dort, wo die Eigenschaft oder Methode aufgerufen wird:
Zum Beispiel:
meinObj.MethodeName(Param1) Wert := meinObj.EigenschaftName[Param1]
Ein Objekt kann auch eine Standardeigenschaft haben, die indirekt aufgerufen wird, wenn die eckigen Klammern ohne Eigenschaftsnamen verwendet werden. Zum Beispiel:
Wert := meinObj[Param1]
Grundsätzlich hat Set die gleiche Bedeutung wie eine Zuweisung und verwendet daher den gleichen Operator:
meinObj.Name := Wert meinObj.Name[Param1, Param2, ..., ParamN] := Wert meinObj[Param1, Param2, ..., ParamN] := Wert
Mithilfe einer Variable können Sie einen Namen als Platzhalter für einen Wert verwenden. Sie können diesen Wert jederzeit während der Skriptausführung ändern. Ein Hotkey könnte z.B. eine Variable press_count verwenden, um zu zählen, wie oft er gedrückt wurde, und jedes Mal eine andere Taste senden, wenn press_count ein Vielfaches von 3 ist (jeder dritte Tastendruck). Eine Variable, der nur einmal ein Wert zugewiesen wird, kann ebenfalls nützlich sein. Zum Beispiel können Sie die Variable WebBrowserTitle nutzen, um die Aktualisierung Ihres Codes zu erleichtern, wenn Sie Ihren bevorzugten Webbrowser ändern oder wenn sich der Titel oder die Fensterklasse aufgrund eines Software-Updates ändert.
In AutoHotkey werden Variablen erstellt, sobald sie verwendet werden. Jede Variable ist nicht dauerhaft auf einen einzigen Datentyp beschränkt, sondern kann stattdessen einen Wert beliebigen Typs enthalten: Zeichenkette, Zahl oder Objekt. Der Versuch, eine Variable ohne zugewiesenen Wert zu lesen, wird als Fehler gewertet, daher ist es wichtig, Variablen zu initialisieren.
Eine Variable hat drei Hauptaspekte:
Für Variablennamen gelten einige Einschränkungen - Einzelheiten finden Sie unter Namen. Kurz gesagt ist es am sichersten, Namen zu verwenden, die aus ASCII-Buchstaben (nicht Groß-/Kleinschreibung-sensitiv), Ziffern und Unterstrichen bestehen, und Namen zu vermeiden, die mit einer Ziffer beginnen.
Ein Variablenname hat einen Gültigkeitsbereich, der definiert, wo im Code dieser Name verwendet werden kann, um auf diese bestimmte Variable zu verweisen; mit anderen Worten, wo die Variable sichtbar ist. Wenn eine Variable in einem bestimmten Gültigkeitsbereich nicht sichtbar ist, kann derselbe Name auf eine andere Variable verweisen. Beide Variablen können gleichzeitig existieren, aber nur eine ist für jeden Teil des Skripts sichtbar. Globale Variablen sind im "globalen Bereich" (d.h. außerhalb von Funktionen) sichtbar und können standardmäßig von Funktionen gelesen werden, müssen aber deklariert werden, wenn ihnen innerhalb einer Funktion ein Wert zugewiesen werden soll. Lokale Variablen sind nur innerhalb der Funktion sichtbar, die sie erzeugt hat.
Eine Variable kann als Behälter oder Speicherort für einen Wert betrachtet werden. In der Dokumentation wird der Wert einer Variable häufig als Inhalt der Variable bezeichnet. Bei x := 42 kann man auch sagen, dass die Variable x die Zahl 42 als Wert hat oder dass der Wert von x eine 42 ist.
Es ist wichtig zu wissen, dass eine Variable und ihr Wert nicht dasselbe sind. Zum Beispiel könnten wir sagen: "meinArray ist ein Array", aber was wir wirklich meinen, ist, dass meinArray eine Variable ist, die eine Referenz zu einem Array enthält. Wir nehmen eine Abkürzung, indem wir den Namen der Variable verwenden, um auf ihren Wert zu verweisen, aber "meinArray" ist eigentlich nur der Name der Variable; das Array-Objekt weiß nicht, dass es einen Namen hat, und könnte von vielen verschiedenen Variablen (bzw. Namen) referenziert werden.
Eine Variable zu initialisieren bedeutet, ihr einen Startwert zuzuweisen. Eine Variable, der noch kein Wert zugewiesen wurde, ist uninitialisiert (oder kurz: ungesetzt). Der Versuch, eine uninitialisierte Variable zu lesen, wird als Fehler gewertet. Dies hilft bei der Erkennung von Fehlern wie z.B. falsch geschriebene Namen und vergessene Zuweisungen.
IsSet kann verwendet werden, um zu prüfen, ob eine Variable initialisiert wurde, z.B. um eine globale oder statische Variable bei der ersten Verwendung zu initialisieren.
Um eine Variable ungesetzt zu machen, kombinieren Sie eine direkte Zuweisung (:=) mit dem Schlüsselwort unset oder dem Operator Vielleicht (var?). Zum Beispiel: Var := unset, Var1 := (Var2?).
Der Oder-Vielleicht-Operator (??) kann verwendet werden, um einen Standardwert für eine Variable ohne Wert bereitzustellen. Zum Beispiel ist MeineVar ?? "Standard" äquivalent zu IsSet(MeineVar) ? MeineVar : "Standard".
Eine Vielzahl von Variablen sind fest in das Programm integriert und können normal referenziert werden. Solche Variablen sind schreibgeschützt, sofern nicht anders angegeben, d.h. ihr Inhalt kann nicht geändert werden. Konventionsgemäß beginnen die meisten dieser Variablen mit dem Präfix A_, daher ist es am besten, dieses Präfix nicht für eigene Variablen zu verwenden.
Einige Variablen wie A_KeyDelay und A_TitleMatchMode spiegeln Einstellungen wider, die das Verhalten des Skripts steuern, und separate Werte für jeden Thread aufbewahren. Dadurch können Subroutinen, die von neuen Threads gestartet werden (z.B. für Hotkeys, Menüs, Timer und so weiter), Einstellungen ändern, ohne andere Threads zu beeinflussen.
Einige spezielle Variablen werden nicht periodisch aktualisiert, sondern ihr Wert wird abgerufen oder berechnet, wenn das Skript auf die Variable verweist. Eine solche Variable ist zum Beispiel A_Clipboard, die den aktuellen Inhalt der Zwischenablage abruft, oder A_TimeSinceThisHotkey, die die Anzahl der Millisekunden berechnet, die seit dem Drücken des Hotkeys vergangen sind.
Siehe auch: Liste von internen Variablen.
Umgebungsvariablen werden vom Betriebssystem verwaltet. Sie können sich eine Liste von Umgebungsvariablen anzeigen lassen, indem Sie SET in die Windows-Konsole eingeben und ENTER drücken.
Mit EnvSet kann eine neue Umgebungsvariable erstellt oder der Inhalt einer vorhandenen Umgebungsvariable geändert werden. Solche Ergänzungen und Änderungen sind nur für das Skript sichtbar und werden vom Rest des Systems ignoriert. Allerdings erben alle Programme oder Skripte, die das Skript über Run oder RunWait startet, in der Regel eine Kopie der Umgebungsvariablen des übergeordneten Skripts.
Mit EnvGet kann eine Umgebungsvariable abgerufen werden. Zum Beispiel:
Pfad := EnvGet("PATH")
Innerhalb eines Ausdrucks wird jede Variablenreferenz automatisch in ihren Inhalt aufgelöst, sofern sie nicht Ziel einer Zuweisung oder des Referenzoperators (&) ist. Mit anderen Worten, der Aufruf von MeineFunktion(MeineVar) würde den Wert von MeineVar an MeineFunktion übergeben, nicht an die Variable selbst. Die Funktion hätte dann ihre eigene lokale Variable (den Parameter) mit dem gleichen Wert wie MeineVar, wäre aber nicht in der Lage, MeineVar einen neuen Wert zuzuweisen. Kurz gesagt, der Parameter wird via Wert übergeben.
Mit dem Referenzoperator (&) kann eine Variable wie ein Wert behandelt werden. &MeineVar erzeugt eine VarRef, die wie jeder andere Wert verwendet werden kann: Sie kann einer anderen Variable oder Eigenschaft zugewiesen, in ein Array eingefügt, an eine Funktion übergeben oder von einer Funktion zurückgegeben werden, usw. Eine VarRef kann verwendet werden, um der ursprünglichen Zielvariable etwas zuzuweisen oder ihren Wert durch Dereferenzierung abzurufen.
Ein Funktionsparameter kann einfach durch Voranstellen eines Und-Zeichens als ByRef deklariert werden. Dies zwingt den Aufrufer, eine VarRef zu übergeben, und erlaubt der Funktion, die VarRef bereits durch einen simplen Verweis auf den Parameter (ohne Prozentzeichen) zu "derefenzieren".
class VarRef extends Any
Die VarRef-Klasse hat derzeit keine vordefinierten Methoden oder Eigenschaften, aber Sie können mit Wert is VarRef testen, ob ein Wert eine VarRef ist.
Wenn eine VarRef als Parameter einer COM-Methode verwendet wird, wird das Objekt selbst nicht übergeben. Stattdessen wird ihr Wert in einen temporären VARIANT kopiert, der mit dem Variantentyp VT_BYREF|VT_VARIANT übergeben wird. Nach Abschluss der Methode wird der VarRef der neue Wert zugewiesen.
Obwohl eine Variable üblicherweise dazu gedacht ist, einen einzelnen Wert zu enthalten, und dieser Wert einen bestimmten Typ (Zeichenkette, Zahl oder Objekt) hat, wandelt AutoHotkey automatisch zwischen Zahlen und Zeichenketten bei Fällen wie "Wert ist " meineZahl und MsgBox meineZahl um. Da solche Umwandlungen sehr häufig vorkommen können, wird jedes Mal, wenn eine Variable, die eine Zahl enthält, in eine Zeichenkette umgewandelt wird, das Ergebnis in der Variable zwischengespeichert.
Momentan wird AutoHotkey v2 eine reine Zahl nur bei der Zuweisung einer reinen Zahl an eine Variable zwischenspeichern, nicht wenn sie gelesen wird. Dadurch bleibt die Möglichkeit erhalten, zwischen Zeichenketten und reinen Zahlen zu unterscheiden (z.B. bei der Type-Funktion oder bei der Übergabe von Werten an COM-Objekte).
Eine Funktion ist das Werkzeug des Skripts, um etwas zu tun.
Funktionen können viele verschiedene Zwecke haben. Einige Funktionen könnten nur eine einfache Berechnung durchführen, während andere sofort sichtbare Effekte erzielen, wie z.B. das Verschieben eines Fensters. Eine der Stärken von AutoHotkey ist die einfache Möglichkeit, andere Programme zu automatisieren und viele andere häufige Aufgaben durch einfaches Aufrufen einiger weniger Funktionen zu erledigen. Beispiele finden Sie in der Funktionsliste.
In dieser Dokumentation werden einige gebräuchliche Wörter in einer Weise verwendet, die für jemanden ohne Vorkenntnisse nicht offensichtlich ist. Nachfolgend finden Sie einige dieser Wörter/Phrasen, die häufig im Zusammenhang mit Funktionen verwendet werden:
Der Aufruf einer Funktion bewirkt, dass das Programm diese startet, ausführt oder auswertet. Mit anderen Worten, ein Funktionsaufruf überträgt vorübergehend die Kontrolle vom Skript auf die Funktion. Wenn die Funktion ihren Zweck erfüllt hat, überträgt sie die Kontrolle via Return wieder auf das Skript. Das heißt, dass jeglicher Code nach dem Funktionsaufruf erst dann ausgeführt wird, wenn die Funktion ihr Ende erreicht hat.
Manchmal hat eine Funktion jedoch bereits ihr Ende erreicht, bevor ihre Effekte für den Benutzer sichtbar werden. Zum Beispiel kann die Send-Funktion ihre Tastendrücke bereits gesendet haben, bevor die Tastendrücke ihr Ziel erreicht und die gewünschte Wirkung erzielt haben.
Normalerweise akzeptiert eine Funktion einen oder mehrere Parameter, die angeben, wie oder womit sie agieren soll. Jeder Parameter ist ein Wert, z.B. eine Zeichenkette oder Zahl. Die Parameter von WinMove legen z.B. fest, welches Fenster wohin verschoben werden soll. Parameter werden auch als Argumente bezeichnet. Gängige Abkürzungen sind Param und Arg.
Parameter werden an eine Funktion übergeben, d.h. für jeden Parameter der Funktion ist beim Aufrufen ein Wert angegeben. Zum Beispiel können Sie den Namen einer Taste an GetKeyState übergeben, um festzustellen, ob diese Taste gedrückt gehalten wird.
Funktionen geben einen Wert über Return zurück, daher wird das Ergebnis der Funktion oft als Rückgabewert bezeichnet. Zum Beispiel gibt StrLen die Anzahl der Zeichen zurück, die in einer Zeichenkette enthalten sind. Funktionen können auch Ergebnisse in Variablen speichern, z.B. wenn sie mehr als ein Ergebnis zurückgeben müssen (siehe Rückgabewerte).
Ein Funktionsaufruf wird manchmal auch als Befehl bezeichnet, da dem Programm quasi befohlen wird, eine bestimmte Aktion auszuführen. (Aus historischen Gründen kann sich der Begriff Befehl auf eine bestimmte Form des Funktionsaufrufs beziehen, bei der die Klammern weggelassen und der Rückgabewert verworfen wird. Technisch gesehen ist dies jedoch eine Funktionsaufrufanweisung.)
Funktionen erwarten normalerweise ihre Parameter in einer bestimmten Reihenfolge, daher hängt die Bedeutung der einzelnen Parameterwerte von ihrer Position in der kommagetrennten Parameterliste ab. Einige Parameter können weg bzw. leer gelassen werden - in diesem Fall aber kann das darauffolgende Komma nur weggelassen werden, wenn alle übrigen Parameter ebenfalls weggelassen werden. Zum Beispiel hat ControlSend die folgende Syntax:
ControlSend Tasten , Steuerelement, FensterTitel, FensterText, AusnahmeTitel, AusnahmeText
Die eckigen Klammern signalisieren, dass die darin enthaltenen Parameter optional sind (die Klammern selbst müssen im eigentlichen Code weggelassen werden). In der Regel muss auch das Zielfenster angegeben werden. Zum Beispiel:
ControlSend "^{Home}", "Edit1", "A" ; Korrekt. Steuerelement ist angegeben.
ControlSend "^{Home}", "A" ; Falsch: Parameter stimmen nicht überein.
ControlSend "^{Home}",, "A" ; Korrekt. Steuerelement wurde weggelassen.
Eine Methode ist eine Funktion, die einem bestimmten Objekt oder Objekttyp zugeordnet ist. Um eine Methode aufzurufen, muss ein Objekt und ein Methodenname angegeben werden. Der Methodenname identifiziert die Funktion nicht eindeutig; was beim Methodenaufruf passieren soll, hängt vom Objekt ab. Zum Beispiel könnte x.Show() ein Menü anzeigen, eine GUI anzeigen, einen Fehler auslösen oder etwas anderes tun, je nachdem, was x ist. Mit anderen Worten, ein Methodenaufruf übergibt einfach eine Meldung an das Objekt, mit der Anweisung, etwas zu tun. Weitere Informationen finden Sie unter Objektorientierte Schnittstelle und Operatoren für Objekte.
Der Kontrollfluss ist die Reihenfolge, in der die einzelnen Anweisungen ausgeführt werden. Im Normalfall werden Anweisungen der Reihe nach von oben nach unten ausgeführt, aber dieses Verhalten kann mit einer Kontrollanweisung manipuliert werden, z.B. indem Anweisungen wiederholt ausgeführt werden, oder nur ausgeführt werden, wenn eine bestimmte Bedingung erfüllt ist.
Eine Anweisung ist einfach gesagt das kleinste eigenständige Element der Sprache, das eine ausführende Aktion ausdrückt. Anweisungen in AutoHotkey sind Zuweisungen, Funktionsaufrufe und andere Ausdrücke. Direktiven, Zweifach-Doppelpunkt-Tags von Hotkeys und Hotstrings, und Deklarationen ohne Zuweisungen sind dagegen keine Anweisungen; sie werden nach dem Programmstart und vor dem Ausführen des Skripts abgearbeitet.
Ausführen, Durchführen, Auswerten, Umsetzen und so weiter. Ausführen hat grundsätzlich die gleiche Bedeutung wie im normalen Sprachgebrauch.
Der Körper einer Kontrollanweisung ist die Anweisung oder Anweisungsgruppe, zu der sie gehört. Zum Beispiel wird der Körper einer if-Anweisung nur ausgeführt, wenn eine bestimmte Bedingung erfüllt ist.
Schauen Sie sich zum Beispiel die folgenden Instruktionen an:
Wir machen einen Schritt nach dem anderen, und wenn dieser Schritt beendet ist, gehen wir zum nächsten Schritt über. So ähnlich erfolgt auch der Kontrollfluss in einem Programm oder Skript normalerweise von einer Anweisung zur nächsten. Was aber, wenn wir etwas in ein existierendes Notepad-Fenster schreiben wollen? Schauen Sie sich die folgenden überarbeiteten Instruktionen an:
Wir öffnen also entweder Notepad oder aktivieren Notepad, je nachdem, ob es bereits läuft. Punkt 1 ist eine bedingte Anweisung, auch bekannt als if-Anweisung, d.h. wir führen ihren Körper (Punkt 1.1 bis Punkt 1.2) nur aus, wenn eine Bedingung erfüllt ist. Punkt 2 ist eine else-Anweisung; wir führen ihren Körper (Punkt 2.1) nur aus, wenn die Bedingung einer vorherigen if-Anweisung nicht erfüllt ist. Je nach Bedingung erfolgt der Kontrollfluss auf eine von zwei Arten: Punkt 1 (if true) → Punkt 1.1 → Punkt 1.2 → Punkt 3; oder Punkt 1 (if false) → Punkt 2 (else) → Punkt 2.1 → Punkt 3.
Die obigen Instruktionen können in den folgenden Code umgewandelt werden:
if (not WinExist("ahk_class Notepad"))
{
Run "Notepad"
WinWait "ahk_class Notepad"
}
else
WinActivate "ahk_class Notepad"
Send "Hallo, Welt{!}"
In unseren schriftlichen Instruktionen haben wir Einrückungen und Nummerierungen verwendet, um die Anweisungen zu gruppieren. Skripte funktionieren etwas anders. Einrückungen verbessern zwar die Lesbarkeit des Codes, haben aber keinen Einfluss auf die Gruppierung von Anweisungen in AutoHotkey. Stattdessen werden Anweisungen gruppiert, indem man sie, wie oben gezeigt, mit geschweiften Klammern umschließt. Dies wird als Block bezeichnet.
Details zur Syntax - also wie man Kontrollanweisungen in AutoHotkey schreibt oder erkennt - finden Sie unter Kontrollfluss.
Jedes Zeichen in der Zeichenkette entspricht einer Zahl, auch Ordinalzahl genannt, oder einem Zeichencode. Zum Beispiel würde der Wert "Abc" wie folgt dargestellt werden:
| A | b | c | |
| 65 | 98 | 99 | 0 |
Kodierung: Die Kodierung einer Zeichenkette definiert, wie Symbole mit den Ordinalzahlen und Ordinalzahlen mit den Bytes verknüpft werden. Es gibt viele verschiedene Kodierungen, aber da alle Kodierungen, die von AutoHotkey unterstützt werden, ASCII als Untermenge enthalten, haben die Zeichencodes 0 bis 127 immer die gleiche Bedeutung. So hat zum Beispiel 'A' immer den Zeichencode 65.
Nullterminierung: Jede Zeichenkette wird mit einem "Nullzeichen" terminiert; solche Zeichen haben den Ordinalwert Null und markieren das Ende einer Zeichenkette. Die Länge der Zeichenkette kann anhand der Position des Nullterminators abgeleitet werden, aber AutoHotkey speichert auch die Länge, um die Performanz zu erhöhen und Nullzeichen innerhalb der Länge der Zeichenkette zu erlauben.
Hinweis: Aufgrund der Abhängigkeit von Nullterminierung unterstützen viele interne Funktionen und die meisten Ausdrucksoperatoren keine Zeichenketten mit eingebetteten Nullzeichen und lesen stattdessen eine Zeichenkette nur bis zum ersten Nullzeichen. Eine grundlegende Manipulation solcher Zeichenketten wird jedoch unterstützt; z.B. Verkettung, ==, !==, Chr(0), StrLen, SubStr, Zuweisungen, Parameterwerte und Return.
Native Kodierung: Obwohl AutoHotkey den Umgang mit Texten unterschiedlicher Kodierung ermöglicht, setzen die internen Funktionen - und bis zu einem gewissen Grad auch die Sprache selbst - voraus, dass Zeichenkettenwerte in einer bestimmten Kodierung vorliegen. Dies wird als native Kodierung bezeichnet. Die native Kodierung hängt von der Version von AutoHotkey ab:
Unicode-Versionen von AutoHotkey verwenden UTF-16. Das kleinste Element in einer UTF-16-Zeichenkette ist zwei Bytes (16 Bit) groß. Unicode-Zeichen im Bereich von 0 bis 65535 (U+FFFF) werden von einer einzelnen 16-Bit-Codeeinheit des gleichen Wertes repräsentiert, während Zeichen im Bereich von 65536 (U+10000) bis 1114111 (U+10FFFF) von einem Ersatzzeichenpaar repräsentiert werden; also exakt zwei 16-Bit-Codeeinheiten zwischen 0xD800 und 0xDFFF. (weitere Details zu Ersatzzeichenpaaren und Methoden zu deren Kodierung bzw. Dekodierung finden Sie im Internet.)
ANSI-Versionen von AutoHotkey verwenden die Standard-ANSI-Codepage des Systems, abhängig von den Sprach- und Regionseinstellungen des Systems oder von der Systemeinstellung "Sprache für Unicode-inkompatible Programme". Das kleinste Element einer ANSI-Zeichenkette ist ein Byte groß. Einige Codepages enthalten jedoch Zeichen, die von Sequenzen mehrerer Bytes repräsentiert werden (das sind immer ASCII-fremde Zeichen).
Hinweis: AutoHotkey v2 verwendet nativ Unicode und hat keine ANSI-Version.
Zeichen: In der Regel wird in anderen Abschnitten dieser Dokumentation der Begriff "Zeichen" für die kleinste Einheit einer Zeichenkette verwendet; Bytes für ANSI-Zeichenketten und 16-Bit-Codeeinheiten für Unicode-Zeichenketten (UTF-16). Aus praktischen Gründen werden die Länge einer Zeichenkette und die Positionen innerhalb einer Zeichenkette in diesen festen Einheiten gemessen, auch wenn sie nicht immer vollständige Unicode-Zeichen sind.
FileRead, FileAppend, FileOpen und das File-Objekt bieten Möglichkeiten, um Text mit einer bestimmten Kodierung aus/in eine Datei zu lesen/schreiben.
Die Funktionen StrGet und StrPut können verwendet werden, um die native Kodierung einer Zeichenkette in eine andere umzuwandeln, und umgekehrt. Diese Funktionen sind jedoch in der Regel nur in Kombination mit Datenstrukturen und der DllCall-Funktion sinnvoll. Zeichenketten, die direkt an oder von DllCall übergeben werden, können mit den Parametertypen AStr oder WStr in ANSI oder UTF-16 umgewandelt werden.
Techniken zum Umgang mit den Unterschieden zwischen ANSI- und Unicode-Versionen von AutoHotkey finden Sie unter Unicode vs. ANSI.
Eine reine oder binäre Zahl ist eine Zahl im Speicher, mit deren Format die CPU des Computers direkt umgehen kann, um z.B. Berechnungen durchzuführen. In den meisten Fällen wandelt AutoHotkey automatisch zwischen numerischen Zeichenketten und reinen Zahlen um, aber nur selten muss AutoHotkey zwischen den beiden Typen unterscheiden. AutoHotkey verwendet hauptsächlich zwei Datentypen für reine Zahlen:
Diese Datentypen beeinflussen den Bereich und die Genauigkeit von rein numerischen Werten bei Variablen, Eigenschaften, Array-/Map-Elementen und -Indizes, Funktionsparametern und Rückgabewerten, und temporären Ergebnissen von Operatoren in einem Ausdruck. Mathematische Operatoren und Funktionen führen 64-Bit-Integer- oder -Floating-Point-Operationen durch. Bitweise Operatoren führen 64-Bit-Integer-Operationen durch.
Mit anderen Worten gelten für Skripte folgende Einschränkungen:
Integer müssen im vorzeichenfähigen 64-Bit-Bereich liegen, d.h. von -9223372036854775808 (-0x8000000000000000, oder -263) bis 9223372036854775807 (0x7FFFFFFFFFFFFFFF, oder 263-1). Wenn eine Integerkonstante in einem Ausdruck außerhalb dieses Bereichs liegt, werden nur die niedrigen 64 Bit verwendet (der Wert wird gekürzt). Obwohl größere Werte in einer Zeichenkette enthalten sein können, wird jeder Versuch, die Zeichenkette in eine Zahl umzuwandeln (z.B. in einer mathematischen Operation), dazu führen, dass sie ebenfalls gekürzt wird.
Floating-Point-Zahlen unterstützen in der Regel eine Genauigkeit von 15 Dezimalstellen.
Hinweis: Es gibt einige Dezimalstellen, die das binäre Floating-Point-Format nicht exakt darstellen kann, so dass eine Zahl auf die nächstliegende darstellbare Zahl gerundet wird. Das kann zu unerwarteten Ergebnissen führen. Zum Beispiel:
MsgBox 0.1 + 0 ; 0.10000000000000001 MsgBox 0.1 + 0.2 ; 0.30000000000000004 MsgBox 0.3 + 0 ; 0.29999999999999999 MsgBox 0.1 + 0.2 = 0.3 ; 0 (nicht identisch)
Eine Strategie zur Lösung dieses Problems besteht darin, den direkten Vergleich zu vermeiden und stattdessen die Differenz zu vergleichen. Zum Beispiel:
MsgBox Abs((0.1 + 0.2) - (0.3)) < 0.0000000000000001
Eine andere Strategie besteht darin, vor dem Vergleich explizit zu runden, z.B. durch Umwandlung in eine Zeichenkette. In der Regel gibt es dafür zwei Möglichkeiten unter Angabe der Genauigkeit:
MsgBox Round(0.1 + 0.2, 15) = Format("{:.15f}", 0.3)
AutoHotkey wendet die gleichen Regeln für die Benennung verschiedener Dinge an, inklusive Variablen, Funktionen, Fenstergruppen, Klassen, Eigenschaften und Methoden. Die Regeln sind wie folgt.
Groß- und Kleinschreibung: Für ASCII-Zeichen nicht relevant. Zum Beispiel ist AktuellesDatum dasselbe wie aktuellesdatum. ASCII-fremde Großbuchstaben wie "Ä" sind jedoch nicht identisch mit ihren Kleinbuchstaben, unabhängig von den aktuellen Sprach- und Regionseinstellungen des Benutzers. Das hilft dem Skript, sich über mehrere Sprach- und Regionseinstellungen hinweg konsistent zu verhalten.
Maximale Länge: 253 Zeichen.
Erlaubte Zeichen: Buchstaben, Ziffern, Unterstrich und ASCII-fremde Zeichen; allerdings können nur Eigenschaftsnamen mit einer Ziffer beginnen.
Reservierte Wörter: as, and, contains, false, in, is, IsSet, not, or, super, true, unset. Diese Wörter sind für zukünftige oder andere spezifische Zwecke reserviert.
Deklarationsschlüsselwörter und Namen von Kontrollanweisungen sind ebenfalls reserviert, hauptsächlich für die Erkennung von Fehlern. Dazu gehören: Break, Case, Catch, Continue, Else, Finally, For, Global, Goto, If, Local, Loop, Return, Static, Switch, Throw, Try, Until, While
Namen von Eigenschaften, Methoden und Fenstergruppen können reservierte Wörter sein.
Skripte interagieren nur indirekt mit einem Objekt, via Referenz zum Objekt. Beim Erstellen eines Objekts wird es an einem Ort erstellt, den Sie nicht kontrollieren können, und Ihnen eine Referenz übergeben. Wenn Sie diese Referenz an eine Funktion übergeben oder in eine Variable oder in einem anderen Objekt speichern, wird eine neue Referenz zum selben Objekt erstellt.
Wenn z.B. meinObj eine Referenz zu einem Objekt enthält, erstellt deinObj := meinObj eine neue Referenz zum gleichen Objekt. Eine Änderung wie meinObj.ans := 42 würde sich sowohl in meinObj.ans als auch in deinObj.ans widerspiegeln, da beide auf dasselbe Objekt verweisen. meinObj := Object() wirkt sich jedoch nur auf die meinObj-Variable aus, nicht auf die deinObj-Variable, die immer noch auf das ursprüngliche Objekt verweist.
Um eine Referenz freizugeben, verwenden Sie einfach eine Zuweisung und ersetzen Sie sie mit einem anderen Wert. Ein Objekt wird erst gelöscht, wenn alle Referenzen freigegeben sind, d.h. es ist weder möglich noch sollte versucht werden, ein Objekt explizit zu löschen. (Sie können jedoch die Eigenschaften, den Inhalt oder die zugehörigen Ressourcen eines Objekts löschen, z.B. die Elemente eines Arrays, das Fenster eines Gui-Objekts, die Menüpunkte eines Menu-Objekts usw.)
Ref1 := Object() ; Ein Objekt erstellen und die erste Referenz speichern Ref2 := Ref1 ; Eine neue Referenz zum selben Objekt erstellen Ref1 := "" ; Die erste Referenz freigeben Ref2 := "" ; Die zweite Referenz freigeben; Objekt wird gelöscht
Sollten Sie das nicht verstehen, versuchen Sie, sich ein Objekt als Mietwohnung vorzustellen. Wenn Sie eine Wohnung mieten, erhalten Sie einen Schlüssel, mit dem sie die Wohnung betreten können. Sie können weitere Schlüssel erhalten und damit die Wohnung betreten, aber wenn Sie die Wohnung nicht mehr benötigen, müssen Sie alle Schlüssel an den Vermieter zurückgeben. In der Regel wird eine Wohnung nicht gelöscht, aber vielleicht muss der Vermieter jemanden beauftragen, den Müll, den Sie hinterlassen haben, zu entfernen; ähnlich dem Fall, dass die hinterlegten Werte in einem Objekt freigegeben werden, wenn das Objekt gelöscht wird.