AutoIt/Zmienne

Zmienne i ich rodzaje

Zmienna to obszar pamięci przechowujący jakieś dane. Dostęp do tych danych jest poprzez nazwę (identyfikator) zmiennej. Zmienne mogą przechowywać wartości różnych typów, liczby lub ciągi znaków (teksty).

Nazwy zmiennych rozpoczynają się od znaku dolara $, po którym mogą występować litery, cyfry lub znak podkreślenia w dowolnej konfiguracji, np.: $a, $11, $_zmienna_2 itp.

Zmienna tworzona jest poprzez przypisanie jej nazwie jakiejś wartości wg schematu:

$nazwa_zmiennej = wartość_zmiennej

np.:

 $a=2
 $b=”jakiś tekst”

Można także utworzyć zmienną przez jej zadeklarowanie. Ten sposób jest obowiązkowy przy ustawionej dyrektywie Opt('MustDeclareVars', 1):

 Dim $a, $b=”Ala”, $c=5	;zadeklarowanie nazwy można połączyć z nadaniem wartości

W powyższym przykładzie zmiennej $a nie nadaliśmy w sposób jawny wartości, lecz domyślnie został jej przypisany pusty łańcuch znakowy.

Tak więc deklaracje Dim $a i Dim $a=”” są sobie równoważne.

W AutoIt nie deklaruje się typu zmiennych, zmienna jest takiego typu, jakiego typu jest przypisana jej wartość (typowanie dynamiczne). Zmienna może w czasie wykonywania programu zmieniać nie tylko wartość, ale nawet typ tej wartości.

I tak całkowicie prawidłowe jest:

 $a=2*2
 $a=”Ala ma kota”

W większości innych języków konstrukcja taka spowodowała wygenerowanie błędu (np. Pascal, C i inne języki statycznie typowane).

Użycie zmiennej zawierającej tekst jako liczby nada jej domyślną wartość 0.

 $a=2
 $b=”Ala ma kota”
 $c=$a*$b               ;zmienna $c przyjmie wartość 0

Zmienne typu prostego

Zmienne można podzielić według tego jakiego typu wartości zawierają:

1. zmienna zawierająca łańcuch znaków zawarty w cudzysłowie lub w apostrofach (typ tekstowy - string):

 $zmienna1 = "qwe123!@#"
 $zmienna2 = 'AutoIt'
 $zmienna3 = "to jest 'cytat'"
 $zmienna4 = 'to jest "cytat"'

Maksymalna długość zmiennej tekstowej wynosi 21 47 483 647 znaków.

2. zmienna zawierająca liczby zmiennoprzecinkowe (typ zmiennoprzecinkowy):

 $zmienna = 2.734

3. zmienna zawierająca tylko cyfry/liczby całkowite (typ całkowity):

 $zmienna = 22734

4. zmienna binarna (ciąg bajtów)

 $zmienna = Binary("ABC") ;zmienna zawiera ciąg wartości kolejnych bajtów odpowiadającym kodom znaków łańcucha

Maksymalna długość zmiennej binarnej wynosi 21 47 483 647 bajtów.

5. zmienna zawierająca wartości logiczne True lub False (typ logiczny):

 $zmienna1 = True
 $zmienna2 = False

6. wskaźnik (pointer) - adres w pamięci komputera 32 lub 64 bitowy (w zależności od posiadanej wersji systemu operacyjnego) Wartości tego typu są zwracane przez funkcje zwracające zaczepy (handle):

 $handle = WinActive("[ACTIVE]")  ;zwróci zaczep (adres) do aktywnego okna

Oprócz zmiennych można tworzyć także stałe. Od zmiennych różnią się tym, że raz nadana im wartość nie może być zmieniona w trakcie działania programu. Próba zmiany wartości stałej spowoduje zgłoszenie błędu.

Stałą deklarujemy za pomocą słowa kluczowego Const, nazwa stałej jest tworzona wg takich samych reguł jak nazwa zmiennej np.:

 Const $PI=3.1415

Zmienne typu złożonego (strukturalne)

W AutoIt jedynym typem zmiennych złożonych są tablice. Zostały one opisane w rozdziale AutoIt/Tablice.

Konwersja typów zmiennych i wyrażeń

Tak naprawdę AutoIt posiada tylko jeden typ wartości nazywany wariantem. Jest to po prostu zawartość pewnego obszaru pamięci.

