[TuT] AutoIT Tutorial by Phoenix_PL

Phoenix_PL · 1 Stycznia 2013

AutoIT Tutorial

by Phoenix_PL 2013©

Z okazji roku 2013, mojego 1000 postów i tego że przechodzę na bardziej zaawansowane języki i kończę z AutoIT, chcę jeszcze napisać sporego tutka (do którego się od dawna przymierzałem) który opisze możliwości AutoITa.

Wiem że jest już taki tutek, ale moim skromnym zdaniem nie opisuje wszystkiego co AutoIT oferuje.
Chociaż dla początkujących jest nawet-nawet.

No dobrze, w takim razie zaczniemy od podstawowych podstaw coby zupełny newbie się połapał, i będę przechodził do coraz bardziej zaawansowanych rzeczy.
Tutorial będzie tylko w tym temacie, więc może się wydawać rozsypany, ale mniej-więcej tutaj umieszczę linki do wszystkich części tutoriala.

A tu macie listę rozdziałów, jeśli ten już przeczytaliście:
Rozdział II - Zmienne
Rozdział III - Pętle
Rozdział IV - Instrukcje warunkowe
Rozdział V - Funkcje
Rozdział VI - GUI, część I
Rozdział VII - GUI, część II
Rozdział VIII - Tablice

Ciekawostki - Wielolinijkowość i makra
Ciekawostki - Porządkowanie kodu

I. TEORIA

Zaczynam od tego, od czego powinno się zacząć, czyli od teorii. Będzie ogólnie o programowaniu, AutoIcie, jego plusach i minusach oraz porównam go z innymi językami.

Ogólnie o programowaniu

Programowanie to wbrew pozorom prosta rzecz, której każdy może się nauczyć.
I nie trzeba być wcale powołany do tego, wystarczy mieć chęci.

Programowanie to pisanie linijek kodu które potem zostaną przekształcone w gotowy program który ma robić 'coś'. O tym czym będzie to 'coś' sami zdecydujemy. Wystarczy mieć pomysł i umiejętności i jesteśmy w stanie napisać dosłownie wszystko.

O AutoIcie

AutoIT to język skryptowy który pierwotnie miał byś używany w automatyzacji czynności pod Windowsem.
Jego pierwsza wersja (ScriptIt) powstała w Styczniu 1999 roku. Wtedy ten język ograniczał się do funkcji Send, Run, RunWait, WinWait, WinWaitClose, WinWaitActive, WinHide, WinActivate, WinClose, WinRestore, Sleep i SetKeyDelay.
Jednakże to są funkcje które do dzisiaj są bardzo często używane.

AutoIT został stworzony jedynie pod Windowsa. Niestety muszę uprzedzić że ma kilka wad, które wymienię razem z zaletami poniżej.

Plusy i minusy AutoITa

+ Prostota kodu
+ Nie trzeba się martwić o typy danych
+ Wiele bibliotek (UDFów) pisanych przez jego programistów
+ Plik z wszystkimi funkcjami oraz angielskim tutorialem dołączony do kompilatora
- Programy są całkiem spore (>300kb)
- Programy łatwo zdekompilować (ale od tego jest wyjątek)
- Jest to język dosyć wolny (wytłumaczenie poniżej)
- Brak klas
- Tylko pod Windowsa

A teraz troszkę wyjaśnień co i jak.
Co do plusów - Pisanie w AutoIcie ogranicza się do klepania komend. Jest to w sumie plus bo początkujący łatwo ogarnie, ale i minus bo cudów w nim nie wykombinujesz.
Co do typów danych, to ten kto widział C++/C#/Javę albo jakikolwiek inny szanujący się język programowania to wie o co chodzi. Zazwyczaj danej zmiennej (czyli kawałek pamięci w którym możemy przechowywać dane; o tym później) przydziela się jeden typ danych który może przechowywać.
W AutoIT ten typ jest przydzielany dynamicznie, i jedna zmienna obsługuje praktycznie każdy typ danych. Jest to genialne udogodnienie.

Jest wielu programistów, nawet tutaj na MPCForum którzy zajmują się pisaniem własnych bibliotek (włącznie ze mną). Przez co możliwości AutoITa powiększają się.

I plik z funkcjami, potocznie mówiąc 'Help', to ukryte pod klawiszem F1 w SciTE kompendium wiedzy o AutoIcie. Jeśli ktoś zna angielski rzecz jasna, bo polskiej wersji jak nie było tak nie ma (są tylko częściowo spolszczone). Zawiera dokładne opisy i składnię wszystkich AutoITowych funkcji, więc bez tego ani rusz.

A teraz o minusach.
Najpierw powiem dlaczego nie dałem do nich braku obiektowości oraz multitaskingu (multithreading, wykonywanie wielu instrukcji jednocześnie przez kilka wątków programu). Powód prosty, bo one występują w AutoIcie. W postaci najprostszej z możliwych, ale występują.
Multitasking objawia się w funkcji AdlibRegister, która pozwala nam zapętlić jedną funkcję która będzie się wykonywała prawie niezależnie od reszty programu (funkcja 'przeplata' kod programu z kodem funkcji, przez co jeśli w naszej funkcji wystąpi coś co może zatrzymać program, wtedy program zostanie zatrzymany)
Obiektowość. Wbrew pozorom wiele programistów nie wie (a powód jest taki, że rzadko kiedy jest to przedstawione w tutorialu) że w AutoIcie można tworzyć obiekty i nimi sterować.
Obiektem jest przykładowo Internet Explorer którym możemy sterować za pomocą obiektowości w AutoIT (co prawda mamy o tego też osobnego UDFa, ale kto bym tam sobie utrudniał życie

)

Zostaje jeszcze kwestia dekompilacji. Dekompilacja to odwrotność kompilacji, czyli przerobienie pliku wykonywalnego (.exe) na kod źródłowy. Z tego powodu że AutoIT jest językiem 'nie do końca' kompilowanym, programy w nim są spore i wolne (w porównaniu do innych języków).
Jednak co w dzisiejszych czasach znaczy 300-400kb, a jego 'spowolnienie' jest prawie niezauważalne.

Porównanie AutoITa do innych języków programowania

Różnica jest zasadnicza.
AutoIT 'dziedziczy' cechy z wielu języków.
Głównie z C i C++
Przykładem jest dyrektywa #include oraz sposób sterowania obiektami, które są prawie identyczne jak w C++.
Jednak, AutoIT posiada własne (uproszczone rzecz jasna) struktury typu pętle oraz instrukcje warunkowe.
Można w AutoIT też łączyć linijki kodu za pomocą znaku _ . Nie można jednak pisać wielu poleceń w jednej linijce, bo AutoIT nie posiada znaku zakończenia linii (zazwyczaj takim znakiem jest średnik) który informuje kompilator o końcu linii kodu.

Kończąc już ten wstęp do programowania, nie napisałem nic o kompilatorze ani tego typu pierdółach.
Tak więc teraz machnę krótki wykładzik i zakończę tą część tutoriala.

O podróży od kodu do wykonania

Czyli jak to się dzieje że klikamy przycisk i nasz program się uruchamia.
Wytłumaczę cały proces, po drodze tłumacząc co jest czym.

Na początku był edytor. Podobno nazywał się SciTE, ale równie dobrze mógł to być Notatnik. Programista nakazał stworzyć plik. I plik się stał. Z rozszerzeniem .au3, które było dobre.
Następnie programista zaczął dzieło. Pisał linijki kodu które także były dobre.
Widząc swoje dzieło, programista kazał swojemu programowi się uruchomić. I stało się.
A że programista tych czasów jest jak Chuck Norris, to program sam się skompilował i zalinkował a następnie uruchomił.

shit happens, programista był debilem i nie umiał programować, czas na prawdziwą teorię.

Na początku trzeba mieć w czym pisać. Może to być i zwykły notatnik, ale wygodniej jest użyć narzędzi polecanych przez twórców języka.
W tym wypadku jest to SciTE, edytor który jest dołączany do kompilatora AutoIT (ale można też pobrać jego rozszerzoną wersję, która zawiera o wieeele więcej funkcji).
Następnie trzeba stworzyć i gdzieś zapisać plik, w którym znajdzie się nasz kod. Kod AutoIT posiada rozszerzenie .au3, a SciTE automatycznie zapisuje w nim pliki.
Potem trzeba nasz program napisać, co mój tutorial wyjaśni krok po kroku.
Kiedy program będzie napisany i zechcemy go skompilować, musi przejść przez szereg innych programów i procedur żeby mógł się uruchomić.

Najpierw przechodzi do debuggera, który sprawdza go pod kątem błędów w składni języka.
Z tego iż jest to złośliwa machina zła która nie pozwoli przejść dalej naszemu programowi jeśli posiada najmniejszy błąd, zazwyczaj zatrzymuje cały proces i wywala nam info o błędzie (dzisiejsze debuggery podają jeszcze miejsce wystąpienia błędu, więc nie trzeba kombinować gdzie on jest)

Jeśli jednak kod przejdzie test, przechodzi do kompilatora i linkera, które przerobią go do postaci zer i jedynek a potem zapiszą do pliku .exe, który możemy uruchamiać.

Tyle w tym temacie, nie musimy więcej wiedzieć, ponieważ i tak nam się to nie przyda.

Zakończenie

Tyle z tej części tutoriala, w najbliższym czasie postaram się dopisać kolejne części tak, aby powstał naprawdę dokładny tutorial.
Dobranoc

-% plx :x

Phoenix_PL · 3 Stycznia 2013

II. ZMIENNE

Pierwsze i podstawowe pytanie - co to są zmienne?

Zmienna to kawałek pamięci komputera do którego możemy 'wsadzić' jakieś dane.

Jakie dane? Głównie tekst oraz liczby.

Oraz do czego nam się to przyda?

Do praktycznie wszystkiego.

Zmienne to podstawowa rzecz jeśli chodzi o programowanie. Bez nich nie byłoby możliwości zapisywać gdzieś w pamięci programu na przykład jakichkolwiek danych oraz potem ich użyć.

Jednak, zanim będziemy mogli zmiennej użyć, należy ją zadeklarować, czyli zarezerwować dla niej miejsce w pamięci komputera i tym samym utworzyć zmienną.

W AutoIT co prawda nie jest to konieczne, bo zmienne (podobnie jak w PHP) deklarują się przy ich pierwszym użyciu.

Ale czasem trzeba je zadeklarować ręcznie, w taki oto sposób:

[modyfikator zasięgu] $zmienna

