Zmienne i ich rodzaje

Na początek dwie krótkie definicje (wg WIKI):

Zmienna - konstrukcja programistyczna posiadająca trzy podstawowe atrybuty: symboliczną nazwę,
miejsce przechowywania i wartość, pozwalająca w kodzie źródłowym odwoływać się przy pomocy nazwy
do wartości lub miejsca przechowywania.
Nazwa służy do identyfikowania zmiennej w związku z tym często nazywana jest identyfikatorem.

Wyrażenie w języku programowania to kombinacja wartości, zmiennych, operatorów, funkcji i nawiasów,
wartościowana zgodnie z regułami tego języka, która po zakończeniu wykonywania, zwraca pewną wartość.
Proces ten nazywamy "wartościowaniem wyrażenia".

Zmienna jest więc pewnym obszarem pamięci przechowujący jakąś wartość. 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), a także wartości pewnych specjalnych typów.

Nazwy zmiennych

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.

AutoIt nie rozróżnia w nazwach zmiennych wielkości liter. Zmienna $a i $A to wg AutoIt ta sama zmienna.

Tworzenie zmiennych

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

$nazwa_zmiennej = wyrażenie

np.:

$a=2                  ;pojedyncza wartość to też wyrażenie
$b="jakiś tekst"      ;tutaj wartość jest łańcuchem znakowym (stringiem)
$c=2+3-0.5
$d=$a
$e=$a+$c-2

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 (typowanie słabe).

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 silnie 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

Użycie nazwy zmiennej, której nie nadano wartości spowoduje wystąpienie błędu:

MsgBox(0,'Test',$a) ;błąd przy próbie uruchomienia skryptu

A teraz błędu już nie będzie:

Dim $a
MsgBox(0,'Test',$a)

Zmienne typu prostego

Zmienna prosta to taka zmienna, która przechowuje pojedynczą wartość.

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

Typ String

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.

Typ Number

Zmienna zawierająca liczbę zmiennoprzecinkową (typ zmiennoprzecinkowy):

$zmienna = 2.734

Typ Integer

Zmienna zawierająca tylko cyfry/liczby całkowite (typ całkowity):

$zmienna = 22734

Typ Binary

Zmienna zawierająca łańcuch binarny (łańcuch wartości kolejnych 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.

Typ Boolen

Zmienna zawierająca wartości logiczne True lub False (typ logiczny):

$zmienna1 = True
$zmienna2 = False

Typ Pointer

Wskaźnik - adres w pamięci komputera 32 lub 64 bitowy (w zależności od posiadanej wersji systemu operacyjnego) Wartości tego typu są tworzone przez funkcje zwracające uchwyty (handle):

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

Wartość Null

Zmienne w AutoIt mogą przyjmować specjalną wartość opisaną słowem kluczowym "Null".

$var = Null

Null użyte jako liczba ma wartość 0, a jako łańcuch jest równoważne pustemu stringowi "".

Wartość Null wprowadzono aby umożliwić wywołanie specyficznych funkcji, które wymagają jej jako parametru (więcej o tym w rozdziałach o bibliotekach DLL i obiektach COM).

Zmienne typu złożonego (strukturalne)

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

UWAGA: W AutoIt można korzystać także z innego rodzaju zmiennych strukturalnych, takich jak struktury (rekordy), kolejki, stosy, itp.

Dostęp do tych struktur danych nie jest jednak bezpośredni, lecz za pomocą zestawu stosownych funkcji. Opis w części podręcznika dla zaawansowanych.

Konwersja typów zmiennych i wyrażeń

Wariant

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
MsgBox(0,'Test9',$a)           ;wyświetli zmienną binarną jako ciąg bajtów w kodzie szesnastkowym
                               ;"0x4A4948"

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 łań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.

Int(wyrażenie)

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

Ceiling

Zmienia wyrażenie na najbliższą większą liczbę całkowitą.

Ceiling(wyrażenie)

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

Floor

Zmienia wyrażenie na najbliższą mniejszą liczbę całkowitą.

Floor(wyrażenie)

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

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

IsNumber(wyrażenie)
IsInt(wyrażenie)
IsFloat(wyrażenie)
IsString(wyrażenie)
IsBool(wyrażenie)
IsBinary(wyrażenie)
IsArray(wyrażenie)
IsPtr(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 (zasięg) zmiennych i stałych

Zmienne i stałe wszystkich typów mogą być zadeklarowane za pomocą Dim, Global lub Local w zależności od wymaganego zasięgu, 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). Jeżeli zmienna była wcześniej zadeklarowana w segmencie głównym to użycie Dim powoduje globalną zmianę jej wartości (jak Global). Deklaracja Dim jest domyślna czyli np.: $a=1 jest równoważne Dim $a=1.

Local – zakres lokalny, tylko wnętrze funkcji lub cały program jeżeli użyto w segmencie głównym

Global – zakresem jest cały program, niezależnie czy użyto w segmencie głównym, czy w definicji funkcji.

Dim, Local, Global użyte w segmencie głównym działają tak samo, czyli jak Global

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

Zmienne statyczne

Normalnie zmienne w AutoIt są dynamiczne, tzn. że są tworzone przy wejściu w ich zasięg 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).

