 |
AutoHotkey Community
Wir helfen uns gegenseitig aus der Patsche
|
| Vorheriges Thema anzeigen :: Nächstes Thema anzeigen |
| Autor |
Nachricht |
denick
Anmeldedatum: 15.09.2006
Beiträge: 1073
Wohnort: Berlin
|
 Verfasst am: Sa Sep 29, 2007 1:01 pm Titel: Die Sendung mit der Maus - Anfängertutorials |
 |
|
Moin,
ich mache mir immer wieder mal so meine Gedanken, wie man einem Einsteiger mit wenig Programmiererfahrung und nicht allzu guten Englischkenntnissen den Zugang zu AHK vereinfachen kann.
Weil ich schon mal etwas zum Thema "Ausdrücke" eingestellt habe, habe ich versucht, das nach bestem Wissen und Gewissen zu überarbeiten. Und weil ich die Zweiteilung von Forum und Wiki persönlich nicht mag, dachte ich mir, man könnte doch mal im Smalltalk einen Thread für Anfängertutorials aufmachen.
Der Titel "Die Sendung mit der Maus" soll dabei weder abschrecken noch beleidigen, er soll nur verdeutlichen, dass es hier vordringlich um Anfängerunterstützung geht.
Genug geredet! Es folgt ein erster Beitrag. Wenn sich Andere beteiliegen wollen, sind sie herzlichst eingeladen.
Expressions und Depressions
Computer und Zahlen - Die binäre Welt der Nullen und Einsen von DerRaphael
_________________
Hilfe zur Hilfe
(de)nick
Zuletzt bearbeitet von denick am So Jun 01, 2008 11:52 am, insgesamt 2-mal bearbeitet |
|
| Nach oben |
|
 |