Modyfikator zasięgu jest to słówko które opisuje jaki zmienna ma zasięg.

Zasięg zmiennej może być lokalny, czyli zmienna będzie widoczna wyłącznie w strukturze w jakiej została utworzona (czyli na przykład w funkcji czy pętli) albo globalny, a wtedy jest widoczna w całym programie bez wyjątku.

Jednak nie radzę używać zmiennych globalnych nałogowo, ponieważ to w jakimś stopniu zamula program (zużywa więcej pamięci).

A jaki modyfikator zasięgu wstawić?

Local - modyfikator lokalny

Global - modyfikator globalny

Zmienna domyślnie (czyli bez podania modyfikatora) jest deklarowana jako lokalna.

Istnieje jeszcze jeden modyfikator, mianowicie Dim, który działa następująco:

Kiedy użyjemy Dim, zmienna zostanie zadeklarowana jako globalna, o ile nie ma innej zmiennej globalnej o tej samej nazwie.

Jeśli jednak istnieje taka zmienna, to nasza zmienna jest zadeklarowana jako lokalna.

Nie można zmieniać zasięgu zmiennej, tak samo jak nie można jej deklarować dwa razy.

Nie mogą też istnieć dwie zmienne o tej samej nazwie, a przy tworzeniu zmiennych możemy użyć jednie liter a-z, A-Z, cyfr oraz _

Oraz wielkość liter ma znaczenie. Zmienna

$Zmienna

to nie to samo co

$zmienna

Kiedy jesteśmy już przy modyfikatorach zasięgu, jest jeszcze jedna rzecz do powiedzenia, a mianowicie jak stworzyć stałą.

Stała, to zmienna której wartości raz przypisanej przy deklaracji nie można zmienić.

Deklaruje się ją następująco:

Const $zmienna = wartosc

to Const służy do deklaracji stałej.

Oczywiście możemy po Const wstawić modyfikator zasięgu.

A przy okazji pokazałem jak przydzielić zmiennej jakąś wartość. Lecz ja wpisałem wartosc co nie jest dopuszczalne, bo tekst trzeba zapisać pomiędzy cudzysłowami podwójnymi (lub pojedyńczymi, ale nie radzę się tego uczyć bo kiedy zechcemy się uczyć innych języków to przyniesie nam to trochę kłopotu)

$zmienna = "tekst"

Ale nie wolno robić tak:

$zmienna = ''tekst''

Do zmiennej możemy też przypisać liczbę oraz wartość logiczną.

Liczbę przypisujemy następująco:

$zmienna = 53

Kiedy chcemy wstawić liczbę zmiennoprzecinkową, musimy tylko użyć kropki zamiast przecinka

$zmienna = 4.23

I jeszcze trochę o wartości logicznej. Wartość logiczna to dwie wartości - prawda i fałsz.

Jest to wbrew pozorom bardzo przydatne w różnych sytuacjach (na przykład w pętlach) a taką zmienną deklarujemy tak:

$zmienna = True

dla wartości 'prawda'

$zmienna = False

dla wartości 'fałsz'

Można te wartości porównać do liczb.

Wartość False reprezentuje liczba 0, zaś wartość True to domyślnie 1, ale może to być ikażda inna dowolna liczba.

To tyle w temacie deklaracji i przypisywania wartości zmiennym, teraz napiszę jak ich użyć.

Zmiennych używa się w prosty sposób.

Wystarczy podać jej nazwę tam, gdzie chcemy żeby jej użyć.

Pokażę to na przykładzie MsgBoxa

$zmienna = 5
MsgBox(0, "", $zmienna)

Ten kod możemy wsadzić w SciTE i kliknąć F5 żeby przekonać się że MsgBox wyświetli nam wartość zmiennej, jaka by ona nie była.

Możemy też sprawdzić tezę o reprezentacji 1 i 0 dla True i False w ten sposób. Wystarczy ustawić wartość zmiennej najpierw na True, potem na False i zobaczyć co się stanie

I jeszcze krótkie słowo o funkcji MsgBox.

Tak wygląda jej składnia:

MsgBox(flaga, tytuł okna, tekst okna)

Będziemy się z nią często bawić, więc warto znać jej składnię nawet na pamięć.

Opiszę jeszcze parametry (czyli flaga, tytuł okna i tekst okna)

flaga - to liczba która odpowiada za m.in wygląd MsgBoxa. Zapraszam do Helpa (F1 w SciTE) pod hasło MsgBox żeby dowiedzieć się o nich więcej

tytuł okna - to tekst który zostanie wyświetlony na belce tytułowej okna

tekst okna - a to tekst który zostanie w MsgBoxie wyświetlony

Okej, wracamy do zmiennych.

Teraz będzie o tym, jak połączyć dwie zmienne ze sobą oraz z osobnymi danymi (czyli tekstem, liczbami itp.), jak kopiować ich dane między zmiennymi oraz jak wykonywać na nich działania matematyczne.

Połączyć dwie zmienne ze sobą oraz danymi to banał.

Wystarczy użyć &

Przykładowo:

$tekst1 = "Ala ma"
$tekst2 = " kota"
$calytekst = $tekst1 & $tekst2

Jeśli spróbujemy wyświetlić zmienną $calytekst to wyświetli nam tekst Ala ma kota

Zmienne tak samo łączy się z 'bezpośrednimi' danymi, czyli:

$tekst1 = "Ala ma"
$calytekst = $tekst1 & " kota"

Jest to identyczny tekst jak w poprzednim przykładzie.

Kopiowanie danych między zmiennymi można też nazwać masowym przydzielaniem tej samej wartości.

$zmienna1 = $zmienna2 = $zmienna3 = 5

W tym wypadku wszystkie zmienne będą wynosić 5, jednakże należy zmienne $zmienna2 oraz $zmienna3 wcześniej zadeklarować.

A teraz trochę o działaniach matematycznych i kończymy.

Do działań używamy następujących znaków:

+ - dodawanie

- - odejmowanie

* - mnożenie

/ - dzielenie

^ - potęgowanie

Działania na zmiennych wykonuje się wstawiając pomiędzy nie te znaki.

Przykład:

$liczba1 = 3
$liczba2 = 5
$liczba3 = $liczba1 + $liczba2

I $liczba3 wynosi 3+5 czyli 8

Rzecz jasna kolejność działań obowiązuje a i możemy używać nawiasów.

Możemy w ten sposób też wykonywać działania na zwykłych liczbach.

Pokażę te obie rzeczy naraz

$liczba = ((4 + 3) * 2 - (2 + 1.5)) ^ 2

wychodzi 110.25 (lol, niezły przykład wymyśliłem)

Jeśli chcemy coś dodać/odjąć/pomnożyć lub podzielić zmienną to możemy użyć skróconych operatorów działań

+= - dodaj do zmiennej liczbę po prawej

-= - odejmij od zmiennej liczbę po prawej

*= - pomnóż zmienną przez liczbę po prawej

/= - podziel zmienną przez liczbę po prawej

Czyli zamiast pisać

$zmienna = $zmienna - $zmienna2

możemy napisać

$zmienna -= $zmienna2

Prawda że fajne?

No dobrze, to by było na tyle w kwestii zmiennych.

Jeśli czegoś nie rozumiesz lub coś pominąłem albo napisałem źle to pisz w tym temacie, postaram się wyjaśnić lub dodać do tematu.

Phoenix_PL · 4 Stycznia 2013

III. PĘTLE

Dzisiaj wam opowiem conieco o podstawowej strukturze nie tylko w AutoIT ale i w każdym języku - o pętli.

Jak sama nazwa wskazuje, pętla jest używana żeby powtarzać określoną czynność kilka razy.

Jest to naprawdę piekielnie przydatna rzecz, na przykład w grach.

Przecież cały świat który widzimy w grze, to jedna wielka, pamięciożerna pętla w której są zawarte instrukcje które np. sprawdzają czy dwa obiekty się nie zderzyły oraz generują grafikę.

W AutoIT są trzy (a nawet cztery) typy pętli. Pierwsza, najbardziej podstawowa to pętla Do...Until

Przedstawia się ona w ten sposób:

Do
{instrukcje}
Until {warunek}

Pomiędzy Do a Until wstawiamy instrukcje które mają się wykonać w pętli, a warunek to jest... warunek

Troszkę opowiem o warunku, bo to ważna rzecz.

Warunek jest to jakieś prosto mówiąc równanie. Jego wartość może wynosić True albo False (logiczny typ danych, było o tym przy zmiennych). W pętli Do instrukcje są wykonywane dopóki warunek będzie nieprawdziwy. Pętla zatrzyma się kiedy warunek będzie prawdziwy.

Do tego typu równań są używane specjalne operatory nierówności, ale o tym pod koniec pętel (pętl, pętel, dziwne słowo )

A to jest przykładowy programik z pętlą Do

$i = 10
Do
MsgBox(0, "Odliczanie!", $i)
$i -= 1
Until $i = 0

Jak widzimy, program odlicza od 10 do 0 a kiedy wartość zmiennej $i dojdzie do 0, program się wyłącza.

Można powiedzieć że pętla Do to odmieniec wśród pętli. Pierwszą jej charakterystyczną cechą jest to, że instrukcja zawarta w niej wykona się przynajmniej raz. Sprawdzenie warunku jest na końcu iteracji pętli.

Iteracja jest to jeden przebieg pętli.

Charakterystyczną jej cechą jest też to, że działa dopóki warunek jest fałszywy.

Teraz pętla While...WEnd

While {warunek}
{instrukcje}
WEnd

Tutaj akurat pętla działa dopóki warunek jest prawdziwy, a także może się wogóle nie wykonać (jeśli warunek jest nieprawdziwy przy próbie użycia pętli)

I praktycznie tyle ją różni od pętli Do, bo obie wykonują to samo.

Mały przykładzik, robi to samo co poprzednio

$i = 10
While $i >= 0
MsgBox(0, "Odliczanie!", $i)
$i -= 1
WEnd

Długość kodu jest porównywalna, a jak pisałem, o tym dziwnym operatorze >= opowiem później.

Teraz pętla For...Next, która jest najbardziej... złożoną ale i w niektórych przypadkach niezastąpioną pętlą.

For {inicjalizacja} To {wartość} Step {interwał}
{instrukcje}
Next

Pojawiło się dużo nowych rzeczy, więc przechodzę do tłumaczenia.

Inicjalizacja to miejsce gdzie deklarujemy zmienną która będzie w tej pętli używana w taki sam sposób jak $i w przykładach z poprzednich pętli. Jest ona deklarowana jako lokalna w pętli For.