Można także 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

Specjalne typy zmiennych

Oprócz wcześniej opisanych typów, zmienne w AutoIt mogą przyjmować wartości pewnych specyficznych typów:

nazwa funkcji (wbudowanej lub zdefiniowanej przez użytkownika)
uchwyt
obiekt
struktura (rekord)
słowo kluczowe Default lub Null

$var = MsgBox ;nazwa funkcji
MsgBox(64,"Typ zmiennej", VarGetType($var)) ;zwraca Function

$var = WinGetHandle("[ACTIVE]") ;uchwyt
MsgBox(64,"Typ zmiennej", VarGetType($var)) ;zwraca Ptr

$var = ObjCreate("Scripting.Dictionary") ;obiekt
MsgBox(64,"Typ zmiennej", VarGetType($var)) ;zwraca Object


$var = DllStructCreate("wchar[256]") ;struktura
MsgBox(64,"Typ zmiennej", VarGetType($var)) ;zwraca DllStruct

$var = Default ;słowo kluczowe
MsgBox(64,"Typ zmiennej", VarGetType($var)) ;zwraca Keyword

Podobnie jak dla standardowych typów, zmienne można testować czy zawierają wartości tych niestandardowych typów.

Poniższe funkcje zwracają True, gdy zmienna jest danego typu:

IsFunction  (nazwa funkcji)
IsHWind     (uchwyt)
IsObject    (obiekt)
IsDllStruct (struktura)
IsKeyword   (słowo kluczowe Default lub Null)

UWAGA: Więcej informacji o niestandardowych typach zmiennych w części dla zaawansowanych.

Stałe

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

Przed Const można podać zakres ważności stałej (Dim, Local lub Global). Pominięcie oznacza tyle co Dim.

Przykład:

Global Const $PI=3.1415
Local Const $stala_1=13, $stala_2=666

Tworzenie stałych poleceniem Enum

Stałe można tworzyć także przy użyciu polecen Enum.

[zakres] Enum [Step <krok>] <lista stałych>

zakres - (opcjonalnie) zakres ważności stałej (Dim, Local lub Global). Pominięcie oznacza tyle co Dim.

krok - (opcjonalnie) krok jakim będzie zmieniana wartość kolejnych stałych. Wartość domyślna 1, czyli kolejne stałe mają wartość zwiększaną o 1.

+n - zwiększanie o n
-n - zmniejszanie o n
*n - wymnażanie przez n
(n musi być liczbą całkowitą)

lista stałych - lista nazw stałych, może być powiązana z nadaniem wartości.

UWAGA:

1. Domyślnie, pierwsza stała będzie mieć wartość 0, a reszta będzie zwiększana o 1.

2. Jeżeli użyjemy kroku wymnażanego (*n) pierwszej stałej zostanie przypisana wartość 1, a kolejne będą tworzone z poprzedniej stałej wymnożonej przez n (1, n, n*n, n*n*n itd).

3. Stałym można nadawać wartości w sposób jawny (np. $s1=10), a następne stałe (którym nie nadano wartości w sposób jawny) będą przyjmować wartości w sposób opisany w punktach 1 i 2.

Przykład:

Global Enum $s1, $s2, $s3          ; 0, 1, 2
MsgBox(0, "Enum:", "$s1 = " & $s1 & @LF & _
		   "$s2 = " & $s2 & @LF & _
		   "$s3 = " & $s3)

Global Enum $s4 = 15, $s5, $s6 = 2 ; 15, 16, 2 
MsgBox(0, "Enum:", "$s4 = " & $s4 & @LF & _
		   "$s5 = " & $s5 & @LF & _
		   "$s6 = " & $s6)

Global Enum Step *2 $s7, $s8, $s9  ; 1, 2, 4
MsgBox(0, "Enum:", "$s7 = " & $s7 & @LF & _
		   "$s8 = " & $s8 & @LF & _
		   "$s9 = " & $s9)