To w jaki sposób interpreter potraktuje wariant zależy od kontekstu jego użycia. Aby to lepiej zrozumieć prześledźmy poniższy przykład:

 $a=-1.2                                ;zmienna typu zmiennoprzecinkowego
 MsgBox(0,'Test1',$a&$a)                ;użyta jak string ma wartość równą łańcuchowi zapisu tej liczby, wyświetli "-1.2-1.2"
 MsgBox(0,'Test2',Not Not $a)           ;użyta jak wartość logiczna równa się True gdy jest różna od zera
 $a=0
 MsgBox(0,'Test3',Not Not $a)           ;lub False gdy jest równa zeru
 $a=""
 MsgBox(0,'Test4',Not Not $a)           ;wartość logiczna pustego łańcucha wynosi False
 $a='ala'
 MsgBox(0,'Test5',Not Not $a)           ;a niepustego True
 $a="-1.2x"                             ;jeżeli początek łańcucha odpowiada zapisowi jakiejś liczby
 MsgBox(0,'Test6',1+$a)                 ;to po użyciu w charakterze liczby zostanie mu przypisana wartość tej liczby, wyświetli -0.2 
 $a=True                                ;przypisanie zmiennej wartości logicznej
 MsgBox(0,'Test7',$a+$a)                ;wartość liczbowa True wynosi 1, więc wyświetli wynik 2 (1+1)     
 MsgBox(0,'Test8',$a&$a)                ;użyta jako string zostanie potraktowana jak napis "True", wyświetli więc "TrueTrue"
 
 $a=Binary("JIH")                       ;funkcja Binary zamienia string na zmienną binarną, czyli ciąg wartości bajtów odpowiadający kodom kolejnych znaków stringu
 MsgBox(0,'Test9',$a)                   ;wyświetli zmienną binarną jako ciąg bajtów w kodzie szesnastkowym "0x48494A"
 MsgBox(0,'Test10',1+$a)                ;wartości binarnej użytej jako liczba zostanie przypisana wartość 0, wyświetli więc 1 (1+0)
 MsgBox(0,'Test11',Not Not $a)          ;użyta jak zmienna logiczna ma wartość True
 MsgBox(0,'Test12',BinaryToString($a))  ;zamiana wartości binarnej na string
 
 $a=0x48494A                            ;to nie jest wartość binarna, lecz zwykła liczba zapisana w kodzie szesnastkowym
 MsgBox(0,'Test13',$a)                  ;wyświetli więc tę liczbę w systemie dziesiętnym

Są to przykłady niejawnej konwersji typów. Niejawnej gdyż dokonywanej przez interpreter bez udziału programisty. Możliwa jest także konwersja jawna, wymuszona przez programistę. Służą do tego odpowiednie funkcje AutoIt'a:

String - zamienia wyrażenie na łąńcuch znakowy (string):

String(wyrażenie)

 $var1=String(3.14)                       ;wynik łańcuch "3.14"
 $var2=String(True)                       ;wynik łańcuch "True"
 $pointer=WinActive("[ACTIVE]")           ;odczytanie zaczepu (typ wskaźnikowy)
 $var3=String($pointer)                   ;wynik łańcuch będący zapisem adresu w kodzie szesnastkowym (np. 0x0007031C)

Number - zmienia wyrażenie na liczbę.

Number(wyrażenie)

 $w = Number(1+2+10)    ;wynik 13
 $x = Number("3.14")    ;wynik 3.14
 $y = Number("24/7")    ;wynik 24
 $z = Number("tmp3")    ;wynik 0

Int - zmienia wyrażenie na liczbę całkowitą, część ułamkowa jest pomijana.

Number(wyrażenie)

 $var1=Int(10.793)    ;wynik 10
 $var2-Int(-22.3)     ;wynik -22

Celing - zmienia wyrażenie na najbliższą większą liczbę całkowitą.

Celing(wyrażenie)

 $var1=Celing(10.793)    ;wynik 11
 $var2=Celing(-22.3)     ;wynik -22

Floor - zmienia wyrażenie na najbliższą mniejszą liczbę całkowitą.

Floor(wyrażenie)

 $var1=Int(10.793)    ;wynik 10
 $var2-Int(-22.3)     ;wynik -23

Round - zmienia wyrażenie na zaokrągloną liczbę

Round(wyrażenie, [ilość miejsc dziesiętnych])

 $x = Round(-1.582, 1)  ;wynik -1.6
 $y = Round(3.1415, 9)  ;wynik bez zmian 3.1415
 $z = Round(123.5, -1)  ;wynik 120

Binary - zmienia wyrażenie na wartość binarną.

Binary(wyrażenie)

 $x=Binary(0xAAFF)
 $y=Binary("ala ma kota")

Ptr - zmienia wyrażenie na wskaźnik (adres 32 lub 64 bitowy w kodzie szesnastkowym).