Wartość to próg wartości dla naszej zadeklarowanej zmiennej przy której pętla się zatrzyma. Czyli jak ustawimy ją na 10, a nasza zmienna będzie wyniesie 10 to pętla się zatrzyma.

Interwał to wartość która będzie dodawana lub odejmowana (zależy jakiego znaku użyjemy) do zmiennej $i po każdej iteracji pętli.

A oto przykład:

For $i = 10 To 0 Step -1
MsgBox(0, "Odliczanie!", $i)
Next

Da dum tsss...

Ten kod jak widać jest o wiele krótszy. A pętla For jest piekielnie przydatna kiedy mamy doczynienia z tablicami (wyższa szkoła jazdy :P)

Krótko mówiąc pętla For działa dopóki zmienna nie będzie miała danej wartości.

Prosta piłka.

Teraz opowiem trochę o operatorach nierówności

Operatory nierówności są używane zarówno w pętlach jak i w instrukcjach warunkowych.

Służą one do tego, żeby sprawdzić zależność między liczbą (ewentualnie całym działaniem) z lewej strony operatora a liczbą/działaniem z drugiej.

Piszę liczbą lub działaniem matematycznym, ale tak czy siak dla programu to będzie liczba którą sobie obliczy.

A oto nasze znaki:

= lub == - obie strony są równe (zalecam używanie tego drugiego bo np. w C++ użycie zwykłego = byłoby błędem)

< - Prawa strona jest większa od lewej

> - Lewa strona jest większa od prawej

<= - Prawa strona jest większa lub równa lewej

>= - Lewa strona jest większa lub równa prawej

<> - Obie strony są nierówne (w C++ jest to operator !=)

Wspominam o operatorach z C++ ponieważ są one identyczne w większości popularnych języków, i warto je umieć.

Jak widać nie jest to takie trudne jakie mogłoby być.

Przykładowa pętla z użyciem... znaku nierówności:

$i = 0
While $i <> 10
MsgBox(0, "Odliczanie!", $i)
$i += 1
WEnd

I jak widzimy program skończył się na liczbie 9. To dlatego że pętla zatrzymała się kiedy zobaczyła że warunek $i <> 10 jest fałszywy - zmienna $i wynosiła wtedy właśnie 10, a znak nierówności powoduje że nasz warunek jest prawdziwy dopóki $i ma każdą inną liczbę niż 10.

Żeby więc doliczyć do 10, na zdrowy rozsądek powinniśmy użyć operatora <=

$i = 0
While $i <= 10
MsgBox(0, "Odliczanie!", $i)
$i += 1
WEnd

I wszystko pięknie śmiga.

Zostały mi jeszcze do omówienia ContinueLoop i ExitLoop (w C++ odpowiednikami są continue i break)

ContinueLoop służy do przeniesienia się do następnej iteracji pętli, pomijając kod pod tym słówkiem.

Przykład:

$i = 0
While $i <= 10
   MsgBox(0, "Odliczanie!", $i)
   $i += 1
   ContinueLoop
   MsgBox(0, "", "lol")
WEnd

Jak widać, drugi MsgBox nigdy się nie wykona, bo jest po ContinueLoop.

ExitLoop służy do wyjścia z pętli.

$i = 0
While $i <= 10
   MsgBox(0, "Odliczanie!", $i)
   $i += 1
   ExitLoop
   MsgBox(0, "", "lol")
WEnd

I tutaj nie dość że znowu drugi MsgBox się nie wyświetli, to jeszcze program wyjdzie z pętli która dojdzie do momentu inkrementacji (czyli to $i += 1).

Obie rzeczy są zazwyczaj połączone z instrukcjami warunkowymi o których będzie w kolejnym rozdziale kursu, więc tak używane są zupełnie nieprzydatne, ale i tak o nich napisałem.

Została mi jeszcze do omówienia pewna anomalia.

Nieskończone pętle.

Nieskończona pętla to pętla, która nigdy się nie kończy (fuck logic)

Wbrew pozorom przydaje się do wielu rzeczy.

W AutoIT jest głównie używana żeby 'podtrzymać program przy życiu' - niedługo poznamy taki przykład

W innych językach jest też używana do gier. Idźmy za przykładem z początka rozdziału. W grach to co widzimy generuje właśnie nieskończona pętla.

Ale czy na pewno nieskończona?

Można z niej wyjść na dwa sposoby. Pierwszym jest zamknięcie programu. Drugim użycie ExitLoop połączonego z instrukcją warunkową.

Najlepszym kandydatem do stworzenia nieskończonej pętli jest While

While 1
   MsgBox(0, "lol", "to się będzie powtarzać w nieskończonosć")
WEnd

APO; żeby nasz program wyłaczyć 'na chama' to ma on ikonkę w trayu (koło zegarka)

Trzeba na nią kliknąć prawym przyciskiem i wybrać "Exit script".

Żeby się dowiedzieć czemu akurat taki warunek w pętli While, trzeba spojrzeć na jej opis i w poprzedni rozdział.

Wartością równoważną do True jest dowolna dodatnia lub ujemna liczba oprócz 0. A skoro warunek jest prawdziwy (True) i nie da rady go zmienić w żaden sposób to pętla wykonuje się w nieskończoność.

To tyle w temacie pętli.

Jak zwykle, jeśli coś pominąłem czy nie zrozumiałeś czegoś - pisz tutaj.

Phoenix_PL · 6 Stycznia 2013

IV. INSTRUKCJE WARUNKOWE

No to jedziemy z kolejną częścią.

Instrukcje warunkowe to kolejna podstawowa rzecz z jaką przyjdzie nam się zmierzyć.

Są one dwie, obie dosyć proste. Zaczynamy.

If...Then

To jest pierwsza instrukcja i zarazem najprostsza. Wygląda ona tak:

If [warunek]
[instrukcje]
EndIf

Jeśli ktoś nie wie co to warunek, to zapraszam do poprzedniej części (pętle - tam wszystko opisałem)

Prosta piłka, jeśli warunek jest prawdziwy to wykonywane są instrukcje, jeśli nie to ten 'if' jest omijany.

Przykładzik:

$i = 5
If $i == 5 Then
MsgBox(0, "Info", "Zmienna $i wynosi 5")
EndIf

W tym wypadku zostanie pokazany MsgBox, ale jeśli zmienimy wartość zmiennej $i to program po prostu nic nie zrobi.

Ale co zrobić jeśli chcemy żeby program wyświetlił nam MsgBoxa kiedy warunek nie jest prawdziwy?

Służy do tego Else

If [warunek]
[instrukcje jeśli jest prawdziwy]
Else
[instrukcje jeśli nie jest prawdziwy]
EndIf

Też jakże proste.

Mały przykładzik

$i = 5
If $i == 5 Then
MsgBox(0, "Info", "Zmienna $i wynosi 5")
Else
MsgBox(0, "Info", "Zmienna $i nie wynosi 5")
EndIf

Teraz kiedy zmienna nie wynosi 5, pokaże się nam stosowny MsgBox

A co kiedy chcemy zawrzeć kilka warunków w jednym Ifie?

Możemy teoretycznie zrobić kilka Ifów pod rząd, ale byłoby to wysoce nieprofesjonalne

Dlatego jest takie coś jak ElseIf

If [warunek] Then
[instrukcje]
ElseIf [warunek2] Then
[instrukcje2]
[...]
ElseIf [warunekN] Then
[instrukcjeN]
EndIf

Teraz, kiedy warunek w Ifie jest nieprawdziwy, to program przechodzi do ElseIfa. Tych ElseIfów możemy wstawiać dowolną ilość, ale musimy mieć pod uwagą dwie święte zasady:

- Kiedy w końcu jeden z warunków będzie prawdziwy, program ominie sprawdzanie reszty - po prostu zakończy Ifa

- Warunki sprawdzane są po kolei, tak jak je wymieniliśmy

Te dwie rzeczy czasem i mi przysparzały trudności kiedy zaczynałem, więc naprawdę trzeba je wziąć do serca.

Przykładem jest takie coś:

$i = 5
If $i == 5 Then
MsgBox(0, "Info", "Zmienna $i wynosi 5")
ElseIf $i > 4 Then
MsgBox(0, "Info", "Zmienna $i jest większa od 4")
EndIf

MsgBox że zmienna $i wynosi 5 nam się wyświetli, ale ten że $i jest większe od 4 (chociaż warunek jest prawdziwy) już nie.

Teraz przechodzimy do drugiej instrukcji - Switch

Wygląda ona tak:

Switch [zmienna]
Case [wartość] [to wartość]
[instrukcje]
Case [wartość2] [to wartość]
[instrukcje2]
[...]
Case [wartośćN] [to wartość]
[instrukcjeN]
EndSwitch

To jest nieco inna instrukcja.

Najpierw podajemy zmienną której wartości będą po Case. Jeśli zmienna ma wartość którą ustawiliśmy w Case, zostaną wykonane odpowiednie instrukcje.

Jest też słówko to które mówi w jakim zakresie liczbowym ma być sprawdzana zmienna.

Zamiast If-owego Else wstawiamy tutaj Case Else

Przykład wyjęty z Helpa:

Local $msg
Switch @HOUR
Case 6 To 15
 $msg = "Dzień dobry"
Case 16 To 21
 $msg = "Dobry wieczór"
Case Else
 $msg = "Co ty jeszcze robisz?"
EndSwitch

MsgBox(0, "Switch", $msg)

O tym co to @HOUR, napiszę w kolejnej części tuta.

Krótko mówiąc jest to makro przechowujące godzinę.

Istnieje tu też słówko ContinueCase, które przenosi instrukcje z poprzedniego Case do następnego Case.

Przykład:

$i = 10
Local $text
Switch $i
   Case 10
       $text = "Zmienna $i "
       ContinueCase
   Case 5
       $text &= "wynosi 10"
EndSwitch

MsgBox(0, "", $text)

I tutaj wszystko widać.

Skoro zmienna $i wynosi 10, pierwszy Case się wykonuje. A że w tym case mam ContinueCase które każe przejść do następnego Case, tak też się dzieje, chociaż warunek jest nieprawdziwy.

W Switchu też działają te dwie święte zasady z Ifa.

No cóż, tyle mam do powiedzenia.

Podstawowe instrukcje znacie, następny rodział będzie "bonusowy", czyli o paru rzeczach które też trzeba wiedzieć, ale i o ciekawostkach.

Jak zwykle - pominąłem coś lub nie rozumiesz - pisz tutaj.

Phoenix_PL · 13 Stycznia 2013