denick
Anmeldedatum: 15.09.2006
Beiträge: 1073
Wohnort: Berlin
|
| Verfasst am: Sa Sep 29, 2007 1:02 pm Titel: Expressions und Depressions |
|
|
Willkommen, liebe Anfänger,
heute lernen wir den Unterschied zwischen depressions und expressions und ihre Bedeutung für die Skriptsprache AutoHotkey (AHK).
Depressions heißen in Deutschland Depressionen. Die kennt wohl jeder, der sich als Neuling mühsam in AHK eingearbeitet hat, nach einigem Rumprobieren, Lesen und aufmerksamen Studium der Beispiele endlich begriffen hat, was es mit den Prozentzeichen und den Variablen auf sich hat (%Variable%), und dann bei seinem ersten wichtigen Skript feststellen muss, dass das meistens prima funktioniert, leider aber manchmal nicht. Es kommt keine Fehlermeldung, das Ergebnis ist aber falsch. Es folgen Zweifel -> Verzweiflung -> Depression!!!
Expressions heißen im Gegensatz dazu nicht "Expressionen", sondern man hat sich auf das schöne deutsche Wort Ausdrücke verständigt. Was will uns dieses Wort nun sagen? Ich würde es mal so ausdrücken:
| Zitat: | | Ein Ausdruck enthält Wertangaben (Operanden: Variablen, Zahlen, Texte), Verarbeitungsanweisungen (Operatoren: s.u.) und ggf. Struktursymbole (Klammern) und weitere Ausdrücke, die zusammen durch ihre Reihenfolge und Rangfolge (Priorität) beschreiben, wie die Werte verarbeitet werden sollen. |
Was hat das nun mit AHK zu tun?
Ganz einfach, es macht AHK richtig schön kompliziert!
Als AHK entstanden ist, muss die Sprache sehr übersichtlich gewesen sein. Für die Zuweisung von Werten an Variablen gab es genau eine Möglichkeit, nämlich die Anweisung Var = Wert. Dabei wird alles rechts vom Gleichheitszeichen als Text behandelt. Nur, wenn etwas in %-Zeichen eingeschlossen ist (%Text%), wird das als Variablenname genommen und der Inhalt der zugehörigen Variablen wird anstelle des Namens und der umgebenden Prozentzeichen eingefügt. Für Berechnungen musste man Anweisungen wie EnvAdd, EnvSub, ..., Transform benutzen. Diese Art der Zuweisung wird heute klassisch oder traditionell (engl.: traditional) genannt.
Im Vergleich mit anderen Sprachen war das mit der Zeit recht unbequem, deshalb wurden irgendwann die Expressions (Ausdrücke) eingeführt. Die erste Anweisung dürfte Var := Ausdruck gewesen sein. Rechts von := steht steht dabei kein Wert, der bis auf die Variablenreferenzen (%%) unverändert in die Zielvariable übernommen wird, sondern ein Ausdruck (s.o.).
Nun gibt es auch in der Welt Programmiersprachen die berühmt berüchtigte "Abwärtskompatibilität". Damit soll erreicht werden, dass nach Einführung von neuen Möglichkeiten in neuen Versionen auch die in älteren Versionen geschriebenen Programme möglichts unverändert ablauffähig bleiben. AHK ist ein Musterbeispiel der Abwärtskompatibilität. Es wird sogar versucht, Skripte, die in der Vorgängersprache AutoIt2 geschrieben wurden, weitmöglichst zu unterstützen. Als Konsequenz daraus wurde die klassische Zuweisung nicht durch Ausdrücke abgelöst. Beide leben mehr oder weniger friedlich mit- und nebeneinander. So hat man in AHK oft mehrere Möglichkeiten, ein und dasselbe Ergebnis zu erhalten. Man muss nur daran denken, dass eine identische Schreibweise bei der klassischen Zuweisung und in Ausdrücken zu völlig unterschiedlichen Ergebnissen oder Fehlern führen kann. Betrachten wir deshalb einmal die
Unterschiede zwischen klassischer Zuweisung und Ausdrücken
Prozentzeichen (%)
Klassische Zuweisung
Die klassische Zuweisung Var = Text ist leicht erklärt. Links vom Gleichheitszeichen steht immer ein Variablenname, rechts davon eine Zeichenfolge (Text). Der Text wird mit nur einer Ausnahme unverändert in die Variable übernommen, die Ausnahme sind in %-Zeichen eingeschlossene Zeichen (%Text%), die immer als Variablennamen gedeutet werden und dazu führen, dass der angegebene Variablenname einschließlich der %-Zeichen durch den Inhalt der Variablen ersetzt wird. Soll der Text selbst %-Zeichen enthalten, müssen die mit dem Escapezeichen ´ markiert werden, sonst erhält man bei der Ausführung ein nicht gewolltes Ergebnis oder Fehlermeldungen. Hier kommt die von Vielen, aber längst nicht von Allen als positiv eingeschätzte Eigenschaft von AHK ins Spiel, dass Variablen nicht ausdrücklich deklariert werden müssen, sondern bei ihrer ersten Verwendung automatisch leer angelegt werden.
Schreibt man unabsichtlich ein einzelnes %-Zeichen in den Text, erhält man die Fehlermeldung: Dieser Parameter enthält einen Variablennamen, dem das abschließende %-Zeichen fehlt. Schreibt man aber zwei hinein, ist das Ergebnis abhängig vom Text zwischen ihnen. Wenn der Text ausschließlich Zeichen enthält, die für Variablennamen zulässig sind, wird flugs eine solche Variable leer angelegt und diese leere Zeichenfolge anstelle des vermeintlichen Variablennamens einschließlich der %-Zeichen eingefügt. Enthält der Text aber unzulässige Zeichen, ergibt das eine Fehlermeldung: Der folgende Variablenname enthält ein ungültiges Zeichen.
| Code: | Var = Inhalt
Prozent = `%
MsgBox, Die Var Var hat den Inhalt %Var% ; ist schon richtig
MsgBox, Die Var Var hat den Inhalt %Var2% ; Var2 gibt's nicht
MsgBox, Die Var Prozent hat den Inhalt %Prozent% ; ist auch richtig
; Wenn man eine der MsgBox-Zeilen aktiviert, gibt es Fehler
; MsgBox, Die Var Prozent hat den Inhalt % ; und Tschüss
; MsgBox, Die Var Prozent hat den Inhalt % Prozent% ; und Tschüss |
Ausdruck
In Ausdrücken werden Variablennamen ohne die Kennzeichnung mit %-Zeichen erkannt, weil Texte zur Unterscheidung hier in Anführungszeichen (") eingeschlossen werden müssen. Alles, was nicht in Anführungszeichen steht, ist entweder ein Variablenname, eine Zahl, ein Operator oder ein Struktursymbol (s.u.). Man sollte also meinen, dass es zum Thema %-Zeichen hier nichts zu sagen gibt. Aber AHK wäre nicht AHK, wenn es nicht doch so und auch anders wäre.
In %-Zeichen eingeschlossene Zeichen, die nicht in einem von Anführungszeichen eingeschlossenen Text enthalten sind, werden auch innerhalb von Ausdrücken als Variablenname gewertet, nur mit einer etwas anderen Konsequenz. Hier wird der Inhalt der Variablen nicht als Text, sondern als Variablenname oder Teil eines Variablennamens betrachtet und auf den Inhalt der so bezeichneten Variablen zugegriffen. Die Hauptanwendung dafür ist der Zugriff auf die "unechten" AHK-"Arrays". Deren Namen werden üblicherweise aus einem gemeinsamen Stammnamen und einer angehängten fortaufenden Nummer gebildet. Für die sequentielle Abarbeitung solcher Variablen verwendet man dann eine Schleife wie: | Code: | ; Anzahl der Farben
Farben := 3
Farbe1 := "Rot"
Farbe2 := "Blau"
Farbe3 := "Grün"
; Wiederhole die Schleife für die Anzahl der Farben
Loop, %Farben%
{
; Die interne Schleifenvariable A_Index enthält den Durchlaufzähler
; A_Index kann deshalb hier nacheinander die Werte 1, 2 und 3 annehmen
; Die Angabe Farbe%A_Index% wird entsprechend zu den Variablennamen
; Farbe1, Farbe2 und Farbe3 aufgelöst
Farbe := Farbe%A_Index%
MsgBox, Farbe %A_Index% ist %Farbe%
} |
Würde man hier den Ausdruck Farbe := Farbe%A_Index% durch die klassische Zuweisung Farbe = Farbe%A_Index% ersetzen, würden der Variablen Farbe in der Schleife nicht die Werte Rot, Blau und Grün sondern Farbe1, Farbe2 und Farbe3 zugewiesen.
Anführungszeichen (")
Klassische Zuweisung
Bei der klassischen Zuweisung ist das Anführungszeichen ein normales Textzeichen. Die Anweisung schreibt deshalb die komplette Zeichenfolge "Text" einschließlich der Anführungszeichen in die Variable Var.
Ausdruck
In Ausdrücken muss reiner Text, der ohne weitere Prüfung zugewiesen werden soll, in Anführungszeichen (") eingeschlossen werden. AHK versucht dann nicht, Variablennamen oder Zahlen darin zu finden, und übernimmt den kompletten Text innerhalb der Anführungszeichen (also ohne die Anführungszeichen) in die Verarbeitung. Wenn ein Text Anführungszeichen enthalten soll, müssen diese doppelt eingegeben werden. Folgende Anweisungen sind deshalb ergebnisgleich: | Code: | ; Klassisch
Var = Er sagte: "Hallo!"
; Ausdruck
Var := "Er sagte: ""Hallo!""" ; man beachte die drei abschließenden Anführungszeichen |
Operatoren (+, -, *, /, etc.)
Klassische Zuweisung
Bei der klassischen Zuweisung sind auch die Operatoren normale Textzeichen. Der Versuch, in einer klassischen Zuweisung zu rechnen, scheitert deshalb kläglich. Die Anweisungen | Code: | Var = 10
Var = %Var% + 1
Var = Var + 1
|
sorgen dafür, dass der Variablen Var nacheinander die Zeichenfolgen 10, 10 + 1 und Var + 1 zugewiesen werden. Für Berechnungen gibt es spezielle Anweisungen wie EnvAdd, EnvDiv, EnvMult, EnvSub und Transform. Beipiele: | Code: | Var = 12
MsgBox, %Var%
; Var = Var + 6
EnvAdd, Var, 6
MsgBox, %Var%
; Var = Var * 2
EnvMult, Var, 2
MsgBox, %Var%
; Var = Quadratwurzel(Var)
Transform, Var, Sqrt, %Var%
MsgBox, %Var% |
Ausdruck
In Ausdrücken bestimmen die Operatoren, wie die Werte verarbeitet werden sollen. Sind sind in der AutoHotkey Hilfe im Abschnitt Variables and Expressions (Variablen und Ausdrücke) beschrieben. Jedem Operator ist eine Priorität zugeordnet. Operatoren höherer Priorität werden vor Operatoren niedrigerer Priorität ausgeführt, innerhalb einer Prioritätsstufe erfolgt die Abarbeitung normalerweise von links nach rechts, Abweichungen sind ausdrücklich beschrieben. (Aus der Schule kennt man vielleicht noch die Regel: Punktrechnung geht vor Strichrechnung!) Die Reihenfolge der Abarbeitung kann aber durch Struktursymbole (Klammern, s.u.) verändert werden.
Für viele Zuweisungen mit dem Zuweisungsoperator := gibt es eine abkürzende Schreibweise / Kurzform, wenn die Variable, die das Ergebnis aufnehmen soll, und die Variable, die den Ausgangswert der Berechnung enthält, identisch sind und dieser Variablenname direkt auf den Zuweisungsoperator folgt. Der erste Operator wird dann anstelle des Doppelpunkts (:) in den Zuweisungsoperator übernommen. So sind z.B. die folgenden Anweisungen ergebnisgleich: | Code: | Var := Var + 1
Var += 1 |
Seit AHK 1.0.46 haben alle Operatoren mit Ausnahme von ++ und -- die Eigenschaft, die aktuelle Zeile mit der voranstehenden zu verbinden wenn sie als erstes Zeichen gefolgt von einem Leerzeichen am Anfang einer Zeile stehen.
AHK-typisch hat der Verbindungsoperator Punkt (.) eine weitere "spezielle" Eigenschaft: Innerhalb einer Zeile wird er nicht benötigt! Die folgenden Anweisungen sind deshalb ergebnisgleich: | Code: | Var := "Finde ich " . "nicht " . "gut!"
Var := "Finde ich " "nicht " "gut!"
|
Ein einfaches Leerzeichen tut es auch. Das kann man gut finden, muss man aber nicht.
Struktursymbole (Klammern)
Klassische Zuweisung
Wie die anderen o.a. Zeichen haben auch Klammern für die klassische Zuweisung keine Bedeutung. Sie werden als normale Textzeichen behandelt.
Ausdruck
In Ausdrücken kann man mit Klammern die Reihenfolge der Abarbeitung beeinflussen. In Klammern zusammengefasste Teilausdrücke werden immer zuerst ausgewertet. Erst dann wird der resultierende Ausdruck nach Priorität der Operatoren abgearbeitet. Wenn geklammerte Teilausdrücke weitere geklammerte Teilausdrücke enthalten, erfolgt die Auswertung von Innen nach Außen. Die folgenden Anweisungen sind deshalb einmal nicht ergebnisgleich: | Code: | Var := 5 + 5 * 3
MsgBox, %Var%
Var := (5 + 5) * 3
MsgBox, %Var% |
Außerhalb von Zuweisungen werden die Klammern oft benötigt, um einen Ausdruck als Ausdruck zu kennzeichnen. Im folgenden Beispiel liefert die If-Anweisung mit und ohne Klammern unterschiedliche Ergebnisse: | Code: | Var := "Text"
Text := "KeinText"
If Var = Text ; Vergleich der Variablen Var mit dem Text Text
{
MsgBox, O.K.
}
Else
{
MsgBox, Falsch
}
If (Var = Text) ; Vergleich der Variablen Var mit der Variablen Text
{
MsgBox, O.K.
}
Else
{
MsgBox, Falsch
} |
Ausdrücke außerhalb von Zuweisungen
Auch außerhalb von reinen Zuweisungen wird die Möglichkeit, Ausdrücke zu verwenden, ständig erweitert. In der Hilfe finden sich viele Stellen mit der Angabe "This (parameter) can (may) be an expression (Dies (Dieser Parameter) darf ein Ausdruck sein)". Wofür braucht man das aber?
Vergleiche (If)
Das Musterbeispiel für die Verwendung von Ausdrücken ist die If-Anweisung. Abhängig von bestimmten Bedingungen sollen hier weitere Anweisungen ausgeführt werden, oder eben auch nicht. Das "klassische" AHK kennt dafür viele Anweisungen, die alle mit If beginnen, z.B. IfEqual, IfGreaterOrEqual, IfInString, IfWinActive, etc. Außerdem können auch mit dem klassischen If Vergleichsoperatoren wie ">, <, <>, =, >=, <=, !=" verwendet werden. Das ist an sich nicht schlecht, hat aber zur Folge, dass sich Fehler wegen der Unterschiede zwischen klassischer Schreibweise und Ausdrücken einschleichen können:
| Code: | #NoEnv
A = A
B := "A"
If A != B
MsgBox, A ungleich B
Else
MsgBox, A gleich B
If (A != B) {
MsgBox, A ungleich B
} Else {
MsgBox, A gleich B
}
If A != %B%
MsgBox, A ungleich B
Else
MsgBox, A gleich B
; und hier noch die absolute Hammeranweisung:
If (A != %B%)
MsgBox, A ungleich B
Else
MsgBox, A gleich B
ExitApp |
Im letzten Ausdruck wird durch die Angabe %B% der Inhalt der Variablen B als Variablenname verwendet. Der Ausdruck ist damit gleichbedeutend mit (A != A).
Die meisten klassischen Anweisungen können nur eine Bedingung prüfen. Was passiert aber, wenn die Ausführung eines Anweisungsblocks von mehreren Bedingungen abhängig sein soll? Man braucht in jedem Fall mehrere If-Anweisungen.
Für die Bedingung Var1 > Var2 und Differenz von Var1 und Var2 < 3 lässt sich das "klassisch" durch "Schachtelung" (aneinandergehängte eingerückte Abfragen) noch relativ gut lösen: | Code: | Var1 = 11
Var2 = 10
If Var1 > %Var2%
{
; Hilfsvariable VarX wird benötigt
VarX = %Var1%
; hier steht fest, dass Var1 > Var2 ist
EnvSub, VarX, %Var2%
If VarX < 3
{
Var1 = 0
Var2 = 0
MsgBox, Bedingung erfüllt!
}
} |
Man kann bei diesem einfachen Beispiel vielleich noch darüber streiten, aber ich finde die Lösung unter Verwendung eines Ausdrucks wesentlich übersichtlicher und eleganter: | Code: | Var1 := 11
Var2 := 10
If (Var1 > Var2 And (Var1 - Var2) < 3)
{
Var1 := 0
Var2 := 0
MsgBox, Bedingung erfüllt!
}
|
Die innerern Klammern (Var1 - Var2) müssen hier nicht sein, sie sorgen aber für bessere Lesbarkeit. Eine Hilfsvariable wird nicht benötigt.
Noch etwas komplizierter gestaltet sich das in der "klassischen" Form für die Bedingung Var1 > Var2 oder Differenz von Var1 und Var2 < 3. Hier kommt man mit der "Schachtelung" allein nicht weiter, weil die Bedingungen nicht voneinander abhängig sind. Man braucht in jedem Fall einen Else-Zweig und die Wiederholung der auszuführenden Anweisungsfolge, die Auslagerung in eine Subroutine oder Funktion oder das nicht mehr zeitgemäße Hüpfen mit Goto. Das macht das Skript nicht unbedingt lesbarer und übersichtlicher: | Code: | ; Wiederholung der Anweisungen
Var1 = 11
Var2 = 10
If Var1 > %Var2%
{
Var1 = 0
Var2 = 0
MsgBox, Bedingung erfüllt!
}
Else
{
VarX = %Var1%
EnvSub, VarX, %Var2%
; Absoluter Wert der Differenz
Transform, VarX, Abs, %VarX%
If VarX < 3
{
Var1 = 0
Var2 = 0
MsgBox, Bedingung erfüllt!
}
}
|
Die Übersichtlichkeit von Ausdrücken kommt hier noch mehr zur Geltung, denn im Vergleich mit dem Beispiel der und-Bedingung sind hier nur minimale Änderungen erforderlich: | Code: | Var1 := 11
Var2 := 10
If (Var1 > Var2 Or Abs(Var1 - Var2) < 3)
{
Var1 := 0
Var2 := 0
MsgBox, Bedingung erfüllt!
}
|
Hier taucht erstmalig eine Funktion auf: ABS(). Funktionen sind in AHK immer Ausdrücke. Jeder, der schon einmal eine Funktion benutzt hat, hat damit auch einen Ausdruck verwendet. Den Funktionen ist unten ein eigener Abschnitt gewidmet.
Anweisungsparameter und "erzwungene Ausdrücke"
Die "klassischen" AHK-Anweisungsparameter sind relativ "statisch", d.h. sie repräsentieren zum Zeitpunkt der Ausführung einen feststehenden Wert, der in den meisten Fällen nur über Variablen verändert werden kann, denen vorher ein entsprechender Wert zugewiesen wurde. Soll ein Wert verwendet werden, der sich aus einer Variablen errechnet, ohne dass der Inhalt der Variablen verändert wird, muss dafür eine Hilfsvariable herhalten. Die Eingabe einer Zahl und die Ausgabe des zugehörigen Quadratwertes würde "klassisch" so aussehen: | Code: | InputBox, Var , Quadrat,
(Ltrim
Bitte eine Zahl eingeben.
Sie erhalten dann ihren Quadratwert!
)
Quadrat = %Var%
EnvMult, Quadrat, %Quadrat%
MsgBox, Das Quadrat von %Var% ist %Quadrat% |
Die Lösung als Ausdruck kann auf die Hilfsvariable verzichten, weil die Berechnung innerhalb des Anweisungsparameters selbst ausgeführt wird: | Code: | InputBox, Var , Quadrat,
(Ltrim
Bitte eine Zahl eingeben.
Sie erhalten dann ihren Quadratwert!
)
MsgBox, % "Das Quadrat von " . Var . " ist " . (Var * Var) |
In diesem Beispiel wird durch das einzeln stehende führende %-Zeichen "ein Ausdruck erzwungen". Überall da, wo nicht automatisch klar ist, ob hier ein Wert oder ein Ausdruck steht, teilt das einleitende einzelne %-Zeichen AHK mit, dass es sich um einen Ausdruck handelt. Das sollte laut Hilfe für alle Parameter mit Ausnahme von Input- oder Outputvariablen gelten. Wenn ein Parameter sowieso ein Ausdruck sein kann, sollte das in diesem Fall eigentlich unnötige einleitende %-Zeichen ignoriert werden. So steht es jedenfalls in der Beschreibung zu den Funktionen.
Wie immer in Ausdrücken, ist auch und gerade bei erzwungenen Ausdrücken eine sorgfältige Unterscheidung zwischen Parametertext und Variablen erforderlich. Wenn die Textteile nicht in Anführungszeichen eingeschlossen werden, werden auch sie als Variablennamen interpretiert und liefern ein nicht gewolltes Ergebnis, wenn eine solche Variable tatsächlich existiert, kein Ergebnis, wenn keine solche Variable existiert, oder einen Fehler, wenn der Text zeichen enthält, die für Variablennamen nicht zulässig sind. Zusammen mit der Tatsache, dass der Verbindungsoperator Punkt (.) weggelassen und durch ein einfaches Leerzeichen ersetzt werden darf, ergeben sich dann interessante Fehlermöglichkeiten. | Code: | #NoEnv
Gui, Show, w400 h400, Test
Gui, +LastFound
ID := WinExist()
; "klassisch" und richtig
WinGetPos, X1, Y1, W1, H1, ahk_id %ID%
MsgBox, X = %X1%, Y = %Y1%, W = %W1% H = %H1%
; "erzwungener Ausdruck" und richtig
WinGetPos, X2, Y2, W2, H2, % "ahk_id " ID
MsgBox, % "X = " X2 ", Y = " Y2 ", W = " W2 ", H = " H2
; "erzwungener Ausdruck" und falsch
WinGetPos, X3, Y3, W3, H3, % ahk_id ID
MsgBox, % "X = " X3 ", Y = " Y3 ", W = " W3 ", H = " H3
ExitApp |
Im letzten WinGetPos wird ahk_id wegen der fehlenden Anführungszeichen als Variablenname interpretiert. Weil es diese Variable nicht gibt, lierfert sie eine leere Zeichenfolge. Diese wird anschließend mit dem Inhalt der Variablen ID verbunden und, wiel AHK den Text ahk_id nicht finden konnte, als Text im Fenstertitel gesucht, allerdings hier mit Null Erfolg. Würde allerdings der Zeichenfolge der ID zufällig in einem Fenstertitel gefunden, könnte das Ergebnis dem Programmierer einiges Kopfzerbrechen bereiten.
Funktionen
Funktionen sind in AHK per Definition immer Ausdrücke. Das gilt sowohl für die Übergabeparameter als auch für den Rückgabewert. Das bedeutet, dass Texte immer in Anführungszeichen eingeschlossen werden müssen, Zahlen nie und Variablennamen in der Regel ohne %-Zeichen (Regelmäßige Ausnahme: AHK-"Arrayvariablen" wie MeinArray%Index%). Wenn die Funktion per Return einen Rückgabewert liefert, muss dafür immer die Schreibweise von Ausdrücken verwendet werden. Für die Zuweisung eines Rückgabewerts an eine Variable muss immer der Zuweisungsoperator := verwendet werden.
Der "ternäre" (dreifache) Operator ( wenn ? dann : sonst)
Der "ternäre" Operator ist eine relativ neue Erungenschaft für AHK. Er ermöglicht es, auf beide möglichen Ergebnisse einer Vergleichsbedingung (wahr oder falsch) in einer Anweisung zu reagieren und ersetzt damit die typische "If -> wahr Else -> falsch " Kette. Das o.a. unter Struktursymbole angeführte Beispiel lässt sich durch Kombination von "ternärem" Operator und "erzwungenem Ausdruck" dann so schreiben: | Code: | #NoEnv
Var := "Text"
Text := "KeinText"
; If (Var = Text) { ; Vergleich der Variablen Var mit der Variablen Text
; MsgBox, O.K.
; } Else {
; MsgBox, Falsch
; }
MsgBox, % (Var = Text) ? "O.K" : "Falsch"
ExitApp |
In diesem Beispiel wird als Ergebnis des Vergleichs die zugehörige Meldung nur ausgegeben. Wenn man später noch wissen muss, welches Ergebnis der Vergleich gebracht hat, kann es zusätzlich in einer Variablen abgelegt werden: | Code: | #NoEnv
Var := "Text"
Text := "KeinText"
Msg := ""
MsgBox, % Msg := (Var = Text) ? "O.K" : "Falsch"
If (Msg = "Falsch") {
MsgBox, % "Tut mir leid, das war wohl nichts!"
}
ExitApp |
Beispiel
Als Beispiel für die Unterschiede zwischen der "klassischen" und der Schreibweise von Ausdrücken soll das kleine Programm Zahlenraten dienen. Die Gui enthält zwei Felder mit berechneten Positionen. Die "klassische" Version muss auf die Verwendung von Funktionen verzichten.
Klassische Version
| Code: | #NoEnv
#NoTrayIcon
; klassische Version
Min = 1
Max = 10
MaxVersuche = 3
Geraten = 0
Treffer = 0
Niedrig = Zu niedrig!
Hoch = Zu hoch!
Getroffen = Glückwunsch!`nTreffer!
Versuche = 1
; ------------------------------------------------------------------------------
Gui, +AlwaysOnTop
Gui, Font, s10, Verdana
Gui, Margin, 20, 20
Gui, Add, Text, vText1,
(Ltrim
Bitte eine Zahl zwischen %Min% und %Max% eingeben.
Du hast %MaxVersuche% Versuche, die richtige zu treffen.
)
GuiControlGet, Text1, Pos
Gui, Add, Text, xm y+0 wp Center vTextVersuche
X = %Text1X% ; Text1X wird noch benötigt
W = %Text1W% ; Text1W wird noch benötigt
EnvDiv, W, 2 ; W /= 2
EnvAdd, X, W ; X += %W%
EnvSub, X, 25 ; X -= 25
Gui, Add, Edit, x%X% w50 Limit2 Number vZahl
Gui, Add, Button, xm w80 Default gBTOK, OK
; Text1X wird nicht mehr benötigt
EnvAdd, Text1X, Text1W ; Text1X += %Text1W%
EnvSub, Text1X, 80 ; Text1X -= 80
Gui, Add, Button, x%Text1X% yp wp hp gBTCancel, Abbrechen
GoSub, NeuesSpiel
Gui, Show, , Zahlenraten
Return
; ------------------------------------------------------------------------------
GuiClose:
GuiEscape:
Gui, Destroy
ExitApp
; ------------------------------------------------------------------------------
BTOK:
Gui, +OwnDialogs
Gui, Submit, NoHide
If Zahl > %Var%
Msg = %Hoch%
Else If Zahl < %Var%
Msg = %Niedrig%
Else
Msg = %Getroffen%
MsgBox, 4096, Zahlenraten, %Msg%
If Msg = %Getroffen%
{
EnvAdd, Treffer, 1 ; Treffer++
MsgBox, 4100, Zahlenraten
, Das war Dein %Treffer%. Treffer!`nWillst Du Weiterspielen?
IfMsgBox, Yes
{
Gosub, NeuesSpiel
Return
}
Else
GoSub, GuiClose
}
EnvAdd, Versuche, 1 ; Versuche++
If Versuche > %MaxVersuche%
{
MsgBox, 4100, Zahlenraten
, Das war mal nichts!`nWillst Du Weiterspielen?
IfMsgBox, Yes
{
GoSub, NeuesSpiel
Return
}
Else
Gosub, GuiClose
}
GuiControl, ,TextVersuche, Das ist Dein %Versuche%. Versuch
GuiControl, , Zahl
GuiControl, Focus, Zahl
Return
; ------------------------------------------------------------------------------
BTCancel:
Gui, +OwnDialogs
MsgBox, 4100, Zahlenraten
, Das war mal nichts!`nWillst Du Weiterspielen?
IfMsgBox, Yes
{
GoSub, NeuesSpiel
Return
}
Else
Gosub, GuiClose
Return
; ------------------------------------------------------------------------------
NeuesSpiel:
Random, Var, %Min%, %Max%
Versuche = 1
GuiControl, ,TextVersuche, Das ist Dein %Versuche%. Versuch
GuiControl, ,Zahl
GuiControl, Focus, Zahl
Return
|
Ausdruck
| Code: | #NoEnv
#NoTrayIcon
; Ausdrücke, wo immer es geht
Min := 1
Max := 10
MaxVersuche := 3
Geraten := False
Treffer := 0
Niedrig := "Zu niedrig!"
Hoch := "Zu hoch!"
Getroffen := "Glückwunsch!`nTreffer!"
Versuche := 1
; ------------------------------------------------------------------------------
Gui, +AlwaysOnTop
Gui, Font, s10, Verdana
Gui, Margin, 20, 20
Gui, Add, Text, vText1, % ""
. "Bitte eine Zahl zwischen " . Min . " und " . Max . " eingeben.`n"
. "Du hast " . MaxVersuche . " Versuche, die richtige zu treffen."
GuiControlGet, Text1, Pos
Gui, Add, Text, xm y+0 wp Center vTextVersuche
Gui, Add, Edit, % "x" . (Text1X + (Text1W // 2) - 25)
. " w50 Limit2 Number vZahl"
Gui, Add, Button, xm w80 h20 Default gBTOK, OK
Gui, Add, Button, % "x" . (Text1X + Text1W - 80)
. " yp wp hp gBTCancel" , Abbrechen
GoSub, NeuesSpiel
Gui, Show, , Zahlenraten
Return
; ------------------------------------------------------------------------------
GuiClose:
GuiEscape:
Gui, Destroy
ExitApp
; ------------------------------------------------------------------------------
BTOK:
Gui, +OwnDialogs
Gui, Submit, NoHide
MsgBox, 4096, Zahlenraten
, % (Msg := (Zahl > Var) ? Hoch : (Zahl < Var ? Niedrig : Getroffen))
If (Msg = Getroffen) {
Treffer++
If Weiter("Das war Dein " . Treffer . ". Treffer!") {
Gosub, NeuesSpiel
Return
} Else {
GoSub, GuiClose
}
}
Versuche++
If (Versuche > MaxVersuche) {
If Weiter("Das war mal nichts!") {
GoSub, NeuesSpiel
Return
} Else {
Gosub, GuiClose
}
}
GuiControl, ,TextVersuche, % "Das ist Dein " . Versuche . ". Versuch"
GuiControl, , Zahl
GuiControl, Focus, Zahl
Return
; ------------------------------------------------------------------------------
BTCancel:
Gui, +OwnDialogs
If Weiter("Das war mal nichts!") {
GoSub, NeuesSpiel
Return
} Else {
Gosub, GuiClose
}
Return
; ------------------------------------------------------------------------------
NeuesSpiel:
Random, Var, % Min, % Max
Versuche := 1
GuiControl, ,TextVersuche, % "Das ist Dein " . Versuche . ". Versuch"
GuiControl, ,Zahl
GuiControl, Focus, Zahl
Return
; ------------------------------------------------------------------------------
Weiter(Text)
{
MsgBox, 4100, Zahlenraten, % Text . "`nWillst Du Weiterspielen?"
IfMsgBox, No
{
Return False
}
Return True
}
|
_________________
Hilfe zur Hilfe
(de)nick
Zuletzt bearbeitet von denick am Sa Sep 29, 2007 11:26 pm, insgesamt 3-mal bearbeitet |
|
| Nach oben |
|
|
IsNull
Anmeldedatum: 20.12.2006
Beiträge: 914
Wohnort: CH
|
|
| Nach oben |
|
|
msgbox
Anmeldedatum: 05.05.2007
Beiträge: 727
Wohnort: C:\
|
| Verfasst am: Sa Sep 29, 2007 1:21 pm Titel: |
|
|
Wow! Ich bin begeistert von dir 
@Moderator: Kann es jemand als sticky machen ??!! 
_________________
msgbox, 1577008, Ich bin msgbox, Teste mich mal |
|
| Nach oben |
|
|
AGermanUser
Anmeldedatum: 25.10.2005
Beiträge: 167
|
| Verfasst am: Sa Sep 29, 2007 1:32 pm Titel: |
|
|
Fetzig.
Habe es gepinnt. Ich war so frei und habe aus ..tuts" die ...tutorials" gemacht. Ich hoffe das ist allen recht so.
@denick
Hast du schon Pläne für weitere Tutorials?
Chucky und ich hatten über etwas Ähnliches mal für das Wiki gesprochen. Zugunsten der CHM Übersetzung haben wir das Projekt aber seinerzeit eingefroren.
Wenn ich noch einen Vorschlag in die Runde werfen darf. Wäre es nicht besser, Diskussionen und Anmerkungen zu den Tutorials in einen weiteren Thread auszulagern, damit das Sticky überschaubar bleibt? Ist nur ein Vorschlag.
_________________
Gruß
AGermanUser a.k.a. AGU
Moderator |
|
| Nach oben |
|
|
BoBo¨
Gast
|
| Verfasst am: Sa Sep 29, 2007 2:03 pm Titel: |
|
|
1) Respekt. Ohne Einschränkung.
Anmerkung.
a) Ich würde Tutorials als einzeln (durchnummerierte?) Threads ausführen (falls du dies nicht sowieso beabsichtigst). Klar, ist Geschmacksache.
b) würde es Sinn machen den Thread zu sperren/locken? Oder beabsichtigst du einen anschließenden Dialog (incl. etwaigen Nonsensepostings) zuzulassen? |
|
| Nach oben |
|
|
BoBo¨
Gast
|
| Verfasst am: Sa Sep 29, 2007 2:41 pm Titel: |
|
|
2)
Das Layout des Tutorial gefällt mir. Evtl. kann die Community sich darauf einigen Dieses als (unverbindliche) Vorgabe zu übernehmen? |
|
| Nach oben |
|
|
msgbox
Anmeldedatum: 05.05.2007
Beiträge: 727
Wohnort: C:\
|
| Verfasst am: Sa Sep 29, 2007 2:42 pm Titel: |
|
|
| BoBo¨ hat Folgendes geschrieben: | | 1) Respekt. Ohne Einschränkung. |
Ich will immer zwei mal mehr wie du haben ^^
Vieeeelen dank!! Sehr toll von dir gemacht 
_________________
msgbox, 1577008, Ich bin msgbox, Teste mich mal |
|
| Nach oben |
|
|
swa
Anmeldedatum: 27.05.2007
Beiträge: 169
|
| Verfasst am: Sa Sep 29, 2007 5:51 pm Titel: |
|
|
wow danke !! klasse Maus sendung ! Ich sollte früher aufstehen um das zu sehn !!
wann wirds denn verfilmt ? |
|
| Nach oben |
|
|
msgbox
Anmeldedatum: 05.05.2007
Beiträge: 727
Wohnort: C:\
|
| Verfasst am: Sa Sep 29, 2007 6:56 pm Titel: |
|
|
| swa hat Folgendes geschrieben: | | verfilmt |
Nein... Wie wäre es wenn wir ein Buch schreiben? AutoHoktey hat keinerlei Bücher! Wir haben schon einen großen Teil vom Helpfile übersetzt, da können wir ja dies kopieren und das aufführliche Tutorial von denick hinzufügen.  Noch bisschen mehr dazu scheiben.. dann wird ein schönes buch
_________________
msgbox, 1577008, Ich bin msgbox, Teste mich mal |
|
| Nach oben |
|
|
BoBo¨
Gast
|
| Verfasst am: Sa Sep 29, 2007 7:59 pm Titel: |
|
|
| Zitat: | | (incl. etwaigen Nonsensepostings) |
BoBo - der es im Urin Habende.  |
|
| Nach oben |
|
|
denick
Anmeldedatum: 15.09.2006
Beiträge: 1073
Wohnort: Berlin
|
| Verfasst am: Sa Sep 29, 2007 10:37 pm Titel: |
|
|
Moin,
es freut mich wirklich, dass die Idee hier gut aufgenommen wird. Ich habe mich schon einige Zeit damit beschäftigt, wusste aber nicht, wie es hier ankommen würde.
| AGermanUser hat Folgendes geschrieben: | | Habe es gepinnt. Ich war so frei und habe aus ..tuts" die ...tutorials" gemacht. Ich hoffe das ist allen recht so. |
Ist mir sehr recht.
Zwei Sachen, die mir z.Zt. am Herzen liegen, wären z.B. "Funktionen" und "relative GUI-Positionierung" (ich mag dieses ; Generated using SmartGUI Creator 4.0 nicht wirklich).
| BoBo" hat Folgendes geschrieben: | | b) würde es Sinn machen den Thread zu sperren/locken? Oder beabsichtigst du einen anschließenden Dialog (incl. etwaigen Nonsensepostings) zuzulassen? |
Fragen müssen hier zulässig sein, denn nur durch Fragen kann man erkennen, ob dieser Thread die Zielgruppe "Anfänger" wirklich erreicht. Wenn man schon länger dabei ist, verliert man gewöhnlich das Gefühl dafür, welche Probleme ein Anfänger hat. Deshalb muss jede Frage erlaubt sein, auch wenn hier nicht jede Frage beantwortet werden kann.
Edit:
| BoBo¨ hat Folgendes geschrieben: | 2)
Das Layout des Tutorial gefällt mir. Evtl. kann die Community sich darauf einigen Dieses als (unverbindliche) Vorgabe zu übernehmen? |
BoBo", Dein Lob ist mir wirklich willkommen (weil ich dem Layout auch einige Gedanken gewidmet habe) , aber meiner Meinung nach sollten Andere, die hierzu etwas beitragen möchten, nicht auf ein bestimmtes (unverbindliches) Layout verpflichtet werden. Wenn's das "Tut"orial tut, ist das Layout doch nebensächlich.
_________________
Hilfe zur Hilfe
(de)nick |
|
| Nach oben |
|
|
Boskoop
Anmeldedatum: 18.12.2005
Beiträge: 60
|
| Verfasst am: Mi Okt 03, 2007 5:59 pm Titel: |
|
|
Das Tutorial gefällt mir auch sehr gut. Ich habe es auch gleich auf die Tutorial-Liste in der Wiki gesetzt.
Vielleicht sollte man eine ähnliche Linkseite auch als Sticky ins Forum setzen. Auf diese Weise ließen sich Tutorials, egal ob sie in der Wiki oder im Forum stehen, leichter finden.
Gruß
Boskoop |
|
| Nach oben |
|
|
halweg
Anmeldedatum: 05.01.2006
Beiträge: 782
Wohnort: Dresden
|
| Verfasst am: Mi Okt 03, 2007 6:36 pm Titel: |
|
|
| msgbox hat Folgendes geschrieben: | | swa hat Folgendes geschrieben: | | verfilmt |
Nein... Wie wäre es wenn wir ein Buch schreiben? AutoHoktey hat keinerlei Bücher! Wir haben schon einen großen Teil vom Helpfile übersetzt, da können wir ja dies kopieren und das aufführliche Tutorial von denick hinzufügen. Noch bisschen mehr dazu scheiben.. dann wird ein schönes buch |
Genau, ein Buch wäre toll. Da kann denick vielleicht sogar dann weiterschreiben, wenn er keine Zeit mehr hat und Geld verdienen muss. Wäre sonst schade, wenn das Teil aus Zeitmagel wieder einschläft. |
|
| Nach oben |
|
|
DerRaphael
Anmeldedatum: 09.01.2008
Beiträge: 825
Wohnort: Zuhause
|
| Verfasst am: Sa Mai 31, 2008 5:48 pm Titel: |
|
|
Ich habe einen Teil dieses Dokument schon im Suche-Hilfe-Teil des Forums vorgestellt, denke mir aber, dass es an dieser Stelle besser aufgehoben ist.
Methodik von Zahlensystemen in der Nussschale
==============================
Erstmal ein kleines Vorwort -wegen dem besseren Verständnis- zu Zahlensystemen (trockene Theorie - ja ich weiß). Zahlensysteme funktionieren im Wesentlichen durch das Zusammenzählen der jeweiligen Symbole.
Nehmen wir die alten Römer. Diese hatten ein recht komplexes System - dort waren die Zahlendarstellungen auch gleichzeitig kleine Rechenaufgaben. Oder große, wenn eine größere Zahl dargestellt wurde.
| Code: | Beispiel:
I -> römisch eins
II -> römisch zwei
V -> römisch fünf
X -> römisch zehn
XX -> römisch zwanzig
etc. |
Diese Schreibweise hatte neben dem Rechenaufwand beim betrachten der Zahlen noch einen Nachteil: Die Römer kannten keine Null.
In useren Kulturkreis wurde die Null zwar mit dem Mittelalter bekannt, jedoch erst sehr viel später fand sie Einzug in die Mathematik. Interessierte können die ganze Geschichte unter http://de.wikipedia.org/wiki/Null nachlesen.
Zurück zu Zahlensystemen: Die Reihenfolge (Position des jeweils einzelnen Symbols unserer zu berechnenden Zahl von rechts) nennen wir mal X, die Rangfolge (Position des Symbols innerhalb der Definition der Symbole) bezeichnen wir als N.
| Code: | ;Beispielhafte Definition der Symbole {abcdefghijklmnopqrstivwxyz}
{abcdefghijklmnopqrstivwxyz}
^- N := 1
Anzahl der Symbole {abcdefghijklmnopqrstivwxyz}
{...} := B
Beispielhafte Zahl -> abcdef
abcdef
^- X := 1 |
Um also Zahlen zu berechnen, nehmen wir die Rangfolge N und multiplizieren sie mit dem Ergebnis, das die Anzahl der Symbole, nennen wir diese B, X weniger 1 mal mit sich selbst multipliziert liefert. X weniger 1, da unser Zahlensystem eigentlich bei 0 beginnt und somit die erste Ziffer NULL ist. Der Einfachheit halber wird das "Mit sich selbst multiplizieren" durch eine Basis B hoch X weniger 1-Darstellung übernommen. Diese kann dann mit der Rangfolge unseres Symbols multipliziert werden.
| Code: | B als Anzahl unserer Symbole {...}
X-1 als Position der Zahl von rechts nach links.
N als Wert der Reihenfolge bei der Symboldefinition {...} |
>> Ein Beispiel:
Wir kennen zehn Symbole für die Darstellung von dezimalen Zahlen. Diese wiederum haben eine festgelegte Reihenfolge. Das sind die beiden Zutaten für unser Zahlensystem.
Wenn wir eine Zahlfolge von 187 haben, rechnen wir (von rechts nach links):
| Code: | dez {0123456789}
(7*10^0) + (8*10^1) + (1*10^2) = 7*1 + 8*10 + 1*100 |
Da 0 die erste Ziffer in der Reihenfolge der definierten Zahlensymbole ist, wird diese auch als erstes verwendet. Mathematisch definiert ist, dass wenn etwas mit Null potenziert wird, das Ergebnis IMMER eins ist.
Um beispielsweise hexadezimalen Zahlen zu verstehen, zählen wir die Anzahl der Symbole - 16 Stück - und nehmen diese Anzahl als Basis. Die Potenzierung erfolgt stets anhand der Posistion in der Reihenfolge des Zielzahlensystems - in unserem Fall: dezimal.
| Code: | hex {0123456789ABCDEF}
0xFF = (15*16^0) + (15*16^1) = 15*1 + 15*16 = 15 + 240 = 255 |
Binäre Zahlensysteme funktionieren mit zwei Symbolen. Zwei ist hier also unsere Basis.
| Code: | bin {01}
b1101 = (1*2^0) + (0*2^1) + (1*2^2) + (1*2^3) = 1*1 + 0*2 + 1*4 + 1*8 = 1 + 0 + 4 + 8 = 13 |
Mit diesem einfachen Grundprinzipien kann man sich Zahlensysteme beliebiger Basen ausdenken und entsprechend berechnen. Auf diesem Wissen aufbauend, können wir uns nun binärer Logik widmen.
Binäre OPERATOREN in der Nussschale
==============================
Anmerkung: Binäre Ziffern haben ein kleines b als Prefix; dezimale Ziffern ein kleines d
Binäres NOT Maskieren (Kurz !)
==============================
Der binäre NOT Operator kehr einfach die entsprechende Bitstruktur um. Jedes gesetzte Bit wird zu einem nicht gesetztem Bit und umgekehrt.
>> Beispiel: NOT Maskierung
| Code: | ! b1000 (d8) ; Die dezimale 8 wird binär invertiert
-------
b0111 (d7) ; und resultiert in einer dezimalen 7
|
Binäres OR Maskieren (Kurz |)
==============================
Binäres OR Maskieren kombiniert die zwei Ausgangswerte anhand ihrer gesetzten Bits. Wo ein Bit gesetzt war, bleibt es gesetzt.
>> Beispiel: OR Maskierung
| Code: | b1000 (d8) ;
| b0011 (d3) ; Dezimal 8 OR-maskiert mit dezimal 3
-------
b1011 (d11) ; Resultiert in dezimal 11. Da jedes gesetzte Bit bleibt |
Typische Benutzung: Setzen von Flags
Binäres AND Maskieren (Kurz &)
==============================
Die binäre AND Maskierung vergleicht jedes Bit aus den Ausgangswerten: Wo jeweils zwei bits gesetzt sind, ist das ergebnis ebenfalls gesetzt; in allen anderen Fällen nicht.
>> Beispiel: Die NN&3 Maskierung
| Code: | b111100 (d60) ; Dezimal 60 - wie man sehen kann, sind die 2 niedrigsten Bits
& b000011 (d3) ; nicht gesetzt. Der AND Operator resultiert in Maskierung der
--------- ;
b000000 (d0) ; zwei kleinsten Bits. Da keine Übereinstimmung, ist das ergebnis NULL
b111111 (d63) ; hat man wie bei dezimal 63 6 bits gesetzt
& b000011 (d3) ; und maskiertz abermals mit dem AND-Operator
---------
b000011 (d3) ; Bleiben diesmal die nierigsten Bits erhalten |
Zusammenfassend: AND-Maskierung eines Integers mit 3 ergibt stets das gleiche wie eine Modulo 4 Division.
Hinweis: Alle Modulo Divisionen, deren Rest sich jeweils durch die niedrigsten Bits darstellen lassen (1,3,7,15 ... ) können durch eine Binäre AND Operation wie hier im Beispiel genutzt werden.
Binäres XOR Maskieren (Kurz ^)
==============================
Die XOR-Maskierung ergibt ein gesetztes Bit, wo Unterschiede in der Bitstruktur bestehen und ein ungesetztes Bit, wo die Ausgangswerte identisch sind.
>> Beispiel: XOR Maskierung
| Code: | b1000 (d8) ;
^ b1011 (d11) ; Dezimal 11 XOR-Maskiert mit dezimal 8
-------
b0011 (d3) ; Ergibt 3 denn die jeweils höchsten Bits waren beide gleich. |
Typische Benutzung: Umschalten von Flags in bereits berechneten binären Werten.
Das Binäre Left Shifting (Kurz <<)
==============================
Left-Shift (Links Verschiebung) 'schiebt' alle Binären Werte um jeweils N stellen nach Links. Die neu entstandenen niedrigen Bits sind nicht gesetzt und werden mit einer NULL repräsentiert.
Sehr vereinfacht funktioniert es so:
| Code: | b00000001 << d1 resultiert in b00000010 (d2)
b00000001 << d2 resultiert in b00000100 (d4) |
Zusammenfassend kann man sagen, dass das Ergebnis auch mit folgender Formel hätte berechnet werden können:
| Code: | NN << x
ist das gleiche wie
NN*(d2**x) ; Multipliziert mit 2 zur X-ten Potenz |
Testen wir unsere Formel! Wir wissen, dass d60 binär b111100 ist und b1111 entspricht d15
| Code: | d15 << d2 muss als d60 ergeben (was es auch macht)
d15 * (d2**d2) = d15 * d4 = d60 |
Das Binäre Right Shifting (Kurz >>)
=========================
Das Right-Shifting (rechts verschiebung) der Binär Daten schneidet die angegebene Zahl an Bits einfach an der rechten Seite ab (niederwertigen Bits)
Sehr vereinfacht funktioniert es so:
| Code: | b00000010 >> d1 resultiert in b00000001 (d1)
b00000100 >> d2 resultiert in b00000001 (d1)
|
Zusammenfassend kann man sagen, dass das Ergebnis auch mit folgender Formel zu erreichen ist:
| Code: | NN >> x
ist das gleiche wie
NN // (d2**x) ; nach unten gerundetes Ergebnis einer Division
; durch 2 zur X-ten Potenz |
Testen wir abermals unsere Formel:
| Code: | d60 >> 2 muss d15 ergeben ; die beiden Bits außen rechts werden abgeschnitten
b111100 >> 2 = b1111 ; Sicher, jedoch funktioniert es auch mit anderen Zahlen?
d60 // (d2**d2) = d15 ; Probieren wir das mal mit d249 (binär b11111001)!
d249 >> d2 = d62
d249 // (d2**d2) = d249 // d4 = abgerundet(d62,25) = d62 |
Dokument Revision 20080531.a / by derRaphael(at)oleco.net
_________________
|
|
| Nach oben |
|
|
|
|
Du kannst Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum antworten.
|
Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de |
FAQ
Suchen
Mitgliederliste
Registrieren
Profil
Einloggen, um private Nachrichten zu lesen
Login