Ptr(wyrażenie)

 $x=Ptr(0xAAFF)          ;wynik 0x0000AAFF (w systemie 32 bitowym)
 $y=Ptr("ala ma kota")   ;wynik 0x00000000

Testowanie zmiennych i wyrażeń

Testowanie zmiennych i wyrażeń ma na celu poznanie rodzaju wartości jakie one reprezentują. Służy do tego kilka funkcji:

VarGetType(wyrażenie)

Funkcja zwraca string opisujący typ wartości wyrażenia:

 $typ1=VarGetType(1)               ;zwróci "Int32"   - 32 bitowa liczba całkowita 
 $typ2=VarGetType(1.1)             ;zwróci "Double"  - liczba zmiennoprzecinkowa
 $typ3=VarGetType("XYZ")           ;zwróci "String"  - łańcuch znakowy
 $typ4=VarGetType(False)           ;zwróci "Bool"    - wartość logiczna
 $typ5=VarGetType(Binary("XYZ"))   ;zwróci "Binary"  - wartość binarna
 $typ6=VarGetType(Ptr(0xAABB))     ;zwróci "Ptr"     - wskaźnik (adres)
 Dim $var[5)                       ;tworzymy tablicę
 $typ7=VarGetType($var)            ;zwróci "Array"   - tablica

IsInt(wyrażenie)
IsFloat(wyrażenie)
IsString(wyrażenie)
IsBool(wyrażenie)
IsBinary(wyrażenie)
IsArray(wyrażenie)

Wszystkie te funkcje zwracają 1 gdy badane wyrażenie jest danego typu, w przeciwnym razie zwracają 0.

Przykład:

 $a=1
 $x=IsInt($a)             ;zwróci 1
 $x=IsInt($a+1.1)         ;zwróci 0
 $x=IsFloat($a+1.1)       ;zwróci 1

Zakres ważności zmiennych (stałych)

Zmienne i stałe wszystkich typów mogą być zadeklarowane za pomocą Dim, Global lub Local w zależności od wymaganego zakresu i tak:

Dim – zmienna lokalna w stosunku do miejsca deklaracji (jeżeli zmienną zadeklarujemy w segmencie głównym to zakresem będzie cały program, jeżeli wewnątrz funkcji to zakresem będzie ta funkcja i wszystkie funkcje wywoływane z jej wnętrza.

Local – zakres lokalny (np. tylko wnętrze funkcji lub tylko segment główny)

Global – zakresem jest cały program.

Aby uniknąć błędów lepiej jest deklarować jawnie zakres zmiennych, w zależności od potrzeb poprzez Global lub Local.

Normalnie zmienne w AutoIt są dynamiczne, tzn. że są tworzone przy wejściu w ich zakres i niszczone po jego opuszczeniu. Np. zmienne utworzone w funkcji są usuwane z pamięci po jej opuszczeniu (chyba że zostały zadeklarowane jako globalne).

Zmienne statyczne

W AutoIt można tworzyć zmienne statyczne. Służy do tego słowo kluczowe Static.

Zmienne statyczne są dostępne w ich zakresie ważności, tak jak zmienne dynamiczne, lecz po jego opuszczeniu nie są niszczone. Po ponownym wejściu w zakres ich wartość jest zachowana.

Prześledźmy następujący przykład, który ilustruje różnice między zmiennymi statycznymi i dynamicznymi:

 MsgBox(0,"Static 1",test1())  ;wyświetli 1
 MsgBox(0,"Static 2",test1())  ;wyświetli 2
 MsgBox(0,"Static 3",test1())  ;wyświetli 3
 
 MsgBox(0,"Dynamic 1",test2()) ;za każdym razem wyświetli 1
 MsgBox(0,"Dynamic 2",test2())
 MsgBox(0,"Dynamic 3",test2()) 

 Func test1()
 	Static Local $a=0   ;utworzenie zmiennej statycznej i nadanie jej wartości następuje tylko przy pierwszym wywołaniu funkcji
                            ;przy kolejnych jest przywoływana z pamięci jej ostatnia wartość
 	$a=$a+1
 	Return $a
 EndFunc
 
 Func test2()
 	Local $a=0          ;utworzenie zmiennej dynamicznej i nadanie jej wartości następuje przy każdym wywołaniu funkcji
 	$a=$a+1
 	Return $a
 EndFunc

Jako statyczne można deklarować tylko zmienne. Próba zadeklarowania stałej jako statycznej spowoduje wystąpienie błędu:

 Static Const $PI=3.1415    ;wystąpi błąd przy próbie uruchomienia skryptu