V. FUNKCJE

No dobrze, wracam z nowymi częściami tutka

Dzisiaj pogadam trochę o funkcjach, czyli kolejnej strukturze w AutoIT która jest piekielnie przydatna.

Funkcja to jest kawałek kodu który może być wywołany gdziekolwiek w programie.

Z gimbazjum wiemy że funkcja przyjmuje parametry. Powinna też zwracać jakąś wartość, ale nie jest to konieczne. Jeśli funkcja nie zwraca wartości, to jej poprawną nazwą jest "procedura", ale nie ma to większego znaczenia.

Funkcję, podobnie jak zmienną, trzeba zadeklarować, ale nie ma znaczenia w której części kodu. Może być obojętnie przed czy po jej wywołaniu. Zawartość funkcji wywoła się wyłącznie podczas jej wywołania, nie podczas deklaracji.

Tak wygląda przykładowa deklaracja funkcji:

Func funkcja($argument1, $argument2, $argument3, [...], $argumentN)
[kod funkcji]
EndFunc

Tak jak widać na załączonym obrazku. Co do nazewnictwa funkcji - tutaj małe i duże litery się nie liczą, funkcja "Funkcja" to to samo co funkcja "funkcja" czy "FUNKCJA"

Argumenty to zmienne które podawane są przy wywoływaniu funkcji. Każdą funkcję wywołuje się w ten sam sposób.

funkcja(12, 4)

To taki przykład, w którym do funkcji podaliśmy jako pierwszy argument liczbę 12 a jako drugi 4.

Oczywiście tak samo możemy podawać zmienne (ale MUSZĄ być one wcześniej zadeklarowane), liczby zmiennoprzecinkowe (gdzie zamiast przecinka umieszczamy kropkę) oraz ciągi znaków czy wartości logiczne.

Funkcją jest na przykład podany wcześniej MsgBox. Zawiera on 3 argumenty wymagane oraz 2 opcjonalne - razem 5 argumentów.

Pamiętasz pewnie jak wcześniej podawaliśmy do tej funkcji argumenty:

MsgBox (0, "Nazwa okna", "Tekst okna")

w Helpie oraz podpowiedzi składni opcjonalne parametry są podawane w kwadratowych nawiasach.

Żeby zadeklarować funkcję z opcjonalnymi parametrami nie możemy jednak ich umieścić w nawiasach. Wystarczy tylko zmiennym odpowiadającym za argumenty przypisać wartość w ten sposób:

Func funkcja($parametr1, $parametr2, $parametr3 = 12, $parametr4 = "lolz")

Tutaj widzimy że pierwsze dwa parametry są wymagane, a dwa ostatnie opcjonalne.

Czyli jeśli nie podamy ich wartości, to zostanie użyta wartość podana przy deklaracji, w tym wypadku 12 i lolz

Żeby użyć parametru w funkcji, wystarczy użyć nazwy zmiennej tego parametru. Czyli w powyższej funkcji żeby użyć wartości parametry $parametr1, należy użyć zmiennej $parametr1

A teraz w takim razie zadam pierwsze zadanie jakie w tym kursie będzie.

Stwórz funkcję która wyświetli MsgBoxa z flagą 0, ale z podanym przed użytkownika tekstem i nazwą okna.

Nazwa funkcji dowolna.

Odpowiedź w spoilerze

_msgbox("Nazwa okna", "Tekst okna")

Func _msgbox($nazwa_okna, $tekst_okna)
MsgBox(0, $nazwa_okna, $tekst_okna)
EndFunc

Prosta rzecz. Jedziemy dalej.

Z matematyki wiemy że zazwyczaj funkcja zwraca wartość. A żeby taką wartość zwrócić, używamy słówka Return.

Return [zwracana wartość]

Po użyciu tego słówka funkcja zostanie automatycznie przerwana, więc jeśli nie podamy wartości która ma zostać zwrócona, to funkcja zostanie przerwana i nie zwróci nic.

Wartość tej funkcji możemy zarówno zapisać w zmiennej jak i użyć jej 'bezpośrednio' - czyli jako parametr innej funkcji na przykład.

A teraz zrobimy funkcję, która zwróci nam kwadrat danej liczby.

Czyli po pierwsze, musimy stworzyć nową funkcję. Nazwijmy ją kwadrat.

Musimy też dać jej parametr który będzie zawierał liczbę która zostanie podniesiona do kwadratu.

Func kwadrat($liczba)

EndFunc

Okej, teraz musimy umieścić w niej działanie które podniesie liczbę do kwadratu.

Func kwadrat($liczba)
   Local $wynik = $liczba ^ 2
EndFunc

Jak zauważyłeś, zadeklarowałem zmienną w zakresie lokalnym. Będzie ona widoczna wyłącznie w funkcji.

I musi jeszcze zwrócić nam wartość tej funkcji. Czyli po działaniu musimy użyć "Return"

Func kwadrat($liczba)
   Local $wynik = $liczba ^ 2
   Return $wynik
EndFunc

Teraz możemy użyć tej funkcji np. w MsgBoxie

Func kwadrat($liczba)
   Local $wynik = $liczba ^ 2
   Return $wynik
EndFunc

MsgBox(0, "Kwadrat liczby 6", kwadrat(6))

Tadan! Możemy kombinować z innymi liczbami, ale za każdym razem funkcja zwróci nam kwadrat danej liczby.

Jeszcze tylko jedna uwaga dotycząca parametrów.

Kiedy jako parametr podajemy zmienną, jest tworzona jej kopia w zakresie funkcji. Czyli oryginalna zmienna jest nieruszona. Czasem przyda się jednak żeby modyfikować oryginalną zmienną. Przychodzi nam z pomocą słówko ByRef

Należy je postawić przed parametrem funkcji tak jak np. modyfikatory zasięgu (jednak nich nie możemy wstawić, bo parametry są zawsze deklarowane jako lokalne w funkcji)

Czyli modyfikując przykład z kwadratem funkcji - tak będzie wyglądać jeśli będziemy chcieli użyć oryginalnej zmiennej:

$liczba = 6

Func kwadrat(ByRef $num)
   $num = $num ^ 2
EndFunc

kwadrat($liczba)
MsgBox(0, "Kwadrat liczby", $liczba)

Tym razem jest troszkę dłużej, ale efekty takie same.

Teraz musimy zmienić wartość $liczba żeby zmienić wartość argumentu funkcji.

A dzięki ByRef nasza zmienna zostaje zmieniona. Gdybyśm teraz usuneli to słówko albo wywalili wywołanie funckji, to MsgBox zwróciłby wartość $liczba podaną przy deklaracji, a funkcja byłaby bezużyteczna.

A jeśli wsadzilibyśmy wywołanie funkcji (kwadrat($liczba)) w MsgBoxa, tak jak wcześniej to MsgBox zwróciłby 0, czyli domyślną wartość funkcji która nic nie zwraca.

No, to by było na tyle. Jak zwykle, jeśli czegoś nie rozumiesz albo coś ominąłem to pisz.

Phoenix_PL · 16 Stycznia 2013

VI. GUI, część I

Naszedł czas na pomówienie trochę o tym cudnym wynalazku. GUI to skrót od Graphical User Interface, i najprościej mówiąc okienko programu w którym znajdują się przyciski, pola do wpisywania tekstu i reszta tego typu rzeczy. GUI może być dowolnie modyfikowane, można zmieniać style, obrazki, wygląd prawie wszystkiego - wystarczy umieć.

W AutoIT są stworzone specjalne biblioteki (biblioteka w AutoIT to UDF - User Defined Functions) do obsługi GUI. Dołącza się je za pomocą dyrektywy #include.

Jeśli biblioteka znajduje się w folderze [AutoIT]/Includes ([AutoIT] to miejsce instalacji AutoITa), to używamy jej w ten sposób:

#include <NazwaBiblioteki.au3>

lub, jeśli biblioteka jest w folderze z naszym skryptem:

#include "NazwaBilbioteki.au3"

Aczkolwiek użycie pierwszego sposobu może się tyczyć obu przypadków (kiedy UDF jest zarówno w naszym folderze, jak i w folderze AutoITa)

Wracając, jak wygląda takie przykładowe GUI? Mamy przykładowy plik z GUI dołączony z AutoITem.

Znajduje się on w pliku [AutoIT]\Examples\GUI\SampleControls.au3

Możemy to otworzyć i zobaczyć jak to wygląda.

W każdym razie - jak zrobić takie GUI? Są dwa sposoby.

Pierwszym jest klepanie GUI ręcznie - kontrolka po kontrolce. Ale komu by się chciało tak klepać.

Drugim sposobem jest KODA - edytor GUI wbudowany w AutoITa (o ile zainstalowaliśmy SciTE oddzielnie )

Żeby uruchomić KODA musimy:

- Mieć w SciTE otwarty jakiś plik .au3

- Kliknąć Alt+M

Jeśli mamy akurat otwarte okienko konsoli błędów, wyświetli nam się takie coś:

>"C:\Program Files\AutoIt3\SciTE\Koda\FD.exe" /Scite

W każdym razie, po otwarciu KODA mamy takie oto okienko:

No dobrze, a teraz co oznaczają kolorki:

Na czerwono zaznaczyłem przyciski do otwierania/zapisywania formatek, tworzenia nowej formatki oraz pokazania kodu aktualnej.

Na zielono zaznaczyłem kontrolki do umieszczenia na formatce. Są podzielone w odpowiednie grupy.

Na żółto zaznaczyłem naszą formatkę, czyli okienko GUI na którym możemy umieszczać kontrolki.

Na fioletowo zaznaczyłem Obiect TreeView, czyli drzewko kontrolek na formatce które umieściliśmy

Na jasnoniebiesko zaznaczyłem listę aktualnie otwartych form

Na niebiesko zaznaczyłem Obiect Inspectora który zawiera właściwości aktualnego obiektu czy naszej formatki

Skoro wiemy już co gdzie jest, to wytłumaczę może znaczenie paru właściwości:

Caption - Napis na naszym obiekcie (przycisku, formie na przykład)

ClientWidth/Height - szerokość/wysokość obiektu.

Width/Height - to samo, w sumie różnicy nie widzę.

Color - Kolor kontrolki. Tutaj ułatwieniem jest fajna rozwijana lista z dostępnymi kolorami.

Cursor - Kursor jaki zostanie przybrany po najechaniu na kontrolkę. Tak jak wyżej, mamy fajną listę.

Enabled - Określa czy kontrolka jest aktywna (True) czy nieaktywna (False) po jej utworzeniu.

Font - Czcionka napisów kontrolki. Po kliknięciu na przycisk z '...' pokaże nam się okienko w którym możemy modyfikować wszystko jak chcemy.

Hint - Podpowiedź która zostanie wyświetlona jako tooltip po najechaniu na kontrolkę.

Name - To jest nazwa kontrolki w programie, tak będzie nazwana jej zmienna (więc nazwa nie może zawierać polskich znaków ani spacji)

Visible - Określa czy kontrolka ma być widoczna (True) czy niewidoczna (False) po jej stworzeniu.

Wszystkie właściwości danej kontrolki/formatki możemy zmienić rzecz jasna podczas działania programu za pomocą odpowiednich funkcji.

A teraz stworzymy nasze pierwsze prawdziwe GUI.

Umieśćmy na nim dwa przyciski, dowolnie. Możemy też zmniejszyć naszą formatkę, bo niepotrzebna nam taka wielka.

Przyciski znajdują się na pierwszej zakładce, 6 ikonka od lewej (wliczając myszkę).

Możemy te przyciski też trochę rozciągnąć.

Kiedy robimy jakiś większy projekt, warto sobie rozrysować na papierze nasze GUI, żeby się nie pogubić.

Kiedy już ustawimy nasze przyciski, zmieniamy nazwę, napis na przyciskach.

Żeby to zrobić klikamy na przycisk, szukamy odpowiedniej pozycji w okienku Obiect Inspector i zmieniamy ją.

Pierwszy przycisk niech się nazywa PrzyciskKlik, drugi PrzyciskKoniec.

Napisy na nim ustawiamy dowolnie, domyślnie są takie same jak nazwa przycisku.

Zmieniamy też nazwę formatki na Tutorial oraz tak samo napis na niej.

Dobrze, mamy nasze GUI. Ale co mamy zrobić żeby dostać jego kod? Kliknąć F9.

Pokaże nam się okienko z kodem GUI. Możemy wszystko skopiować i wkleić do SciTE, albo kliknąć przycisk "Insert to SciTE", który sam nam wpisze wszystko do aktualnie otwartego pliku.

Mi wyszło coś takiego:

#include <GUIConstantsEx.au3>

#Region ### START Koda GUI section ### Form=
$Tutorial = GUICreate("Tutorial", 149, 74, 192, 114)
$PrzyciskKlik = GUICtrlCreateButton("Kliknij!", 8, 8, 131, 25)
$PrzyciskKoniec = GUICtrlCreateButton("Koniec!", 8, 40, 131, 25)
GUISetState(@SW_SHOW)
#EndRegion ### END Koda GUI section ###

While 1
$nMsg = GUIGetMsg()
Switch $nMsg
	Case $GUI_EVENT_CLOSE
		Exit

EndSwitch
WEnd

Na początku są #include naszego GUI. I od razu mówię że większość nam nie będzie potrzebna.

Najważnieszą biblioteką jest GuiConstantsEx.au3, która zawiera stałe zawierające np. ID niektórych specjalnych przycisków, czy tego typu rzeczy. W każdym razie, usuwamy wszystkie biblioteki oprócz niej. Jeśli będziemy potrzebowali czegoś z innych bibliotek, dopiero wtedy je dołączajmy, ponieważ każdy UDF w pewnym stopniu zaśmieca kod.

Ale o tym później, po prostu usuwamy wszystkie #include oprócz tego z GuiConstantsEx.au3

Niżej mamy dyrektywy #region i #endregion. One służą... niczemu. Są używane wyłącznie do porządkowania kodu.

Między tymi dyrektywami jest nasz kod GUI, czyli tworzenie wszystkich kontrolek.

Jak pewnie zauważyłeś, do każdej funkcji jest podpięta zmienna. Ta zmienna trzyma ID kontrolki i tą zmienną podajemy jeśli chcemy cokolwiek zrobić z danym obiektem na GUI. Jest to po prostu odnośnik do tego elementu.

Niżej jest nieskończona pętla. Mówiłem w części o pętlach, że ten typ pętli będzie przydatny przy GUI - podtrzymuje je przy życiu razem z programem. W innym wypadku GUI by tylko mignęło i zniknęło.

A co jest w pętli? To jest mózg GUI. Funkcja GUIGetMsg zwraca ID naciśniętej kontrolki, które jak wiemy jest trzymane w zmiennej tej kontrolki. Jeśli żadna kontrolka nie została naciśnięta, zwraca 0. W Switchu podajemy przy Case zmienną danej kontrolki, a pod Case piszemy instrukcje które się wykonają jeśli dana kontrolka zostanie wciśnięta. Proste.

Krótko mówiąc, działa to w ten sposób:

GUIGetMsg zwraca ID kontrolki. Switch sprawdza po kolei czy ID zwrócone przez GUIGetMsg pasuje do podanego przy danym Case ID ze zmiennej. Jeśli pasuje, wykonuje się instrukcja po danym Case.

Jeszcze pytanie - co to $GUI_EVENT_CLOSE?

Ta zmienna jest z biblioteki GuiConstantsEx, i ta zmienna zawiera ID przycisku 'x' na belce formatki (tego w górnym prawym rogu okienka). Podpowiem że jest to -3, ale dla czytelności kodu lepiej użyć zmiennej.

Dodatkowo automatycznie pod Case jest funkcja Exit, która zamyka program.

Skoro już wszystko wiemy, teraz praktyka.

Do przycisku PrzyciskKlik przypisz MsgBoxa, a do PrzyciskKoniec funkcję Exit.

Rozwiązanie:

While 1
$nMsg = GUIGetMsg()
Switch $nMsg
	Case $GUI_EVENT_CLOSE
		Exit
	Case $PrzyciskKlik
		MsgBox(0, "Klik!", "Bu!")
	Case $PrzyciskKoniec
		Exit
EndSwitch
WEnd

Jak widzimy wszystko działa

Znamy teraz jeden sposób na przypisanie czynności do kontrolki. Jest jednak drugi, zapewne mniej pamięciożerny (nie używa pętli) i dla niektórych prostszy. Tryb OnEvent.

Polega on na najprostszym przypisaniu naszej funkcji do przycisku. Najpierw trzeba go uruchomić. Czyli tuż przed GUI wstawiamy takie cuś:

Opt("GuiOnEventMode", 1)

Opt to funkcja która ustawia opcje dla całego programu - po listę tych opcji zapraszam do helpa.

Żeby przypisać jakąś funkcję do kontrolki, używamy tej funkcji:

GUICtrlSetOnEvent($uchwyt, "funkcja")

A żeby przypisać taki przycisk jak nasz $GUI_EVENT_CLOSE musimy użyć

GUISetOnEvent($uchwyt, "funkcja")

I nic więcej. Jedynie zamiast naszej pętli z GUIGetMsg wsadzamy taką pętlę:

While 1
Sleep (100)
WEnd

Ale nasza funkcja musi spełniać pewien warunek. Nie może potrzebować żadnych parametrów. Czyli musi być to procedura. Dlatego podajemy samą nazwę funkcji.

No dobrze, a jak to wygląda w praktyce?

Poniższy kod to to samo co poprzedni kod, tylko z użyciem OnEvent:

#include <GUIConstantsEx.au3>

Opt("GuiOnEventMode", 1)
#Region ### START Koda GUI section ### Form=
$Tutorial = GUICreate("Tutorial", 149, 74, 192, 114)
$PrzyciskKlik = GUICtrlCreateButton("Kliknij!", 8, 8, 131, 25)
$PrzyciskKoniec = GUICtrlCreateButton("Koniec!", 8, 40, 131, 25)
GUICtrlSetOnEvent($PrzyciskKlik, "Klik")
GUICtrlSetOnEvent($PrzyciskKoniec, "Koniec")
GUISetOnEvent($GUI_EVENT_CLOSE, "Koniec")
GUISetState(@SW_SHOW)
#EndRegion ### END Koda GUI section ###

Func Klik()
MsgBox(0, "Bu!", "Klik!")
EndFunc

Func Koniec()
Exit
EndFunc

While 1
Sleep (100)
WEnd

Cała filozofia.

W następnej części tuta powiem jeszcze więcej o GUI, czyli jak odczytywać wartości od kontrolek, jak zmieniać ich style i tego typu duperele.

Phoenix_PL · 3 Lutego 2013

Tymczasowo muszę zawiesić tutoriala z powodu nauki (gimbaza :<) i tego, że szlag trafił sporą część kolejnej części po reinstalce windowsa.

Postaram się to po trochu pisać, ale cudów nie będzie ._.

//dziękuję nieznanemu moderatorowi/adminowi za clean tematu

Phoenix_PL · 7 Lutego 2013

VII. GUI, część II

Witam po dłuższej przerwie w drugiej części tutoriala o GUI. Tutaj opiszę trochę przydatnych funkcji do obsługi naszego interfejsu.

Odczytywanie/Zapisywanie wartości kontrolki

Podstawowa czynność. Służą do tego dwie funkcje.

Do odczytywania wartości służy funkcja GUICtrlRead

GUICtrlRead($uchwyt)

$uchwyt - uchwyt do kontrolki

Do zapisywania zaś służy GUICtrlSetData

GUICtrlSetData($uchwyt, "dane")

$uchwyt - uchwyt do kontrolki

"dane" - dane do zapisu

Odczytać i zapisać wartość możemy praktycznie do wszystkiego co ma tekst, czyli inputy, przyciski, labele, editboxy i checkboxy czy radioboxy, zazwyczaj te funkcje zwracają tekst z kontrolek. Wyjątkiem jest Progressbar, te funkcje ustawiają i odczytują jego wartość (od 0 do 100).

A teraz trochę praktyki. Zrób GUI z dwoma przyciskami i inputem, a następnie do jednego przycisku przypisz instrukcje odczytujące co zostało zapisane w inpucie (i wyświetlające to), a do drugiego przycisku przypisz funkcję która ustawi tekst w inpucie na na przykład "Tutorial".

Możesz jeszcze zrobić sprawdzanie czy wogóle jest coś napisane w inpucie, dosyć prosta rzecz.

Porównaj swój kod z tym:

#include <GuiConstantsEx.au3>
 
Opt ("GuiOnEventMode", 1) ;tryb OnEvent
 
$GUI = GUICreate("GUI", 187, 63, 192, 124)
$bZapis = GUICtrlCreateButton("Zapis", 8, 32, 75, 25)
$bOdczyt = GUICtrlCreateButton("Odczyt", 104, 32, 75, 25)
$inTekst = GUICtrlCreateInput("", 8, 8, 169, 21)
 
GUISetOnEvent($GUI_EVENT_CLOSE, "koniec")
GUICtrlSetOnEvent($bZapis, "Zapis")
GUICtrlSetOnEvent($bOdczyt, "Odczyt")
 
GUISetState(@SW_SHOW)
 
Func koniec() ;funkcja zamykająca program
    Exit
EndFunc
 
Func Zapis() ;funkcja zapisująca tekst do inputa
    GUICtrlSetData($inTekst, "Tutorial") ;jak widać jest to prosta rzecz - jedna linijka kodu
EndFunc
 
Func Odczyt() ;funkcja odczytująca tekst z inputa
    Local $tekst = GUICtrlRead($inTekst) ;odczytanie tekstu - pamiętajmy zeby tą zmienną zadeklarować jako lokalną, program będzie zarł mniej pamięci
 
    If $tekst = "" Then ;a tutaj sprawdzam czy przypadkiem input nie jest pusty
        MsgBox(16, "Błąd!", "Nic nie zostało wpisane!")
        Return
    EndIf
 
    MsgBox(64, "Tekst z inputa:", $tekst) ;i ostatecznie wypisuję tekst
EndFunc
 
While 1
    Sleep (100)
WEnd

Tyle, prosta rzecz. Idziemy dalej

Odczytywanie/Ustawianie statusu kontrolek

Status kontrolki mówi nam na przykład czy checkbox jest aktualnie wciśnięty, czy button jest aktywny, itp. Do odczytu statusu służy funkcja GUICtrlGetState

GUICtrlGetState($uchwyt)

$uchwyt - uchwyt do kontrolki

Zaś do ustawienia statusu służy GUICtrlSetState

GUICtrlSetState($uchwyt, $status)

$uchwyt - uchwyt do kontrolki

$status - zmienna statusu jaki chcemy ustawić

Statusy dla przejrzystości kodu są zapisane w stałych w pliku GUIConstantsEx.au3. Lista wszystkich statusów znajduje się w helpie, pod funkcją GUICtrlSetState.

Tutaj nie będzie ćwiczenia, ponieważ mój AutoIT świruje... Cóż, przeanalizujcie sobie ten kod i spróbujcie odpalić, powinien zadziałać...

#include <GuiConstantsEx.au3>
 
Opt("GuiOnEventMode", 1)
 
$GUI = GUICreate("GUI", 130, 74, 192, 124)
$bTroll = GUICtrlCreateButton("Troll", 8, 8, 115, 25)
$bKlik = GUICtrlCreateButton("Kliknij!", 8, 40, 115, 25)
 
GUISetOnEvent($GUI_EVENT_CLOSE, "koniec")
GUICtrlSetOnEvent($bTroll, "Troll")
GUICtrlSetOnEvent($bKlik, "Klik")
 
GUISetState(@SW_SHOW)
 
Func koniec()
    Exit
EndFunc
 
Func Klik()
    Local $state = GUICtrlGetState($bTroll) ;pobranie statusu kontrolki
 
    If $state = $GUI_HIDE Then ;sprawdzenie czy kontrolka jest niewidoczna
        GUICtrlSetState($bTroll, $GUI_SHOW) ;uwidocznienie kontrolki
    Else
        GUICtrlSetState($bTroll, $GUI_HIDE) ;schowanie kontrolki
    EndIf
 
    ;$GUI_SHOW wynosi 16, $GUI_HIDE - 32
    ;Mi jakims dziwnym trafem wywala 80 przy widocznej kontrolce, 96 przy schowanej... wtf?
    ;Wstaw msgboxa przed ifem i sam się przekonaj o tej 'anomalii'
EndFunc
 
Func Troll()
    MsgBox(0, "w00t", "tutorial by Phoenix_PL")
EndFunc
 
While 1
    Sleep (100)
WEnd

Jedziemy dalej...

Style

Style umożliwiają nam zmianę właściwości kontrolki. Zazwyczaj są ustawiane przy jej tworzeniu, jako parametry po współrzędnych kontrolki, ale można też je ustawić podczas działania programu. Służy do tego funkcja GUICtrlSetStyle

GUICtrlSetStyle($uchwyt, $styl)

$uchwyt - uchwyt do kontrolki

$styl - zmienna ze stylem

Funkcji odczytującej styl nie ma, ponieważ dla większości kontrolek jest ustawione kilka stylów naraz, więc jest bezużyteczna.

Dlaczego bezużyteczna? Dlatego, że style to są liczby. Odpowiednia liczba to odpowiedni styl. A przecież nawet jak kontrolka będzie mieć tylko dwa style, to kombinacji jest i tak mnóstwo - nie odwrócisz dodawania.

A przy okazji dodawania - jak połączyć style?

Służy do tego funkcja BitOR. Szczerze mówiąc to nie wiem dokładnie jak ta funkcja działa, oprócz tego że wykonuje operacje na bitach. Jeśli ktoś byłby skłonny wyjaśnić, byłbym wdzięczny.

Ale wracamy do tematu. Lista styli również jest w helpie, w Spisie Treści wchodzimy do folderu Appendix i wybieramy GUI Control Styles.

Tam mamy tabelę ze stylami oraz bibliotekami w których te zmienne się znajdują.

(KODA dodaje nam do kodu właśnie te biblioteki ze stylami dla każdej kontrolki jaką wsadzimy w GUI)

No cóż, niewiele tu do tłumaczenia.

Jeszcze tylko szybki opis reszty funkcji do ustawiania różnych pierdółek w GUI:

GUICtrlSetBkColor - ustawia kolor tła kontrolki

GUICtrlSetColor - ustawia kolor kontrolki (czyli na przykład napisów na labelu)

GUICtrlSetCursor - ustawia jaki kursor ma się pojawić kiedy myszka pojawi się nad kontrolką.

GUICtrlSetFont - Ustawia czcionkę tekstu kontrolki

GUICtrlSetGraphic - (NIE MYLIĆ Z GUICtrlSetImage!) - służy do rysowania po kontrolce Graphic (GUICtrlCreateGraphic)

GUICtrlSetImage - ustawia grafikę kontrolki

GUICtrlSetPos - Ustawia pozycję kontrolki

Jeszcze jedna uwaga: Jeśli chcemy te rzeczy zrobić z GUI, a nie z kontrolkami, wystarczy sprawdzić czy dana funkcja bez Ctrl istnieje w Helpie i jej użyć.

Przykładowo, jest funkcja GUICtrlSetBkColor. Dla GUI jest to funkcja GUISetBkColor.

To tyle na tą część. W następnej części opiszę tablice, a więc i skończę podstawy AutoITa. Jak zwykle - jeśli macie jakieś problemy lub czegoś nie rozumiecie, albo chcecie żebym coś opisał - piszcie tutaj, na GG albo na PW - postaram się pomóc.

MacroMAN · 14 Lutego 2013

Bardzo dobry poradnik. Brakuje Tablic i troche o programowaniu obiektowym [jeśli tak to można nazwać].

Phoenix_PL · 16 Lutego 2013

Spokojnie, jeszcze to wszystko będzie, problem jest taki że tymczasowo w domu nie mam internetu, więc nie mogę wstawić nowych części.

MagicznyKrzys · 26 Kwietnia 2013

Ogólnie to całkiem spoko tut :P

Phoenix_PL · 4 Maja 2013

VIII. TABLICE

Witam po dłuższej przerwie, i tą częścią tutoriala kończę serię "dla zielonych". Po przeczytaniu tej części będziesz wiedział wszystko, co będzie ci potrzebne do pisania porządnych programów.

Co to tablica?

Tablica to zmienna. Duża zmienna. Zawierająca tak zwane indeksy i wymiary. Każdy wymiar ma określoną ilość indeksów.

Indeksy, wymiary, taka sytuacja.

Indeksy w tablicy są jak komórki w arkuszu kalkulacyjnym (takim jak w excelu).
Zwykłą tablicę jednowymiarową (o wymiarach za moment) można przedstawić tak:

Indeksy zaczynają się od 0, i może być ich w jednej tablicy maksymalnie 2^24 (16 777 216) (oczywiście we wszystkich wymiarach tablicy)
W jednym indeksie może być zawarty tekst, liczba, cokolwiek co w normalnej zmiennej. Każdy indeks w tablicy to osobna zmienna.

Wymiary w tablicy są jak wymiary w grze. Dwuwymiarowa tablica to taka która posiada wysokość i szerokość. W rzeczywistości przedstawia się tak:

Szachownica. Gdyby indeksów było więcej, można by to uznać za mapę gry 2D.

Tablicę 3D, czyli z trzema wymiarami można przedstawić jako sześcian. Tablic cztero- i więcej-wymiarowych nie da się przedstawić za pomocą żadnej figury geometrycznej. Tablica może mieć maksymalnie 64 wymiary.

Po co tablice?
Ano po to, że tablice są świetne do przechowywania większej ilości danych. Zamiast tworzyć pierdyliard zmiennych, robimy tablicę, wpisujemy jaką ma mieć wielkość i voila.

I jeszcze jedno, Tablica nie ma takiej wielkości jaką podaliśmy przy jej tworzeniu. Tzn. jeśli podaliśmy że tablica ma mieć 5 indeksów, ostatni indeks będzie miał numer 4. Dlaczego? Dlatego, że indeksy są liczone od 0. Czyli tak naprawdę jest 5 indeksów: 0; 1; 2; 3; 4. To jest często robiony przez początkujących błąd, więc radzę się tego nauczyć.

A teraz trochę praktyki.

Tablica w AutoIT wygląda następująco:

Local $tablica[3]

Czyli żeby stworzyć tablicę, musimy podać jej zasięg, nazwę i wielkość. W tym wypadku tablica ma zasięg lokalny, i ma tylko 3 indeksy.
Akurat tablice należy zawsze deklarować przed jej użyciem, dlatego jest wymagany taki zapis przed jej użyciem.

Tablice wielowymiarowe deklaruje się w ten sposób:

Local $tablica_2d[3][3] ;tablica 2-wymiarowa Local $tablica_3d[3][3][3] ;tablica 3-wymiarowa;itd.

Schemat tablicy 2D jest wyjaśniony powyżej, tablica 3D to taki sześcian, każdy indeks to mały kwadracik w tym sześcianie, wystarczy że masz dobrą wyobraźnię i możesz sobie to wyobrazić

A jak zapisać coś do tablicy? Tak jak przy zmiennych, są dwa sposoby. Inicjalizacja oraz klasyczny zapis danych.

Inicjalizacja to jak pewnie pamiętasz zapis danych do zmiennej przy jej deklaracji. W wypadku tablic ten proces jest nieco bardziej skomplikowany. Schematycznie wygląda on tak:

Local $tablica[3] = ["element0", "element1", "element2"]

Numer elementu w tym wypadku odpowiada jego indeksowi. Czyli element0 będzie w indeksie 0, element 1 w indeksie 1, element 2 w indeksie 2. Indeksu 3 rzecz jasna nie ma.

Klasyczny sposób zapisu danych wygląda tak:

Local $tablica[3] $tablica[indeks] = "element"

Prościzna.

Odczyt danych z tablicy

Odczytywanie ogranicza się do podania nazwy i indeksu tablicy, jeśli chodzi o pojedynczy element.

Local $tablica[3] = ["jeden", "dwa", "trzy"] MsgBox(0, "Indeks 1", $tablica[1])

MsgBox powinien wyświetlić wiadomość "dwa"

Jeśli chodzi o odczytywanie danych z całej tablicy, to mamy kilka opcji.
Pierwszą z nich jest użycie _ArrayDisplay z biblioteki Array.au3 (zawiera ona przydatne funkcje przy pracy z tablicami; polecam przejrzeć je w helpie)

#include <Array.au3>Local $tablica[3] = ["jeden", "dwa", "trzy"] _ArrayDisplay($tablica)

W ten sposób wyświetlamy ładną tabelkę z zawartością naszej tablicy.

Drugą i trzecią opcją zajmiemy się za chwilę

Masowe zapisywanie/odczytywanie danych do/z tablicy

Przechodzimy do najważniejszej części tego tutoriala, bo tego co tutaj opiszę będziesz używał najczęściej.

Do masowego odczytywania i zapisywania danych służy pętla. Pętla For

Masowe zapisywanie wygląda następująco:

#include <Array.au3>Local $tablica[10] For $i = 0 To UBound($tablica)-1 Step +1   $tablica[$i] = Random(0, 100, 1)Next _ArrayDisplay($tablica)

Ten kod zapisuje do 10-cio indeksowej tablicy losowe cyfry. Bardzo praktyczne, bo nieciekawie by było klepać linijka po linijce te same polecenia każde do osobnej zmiennej.

Funkcja UBound to funkcja która zwraca wielkość tablicy, taka jaką podaliśmy przy jej tworzeniu. Stąd to -1.

Masowe odczytywanie wygląda podobnie, ale są na to dwa sposoby.
Pierwszy, wygląda tak samo jak powyższy, również pętla for...to

Local $tablica[10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] For $i = 0 To Ubound($tablica)-1 Step +1   MsgBox(0, "Indeks "&$i, $tablica[$i])Next

Drugi sposób nie wymaga UBound, jest znacznie prostszy. Pętla Foreach, czyli w AutoIT For...In

Local $tablica[10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] For $element In $tablicaMsgBox(0, "For...In", $element)Next

Jedyny minus to to, że nie mamy czegoś w stylu zmiennej $i. Dlatego czasem praktyczniej użyć klasycznego For-a

Cóż, to by było na tyle. Nic dodać, nic ująć. Jeśli o czymś zapomniałem, czegoś nie opisałem, lub zwyczajnie czegoś nie rozumiesz to pisz w tym temacie, postaram się wyjaśnić.

To, że to jest ostatnia część tutoriala "Dla zielonych" nie oznacza że go skończyłem. Będę jeszcze pisał o AutoIT-owych ciekawostkach. Ale to później. Tyle, dziękuję za uwagę i powodzenia w programowaniu.

aleklejawa · 5 Maja 2013

@up Świetny TuT ładnie wytłumaczyłeś rozwijaj i dodawaj te ciekawostki szybko bo jestem żądny wiedzy

.FeNix · 8 Maja 2013

Co radzicie na początek się uczyć? autoit czy c++?

tutek świetny chociaż go nie rozumiem + leci

Zkumeku · 8 Maja 2013

Co radzicie na początek się uczyć? autoit czy c++?

tutek świetny chociaż go nie rozumiem + leci

AutoIt prostszy, ale C++ popularniejszy i ma więcej możliwości.

Phoenix_PL · 8 Maja 2013

@2up, czego w nim nie rozumiesz ?

Na początek polecam AutoIT bo uczysz się podstaw programowania, algorytmiki, itp. a przy okazji jest bardzo przydatny do pisania programów "na szybko" oraz ułatwiania sobie życia :P

Potem C# i C++. Jednak C++ polecam tylko do robienia cheatów albo pisania gier, bo resztę zrobisz w C# który jest nieco łatwiejszy.

.FeNix · 8 Maja 2013

no właśnie nie wiem czemu to napisałem, że nie rozumiem ;p ale dzięki za odpowiedź od jutra poduczę się AutoIT jak skończę zacznę C++

metin1998 · 11 Maja 2013

co do wielowątkowości to AdlibRegiester oddaję ją w marnym stopniu, to co oferuje można sobie zaimplementować i bez tej funkcji...

A to do czego naprawdę potrzebna jest wielowątkowość jest wciąż niedostępne w autoit (afaik)

Phoenix_PL · 11 Maja 2013

CIEKAWOSTKI W AUTOIT

"wielolinijkowość" i makra

Witam w pierwszej części AutoITowych ciekawostek. Dzisiaj opowiem trochę o tak zwanej "wielolinijkowości" oraz makrach w AutoIT.

WIELOLINIJKOWOŚĆ

Bajer znany z praktycznie wszystkich popularnych języków programowania. Piszemy kawałek tekstu tutaj, niżej kolejny kawałek, jeszcze niżej kolejny. Chociaż niewielu o tym wie i tego używa, taki bajer można też zrobić w AutoIT.

Służy do tego znak _ (podkreślnik). Dzięki niemu kompilator uzna dwie (lub więcej) linijki tekstu za jedną i połączy je podczas kompilacji.

Taki mały przykład użycia:

MsgBox(0, _
"Lol", _
"Lol2")
 
;identyczny kod, tylko w jednej linijce:
MsgBox(0, "Lol", "Lol2")

Jednak są pewne zasady i ograniczenia tego znaku. Poniżej wyjaśnię kilka.

Po pierwsze; między _ a ostatnim znakiem kodu musi być spacja. Przykładowo

MsgBox(0,_
"Lol", "Lol2") ;to jest błędny zapis
 
MsgBox(0, _
"Lol", "Lol2") ;a to prawidłowy

Po drugie; Jeśli chodzi o wielolinijkowy zapis tekstu to wygląda on tak:

$tekst = "Lol"& _
"Trololol"& _
"Huehue" ;prawidłowy zapis
 
$tekst = "Lol" _
"Trololol" _
"Huehue" ;nieprawidłowy zapis

Musimy wstawić te znaki &, bo pamiętajmy że kompilator łączy to w całość więc ten kod po kompilacji wygląda tak:

$tekst="Lol"&"Trololol"&"Huehue"

a nieprawidłowy

$tekst="Lol""Trololol""Huehue"

Nie możemy też rozdzielać deklaracji tablicy oraz ich wielkości, czyli takiej sztuczki

$tablica _
[12]

Ale możemy tego użyć żeby rozdzielać inicjalizowaną zawartość tej tablicy

$tablica[5] = [ _
"element1", _
"element2", _
"element3", _
"element4", _
"element5"]

Pamiętajmy że nie możemy tym znakiem rozdzielać np. nazw funkcji czy zmiennych. Zrobienie takiego czegoś:

$Zmie _
nna

lub takiego

Msg _
box(0, "lul", "lu")

jest czystą głupotą x)

Tego znaku możemy używać do:

- Rozdzielania tekstu (jak wyżej)

- Rozdzielania parametrów funkcji (jak wyżej)

- Rozdzielania warunków w instrukcjach warunkowych oraz pętlach

- Łączenia inicjalizowanej zawartości tablic (jak wyżej)

itepe, itede, zachęcam do kombinowania

MAKRA

Makra to zmienne które w większości są zależne od środowiska w jakim pracuje program, ale niektóre są zależne od operacji wykonywanych w programie.

Dzisiaj opowiem trochę jakie są makra i do czego służą.

Makro to taka zmienna predefniowana przez kompilator (jak w PHP). Nie można deklarować ich ani zmieniać ich zawartości tak jak normalnym zmiennym (ale i od tego są wyjątki). Wygląda ona tak:

@nazwa_makra

Jak napisałem, makro jest "tylko do odczytu". Teraz podam kilka przykładów makr.

Istnieją makra ścieżek, środowiskowe oraz programowe. Tych pierwszych jest najwięcej, prowadzą one do ścieżek na komputerze na którym program jest uruchamiany, czyli np. do ścieżki pulpitu, moich dokumentów, itp.

Zawierają one tekstowy zapis pełnej ścieżki na dysku do danego folderu (UWAGA: bez \ na końcu.).

Czyli na przykład u mnie makro @DesktopDir po wyświetleniu w MsgBoxie wygląda tak:

Tutaj lista wszystkich makr ścieżek:

@AppDataDir - Folder "Dane Aplikacji", w Win7 "AppData\.roaming"

@DesktopDir - Pulpit

@MyDocumentsDir - Moje dokumenty

@FavoritesDir - Ulubione

@ProgramsDir - Wszystkie Programy w Menu Start

@StartMenuDir - Menu Start

@StartupDir - Autostart (programy uruchamiane przy odpaleniu komputera)

@UserProfileDir - Profil usera, np. C:\Users\Admin czy C:\Documents and Settings\Admin)

Po dodaniu "Common" przed "Dir" w tych makrach zostanie wyświetlona dana ścieżka dla wszystkich userów na komputerze (All users)

Inne ścieżki:

@HomeDrive - Litera dysku na którym jest zainstalowany system

@HomePath - Ścieżka do profilu aktualnie zalogowanego użytkownika, bez litery dysku. W połączeniu z @HomeDrive wychodzi @UserProfileDir.

@ProgramFilesDir - Folder Program Files

@WindowsDir - Folder Windows

@SystemDir - Folder system32

@TempDir - Folder Temp

Po pełną listę makr odsyłam do F1

Makra środowiskowe to makra programu oraz środowiska na którym są uruchomione (ścieżka programu, system, architektura procesora, itp.)

Lista wszystkich makr środowiskowych:

Lista makr dotyczących naszego programu:

@ScriptDir - Folder z którego został uruchomiony nasz program.

@ScriptName - Nazwa naszego skryptu (pliku .exe)

@ScriptFullPath - Ścieżka do naszego skryptu (połączenie @ScriptDir i @ScriptName)

@AutoItExe - Ścieżka do kompilatora który uruchomił nasz skrypt. Dla skompilowanego skryptu będzie to @ScriptFullPath

@AutoItPID - ID procesu naszego programu.

@AutoItVersion - Wersja kompilatora naszego skryptu

@AutoItX64 - Zwraca 1 jeśli skrypt chodzi pod 64-bitowym kompilatorem AutoIT

Lista makr dotyczących systemu pod którym chodzi program

@CPUArch - Architektura procesora, zwraca X86 jeśli procesor jest 32-bitowy lub X64 jeśli jest 64-bitowy (PROCESOR nie system)

@KBLayout - Układ klawiatury, w Helpie jest lista zwracanych wartości (@OSLang codes).

@OSArch - Architektura systemu, zwraca X86 (32bit), IA64, X64 (64bit) w zależności od zainstalowanego systemu

@OSType - Zwraca "WIN32_NT" jeśli program został uruchomiony na Windowsie 2000/XP/2003/Vista/2008/Win7/2008R2

@OSVersion - Wersja systemu na którym został uruchomiony program, zwraca WIN_2008R2", "WIN_7", "WIN_8", "WIN_2008", "WIN_VISTA", "WIN_2003", "WIN_XP", "WIN_XPe", "WIN_2000".

@OSServicePack - Zwraca wersję Service Pack'a zainstalowanego na systemie

@ComputerName - Nazwa komputera w sieci

@UserName - Nazwa zalogowanego użytkownika

@IPAddress1-4 - Adresy IP naszego komputera, pierwszy to zazwyczaj 127.0.0.1, reszta 0.0.0.0

@DesktopHeight - Wysokość monitora w pikselach, dla rozdzielczości 800x600 wynosi 600

@DesktopWidth - Szerokość monitora w pikselach, dla rozdzielczości 800x600 wynosi 800

@DesktopDepth - Głębia kolorów monitora, 16-bit lub 32-bit

@DesktopRefresh - Częstotliwość odświeżania monitora w Hz (np. dla mnie 60)

A teraz makra programowe.Tutaj będzie długo, bo będę wyjaśniał jak te makra działają, co można z nimi zrobić itp.

Okej, zaczynamy, najpierw lista.

@compiled - Zwraca 1 jeśli skrypt jest skompilowany; 0 jeśli uruchomiony bezpośrednio z kodu

@error - Flaga błędu

@extended - Rozszerzenie flagi błędu

@exitCode - Kod wyjścia programu, czyli jeśli gdzieś wstawimy Exit 1 to kod wyjścia będzie wynosił 1.

@NumParams - Liczba parametrów które zostały podane przy uruchamianiu programu

@ScriptLineNumber - Aktualnie wykonywana linijka skryptu, uwagi poniżej.

@HotKeyPressed - Ostatni naciśnięty hotkey

@CR - Powrót karetki (wskaźnika, tej migającej kreski przy tekście)

@LF - Przejście do następnej linii

@CRLF - Połączenie powyższych, zwykły Enter

A po resztę odsyłam do F1, tu opisałem tylko te najważniejsze makra.

A teraz trochę popiszę.

@error i @extended na pierwszy ogień bo to są wyjątkowe makra. Ich zawartość może być zmieniana przez funkcje. Dzięki tym makrom dowiadujemy się czy funkcja wykonała się poprawnie, a jak nie to dlaczego. Zostają ustawiane przez funkcje SetError i SetExtended , i mogą być zmieniane tylko w funkcji.

@ScriptLineNumber. Tutaj jest jeden kruczek. Pokazuje nam co prawda aktualnie wykonywaną linijkę kodu, ale problem jest po skompilowaniu. A to dlatego że kompilator łączy wszystkie UDFy i temu podobne rzeczy w jeden plik, wywala z niego niepotrzebne białe znaki i tak naprawdę to co u nas w kodzie jest w linijce 12 w kodzie programu może być w linijce 214 nawet jeśli u nas w kodzie takiej linijki nie ma.

@HotKeyPressed, bardzo przydatne makro. W spoilerze w sygnie mam tuta o HotKeyach, polecam przeczytać Ogólnie mówiąc BARDZO ułatwia nam współpracę z HotKey-ami.

@CR, @LF i @CRLF. Makra obsługujące karetkę. Karetka to ta migająca pionowa kreska którą widzimy podczas pisania tekstu, fachowo nazywa to się wskaźnik. Powiem tylko że najlepiej do robienia "enterów" używać makra @LF.

No, tyle na dzisiaj. Podrzucajcie pomysły na następne części tutka.

Phoenix_PL · 12 Maja 2013

Zamykam, wszelkie zażalenia/pytania/itp. proszę składać do mnie na PW/GG/AQQ

GG: 44269601

AQQ: [email protected]

Phoenix_PL · 14 Maja 2013

CIEKAWOSTKI W AUTOIT

porządkowanie kodu

Witam w kolejnej części Ciekawostek. Dzisiaj pokażę parę sposobów, jak utrzymać ład i porządek w kodzie, żeby potem łatwo było go rozczytać. Zapraszam.

No dobrze, w celu utrzymania porządku w kodzie możemy zrobić kilka rzeczy:
- Komentarze
- Białe znaki
- Specjalne dyrektywy
Opiszę każdy z nich po kolei

Komentarze
Podstawowa rzecz jaką mamy się posługiwać. Komentarze w AutoIt wyglądają następująco:

;ten tekst będzie zignorowany
MsgBox(0, "lol", "to się pojawi")
;MsgBox(0, "trolol", "a to nie")

Komentarze zaczynają się średnikiem i powodują że tekst po średniku będzie zignorowany przez kompilator, dzięki czemu możemy tam pisać co chcemy.
Czyli na przykład, kiedy piszemy jakąś skomplikowaną funkcję, to możemy komentarzami oznaczyć co robi dany kawałek kodu. Bardzo przydatna rzecz. A potem nie będziemy musieli się zastanawiać "co ten kod tutaj robi?". Naprawdę polecam używać chociaż tego, szczególnie kiedy mamy zamiar kod publikować, bo jeśli używamy go prywatnie to nie ma aż takiej potrzeby żeby te komentarze umieszczać.

Jest jeszcze jeden sposób komentowania, ale o tym później.

Białe znaki
Tutaj wielki wykrzyknik dla początkujących programistów, którzy często białych znaków nie używają.
Co to białe znaki? Spacje, entery, tabulacje, wszystko co jest i czego nie widać.
Sam SciTe dodaje nam z automatu tabulacje, tylko niestety nie zwracamy na to uwagi a potem kod robi się strasznie wymieszany.
Te znaki są wymyślone po to, żeby oddzielać "bloki" instrukcji od siebie, oraz pomagają nam rozpoznać do jakiej struktury (ify, pętle, itp.) należy dany kod.

Na pewno taki zapis jest łatwiej rozczytać:

Func funkcja()
    Local $zmienna
    InputBox("Wpisz coś", "")
    If $zmienna = "wyjscie" Then
        MsgBox(0, "...", "okej")
        Exit
    ElseIf $zmienna = "lol" Then
        For $i = 0 To 10 Step +1
            MsgBox(0, ";O", "trololol")
        Next
    EndIf
EndFunc

niż taki

Func funkcja()
Local $zmienna
InputBox("Wpisz coś", "")
If $zmienna = "wyjscie" Then
MsgBox(0, "...", "okej")
Exit
ElseIf $zmienna = "lol" Then
For $i = 0 To 10 Step +1
MsgBox(0, ";O", "trololol")
Next
EndIf
EndFunc

Dlatego też naprawdę, używajcie tych białych znaków, bo to dar z niebios.

Specjalne dyrektywy
Ostatni element układanki. Istnieją dwie (dokładniej cztery) specjalne dyrektywy które pomagają porządkować kod.

Pierwszą z nich jest #comments-start i #comments-end. W skrócie #cs i #ce. Pozwalają one robić wielolinijkowe komentarze, które przydają się przy opisywaniu funkcji w UDFach.

Drugą dyrektywą jest #region (i #endregion). Te dyrektywy znane z KODA, pozwalają oddzielać od siebie kod, np. GUI i go zwinąć. Przydatne kiedy GUI jest duże i nam trochę przeszkadza, wtedy wstawiamy na początku jego kodu #Region, na końcu #Endregion i zwijamy.

Jeszcze dwa przykładziki i koniec:

#cs
To jest komentarz, nie potrzeba już ;
Wszystko co zostanie tutaj zapisane, będzie zignorowane
MsgBox(0, "lol", "nie, to też się nie pojawi")
#ce

#region trololo
;Ten kod w SciTE można dowolnie zwijać, wystarczy kliknąć "-" na pasku po lewej koło dyrektywy #region
;Jak widać można też nazwać dany region, opisać co w nim jest.
#endregion

Krótko, ale tyle tylko można o tym napisać. Używajcie tego co wam twórcy dali, bo w końcu stracicie rachubę w swoim własnym kodzie :P

Keniger · 14 Maja 2013

"Komentarze zaczynają się cudzysłowiem i powodują że tekst po cudzysłowiu będzie zignorowany przez kompilator, dzięki czemu możemy tam pisać co chcemy."

Nie cudzysłowiem ale ŚREDNIKIEM !!!!

Phoenix_PL · 15 Maja 2013

My bad kenio, poprawiam.

Btw; opcja zamykania tematu po napisaniu posta nie działa albo ktoś mi chamsko temat otworzył.

jackraymund · 16 Maja 2013

"Sam SciTe dodaje nam z automatu tabulacje, tylko niestety nie zwracamy na to uwagi a potem kod robi się strasznie wymieszany."

a jak się wymiesza i ma się pełną paczke autoita to można uruchomić skrypt który nam sprząta kod ctrl+t (tidy)

btw. czemu zamykasz temat? i musiałeś sam otworzyć temat, bo nie da się napisać posta w zamkniętym temacie(bodajże gmy i adminy mogą)

@down

o raporty nie chodziło mi, tylko o opinie innych, a na opiniach powinieneś sie wzorować

Phoenix_PL · 16 Maja 2013

Bo nie chcę żeby tu spamming się zrobił :P

Wcześniej taka sytuacja się zaczynała, ale poszły raporty.

W sumie masz rację, zawsze te parę raportów naprzód.

Zaloguj się

👋 Witaj na MPCForum!

[TuT] AutoIT Tutorial by Phoenix_PL

Rekomendowane odpowiedzi

Zarchiwizowany