VBA Dla Excela 2016 PL. 222 Praktyczne Przykłady - Witold Wrotek

Wszelkie prawa zastrzeżone.
Nieautoryzowane rozpowszechnianie całości

lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione.
Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie
książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie
praw autorskich niniejszej publikacji.
Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi

bądź towarowymi ich właścicieli.
Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte

w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej
odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne
naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION
nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe
z wykorzystania informacji zawartych w książce.
Redaktor prowadzący: Michał Mrowiec
Wydawnictwo HELION
ul. Kościuszki 1c, 44-100 GLIWICE
tel. 32 231 22 19, 32 230 98 63
e-mail: helion@helion.pl
WWW: http://helion.pl (księgarnia internetowa, katalog książek)
Drogi Czytelniku!
Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres
http://helion.pl/user/opinie/vbae16_ebook
Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję.
Kody źródłowe wybranych przykładów dostępne są pod adresem:

ftp://ftp.helion.pl/przyklady/vbae16.zip
ISBN: 978-83-283-2866-2
Copyright © Helion 2016
 Poleć książkę na Facebook.com  Księgarnia internetowa

 Kup w wersji papierowej  Lubię to! » Nasza społeczność
 Oceń książkę
Spis treści
Wstęp . ............................................................................................ 7
Co to jest VBA? . ............................................................................................................... 7
Basic . .................................................................................................................................. 7
Visual Basic ....................................................................................................................... 8
Visual Basic for Applications . ........................................................................................... 8
Czy VBA jest przeżytkiem? . ............................................................................................. 9
VBA i Office 2007, 2010, 2013, 2016 . ............................................................................ 10
Zmieniony wygląd okna programu . ................................................................................. 10
Makropolecenia w Microsoft Office 2007, 2010, 2013 i 2016 . ...................................... 10
Bezpieczeństwo w Microsoft Office 2007, 2010, 2013 i 2016 . ...................................... 12
Jaką funkcję może pełnić VBA? . ..................................................................................... 12
Kiedy warto stosować VBA? . ......................................................................................... 13
Kiedy nie warto stosować VBA? . .................................................................................... 14
Jak napisać najprostszy program w VBA? ...................................................................... 14
Podsumowanie . ................................................................................................................ 15
Rozdział 1. Makropolecenia . ........................................................................... 17
Microsoft Office 2007, 2010, 2013 i 2016 ...................................................................... 18
Planowanie makropolecenia . ........................................................................................... 18
Wcześniejsze wersje pakietu . .......................................................................................... 19
Microsoft Office 2016 . .................................................................................................... 58
Podsumowanie . ................................................................................................................ 76
Rozdział 2. Jak uruchomić edytor Visual Basic for Applications . ....................... 77
Excel 2007 . ...................................................................................................................... 78
Czy makropolecenia są groźne? . ..................................................................................... 81
Excel 2010, 2013 i 2016 . ................................................................................................. 83
Czy makropolecenie może spowodować szkody? . ......................................................... 87
Podsumowanie . ................................................................................................................ 91
Rozdział 3. Okno edytora Visual Basic for Applications . ................................... 93
Okno Project . ....................................................................................................................94
Okno Properties . .............................................................................................................. 95
Okno Code . .......................................................................................................................96
Pasek menu . ......................................................................................................................97
Pasek narzędziowy . ......................................................................................................... 98
4 VBA dla Excela 2016 PL. 222 praktyczne przykłady
Pierwszy program . ........................................................................................................... 98

Przełączanie między widokami ..................................................................................... 108
Wyrównywanie obiektów . ............................................................................................. 110
Strzelanie z armaty do komara ...................................................................................... 113
Podsumowanie . .............................................................................................................. 113
Rozdział 4. Zmienne . .................................................................................... 115
Nazwy zmiennych w VBA . ........................................................................................... 116
Pułapki systemu komunikatów . ..................................................................................... 119
Typy danych . ................................................................................................................. 120
Pułapki braku deklaracji . ............................................................................................... 127
Wymuszanie deklarowania zmiennych .......................................................................... 130
Zasięg deklaracji . ........................................................................................................... 132
Zmienne lokalne ............................................................................................................. 132
Zmienne obowiązujące wewnątrz całego modułu ......................................................... 133
Zmienne globalne . ......................................................................................................... 133
Przekazanie wartości przez zmienną globalną ............................................................... 137
Przekazanie wartości przez wywołanie procedury z parametrem . ................................ 139
Deklaracja typu i instrukcja przypisania ........................................................................ 140
Komórka arkusza jako zmienna ..................................................................................... 145
Tekst jako wartość zmiennej . ........................................................................................ 149
Podsumowanie . .............................................................................................................. 152
Rozdział 5. Komunikacja z użytkownikiem . .................................................... 153
Wprowadzanie danych . ................................................................................................. 154
Wyświetlanie komunikatów . ......................................................................................... 164
Poprawność wprowadzanych danych ............................................................................ 175
Wycinanie tekstu . .......................................................................................................... 182
Podsumowanie . .............................................................................................................. 187
Rozdział 6. Korzystanie z obiektów . ............................................................... 189
Obiekty ........................................................................................................................... 189
Właściwości . .................................................................................................................. 189
Metody ........................................................................................................................... 190
Zaznaczanie komórki . ................................................................................................... 190
Elektroniczny sufler . ..................................................................................................... 191
Usuwanie zawartości i formatowania . ........................................................................... 193
Usuwanie zawartości . .................................................................................................... 194
Usuwanie formatowania . ............................................................................................... 195
Usuwanie wartości mniejszych od progowej ................................................................. 196
Właściwości . .................................................................................................................. 197
Przypisanie wartości komórce . ...................................................................................... 197
Kopiowanie zawartości komórek . ................................................................................. 201
Nadawanie komórce koloru z użyciem nazwy koloru ................................................... 203
Nadawanie komórce koloru z użyciem kodu koloru ..................................................... 204
Nadawanie koloru zawartości komórki . ........................................................................ 207
Przesuwanie aktywnej komórki . .................................................................................... 209
Podsumowanie . .............................................................................................................. 212
Rozdział 7. Instrukcje warunkowe . ................................................................ 213
Porównywanie . .............................................................................................................. 214
Sterowanie wykonywaniem procedur ............................................................................ 215
Skok do etykiety . ..................................................................................................... 215
Podejmowanie decyzji . ............................................................................................ 225
Wybór jednej z trzech lub więcej opcji ................................................................... 227
Spis treści 5
Wykonanie grupy instrukcji określoną liczbę razy ........................................................ 231

Pętle zagnieżdżone . ....................................................................................................... 237
Wykonywanie pętli, gdy warunek jest spełniony .......................................................... 241
Podsumowanie . .............................................................................................................. 243
Rozdział 8. Elementy sterujące arkusza . ........................................................ 245
Pole listy ......................................................................................................................... 246
Pole kombi (listy rozwijanej) ......................................................................................... 252
Pasek Toolbox i elementy sterujące arkusza .................................................................. 254
Właściwości . .................................................................................................................. 256
Podsumowanie . .............................................................................................................. 260
Rozdział 9. Zdarzenia . ................................................................................... 261
Lista zdarzeń dla skoroszytu . ......................................................................................... 263
Lista zdarzeń dla arkusza . .............................................................................................. 269
Lista zdarzeń dla aplikacji . ............................................................................................ 271
Komunikacja z programem . ........................................................................................... 274
Lista zdarzeń dla formularzy . ........................................................................................ 278
Podsumowanie . .............................................................................................................. 280
Rozdział 10. Metody i właściwości dla zakresu . ............................................... 281
Kopiowanie zakresu komórek . ...................................................................................... 281
Sortowanie zakresu komórek . ........................................................................................ 287
Filtrowanie zakresu komórek . ....................................................................................... 292
Wyszukiwanie informacji . ............................................................................................. 296
Podsumowanie . .............................................................................................................. 299
Rozdział 11. Podprogramy . .............................................................................. 301
Śledzenie pracy programu . ............................................................................................ 308
Procedury zagnieżdżone . ............................................................................................... 310
Procedury zapętlone . ..................................................................................................... 312
Podsumowanie . .............................................................................................................. 315
Rozdział 12. Ściągawka z VBA . ....................................................................... 317
Metody ........................................................................................................................... 317
Funkcje . ......................................................................................................................... 323
Instrukcje . ...................................................................................................................... 332
Operatory ........................................................................................................................ 335
Operatory arytmetyczne . ............................................................................................... 335
Operatory porównania . .................................................................................................. 338
Operator konkatenacji . .................................................................................................. 340
Operatory logiczne . ....................................................................................................... 342
Podsumowanie . .............................................................................................................. 343
Rozdział 13. Funkcje arkuszowe . ..................................................................... 345
Odpowiedniki funkcji arkuszowych w VBA ................................................................. 347
Podsumowanie . .............................................................................................................. 366
Dodatek A Wybrane kody błędów VBA . ......................................................... 367
Dodatek B Programowanie obiektowe . .......................................................... 371
Programowanie proceduralne a obiektowe .................................................................... 371
Właściwości . .................................................................................................................. 373
Metody ........................................................................................................................... 373
Zdarzenia . ...................................................................................................................... 373
Kolekcje ......................................................................................................................... 374
Modele obiektowe . ........................................................................................................ 374

Metoda kropkowa . ......................................................................................................... 374
Obiekty aktywne . ........................................................................................................... 375
Zakończenie . .............................................................................. 377
Skorowidz . ................................................................................. 379
Wstęp
Z tego rozdziału dowiesz się:
 Co oznacza skrót VBA
 Czy VBA trzeba kupować osobno
 Kiedy warto, a kiedy nie należy korzystać z VBA
 Jak utworzyć najprostszy program w VBA
Co to jest VBA?
Skrót VBA pochodzi od angielskich słów Visual Basic for Applications. Spróbujmy
rozszyfrować tę nazwę.
Basic
W pierwszej kolejności mam skojarzenie ze słowem BASIC. Jest to język programo-
wania opracowany na początku lat 60. Skrót oznacza Beginner’s All-purpose Symbolic
Instruction Code, czyli uniwersalny kod instrukcji symbolicznych dla początkujących.
BASIC był przeznaczony do nauki programowania.
Napisany w nim program, którego zastosowanie pozwalało drukować zadaną liczbę

gwiazdek, miał następującą postać:
10 PRINT "Witaj"
20 INPUT "Ile gwiazdek wydrukowac?"; ile
30 PRINT "*";
40 LET ile = ile -1
50 IF ile > 0 THEN GOTO 30
Liczby po lewej stronie to numery linii. Wpisywano je ręcznie. Numerowano je co

dziesięć. Dzięki temu, gdy zachodziła konieczność wstawienia fragmentu kodu, nie
trzeba było przenumerowywać całego programu, a wystarczyło tylko wykorzystać
wolne numery.
Wielką popularność BASIC zyskał dzięki temu, że można było programować w nim
komputery Amstrad CPC, Atari, Commodore, IBM PC i Sinclair ZX Spectrum. Wielu
Czytelników zna komputery tych marek tylko z opowiadań. Widać więc, że BASIC jako
język programowania nieco trąci myszką.
Visual Basic
Kolejne skojarzenie, a mianowicie Visual Basic, jest bardziej trafne. Visual Basic jest ję-
zykiem programowania wysokiego poziomu. Jego składnia jest oparta na języku BASIC,
ale unowocześniona. Pisząc aplikację, a potem używając jej, można korzystać z interfejsu
graficznego (rysunek W.1).
Rysunek W.1.
Visual Basic ma
interfejs graficzny
Visual Basic for Applications

Korzystanie ze skojarzeń przy rozszyfrowywaniu nazwy VBA nie prowadzi do sukcesu.
Pokazuje za to drogę rozwoju oprogramowania.
BASIC jest językiem działającym w środowisku tekstowym. Linie kodu należało wpi-
sywać ręcznie. Popełnienie pomyłki uniemożliwiało uruchomienie programu aż do
usunięcia błędu.
VB był wyposażony w dobrodziejstwa, które przyniósł system Windows. Zamiast

wpisywać linie kodu z klawiatury, wystarczyło wybrać komponenty w oknie programu.
Użytkownik aplikacji mógł komunikować się z nią za pośrednictwem interfejsu gra-
ficznego.
VBA został zaimplementowany w aplikacjach pakietu Microsoft Office (rysunek W.2).

Pozwala on na automatyzację pracy z dokumentami. Jednym z najprostszych zastosowań
VBA są makropolecenia.
Wstęp 9
Rysunek W.2. Okno VBA
VBA nie pozwala na kompilowanie programów i zapisywanie ich do plików wykony-

walnych z rozszerzeniem *.exe.
Program napisany w VBA wymaga do pracy zainstalowanej w komputerze odpowied-

niej aplikacji. Dla plików *.doc jest to MS Word, a dla plików *.xlsx — MS Excel.
Microsoft Access Runtime pozwala na uruchamianie plików Accessa bez konieczności

instalowania na każdym komputerze programu Access.
Czy VBA jest przeżytkiem?

Po raz pierwszy VBA został dołączony do arkusza kalkulacyjnego Excel 5. Miało to
miejsce dosyć dawno temu. Czy warto się nim interesować? A może wkrótce zostanie
zastąpiony innym narzędziem?
Począwszy od Microsoft Office 2000, pakiet został wyposażony w Edytor Visual Basic.
Ułatwia on pracę z kodem. W wersji 2000 dodano także możliwość współpracy programu
Microsoft Access z bazą danych Microsoft SQL Server w architekturze klient-serwer.
VBA i Office 2007, 2010, 2013, 2016

Pakiety Microsoft Office 2007, 2010, 2013 i 2016 obsługują wszystkie technologie, z któ-
rych mogli korzystać zarówno użytkownicy, jak i deweloperzy we wcześniejszych wer-
sjach Microsoft Office.
W pakietach Microsoft Office 2007, 2010, 2013 i 2016 można uruchamiać makro-
polecenia osadzone w istniejących dokumentach i szablonach. Pakiety zawierają język
programowania Visual Basic for Applications (VBA). Zostało w nich więc udostępnione
środowisko dla makropoleceń. Obsługiwane są COM API (COM — Component Object
Model to standard definiowania i tworzenia interfejsów programistycznych; API — Ap-
plication Programming Interface to interfejs programowania aplikacji). Pozwala to ma-
kropoleceniom na wyzwalanie funkcji i przechwytywanie zdarzeń w takich aplikacjach,
jak Outlook czy Word.
Wsteczna zgodność jest bardzo istotna dla makropoleceń. Są one szeroko stosowane
przez użytkowników i deweloperów. Pozwalają na integrowanie Microsoft Office z in-
nymi aplikacjami. Zastosowanie makropoleceń pozwala wybierać dane z listów elek-
tronicznych zapisanych w Outlooku, przeglądać informacje zgromadzone w systemach
CRM (ang. Customer Relationship Management — zarządzanie relacjami z klientem),
generować arkusze Excela na podstawie danych zawartych w systemach ERP (ang. en-
terprise resource planning — planowanie zasobów przedsiębiorstwa).
Wraz z wprowadzeniem Windows 7 oraz Office 2010 VBA programistom stworzono

nową możliwość. Aplikacje mogą działać zarówno w środowisku 32-, jak i 64- bitowym.
Zmieniony wygląd okna programu

Pierwszą rzeczą, którą zauważyłem po uruchomieniu pakietu Microsoft Office 2007,
był zmieniony w stosunku do wcześniejszych wersji interfejs użytkownika. Ta zmiana
może spowodować, że niektóre makropolecenia są ukryte przed użytkownikiem. To roz-
wiązanie zostało zachowane w Microsoft Office 2010, 2013 i 2016.
W Microsoft Office 2007 zastąpiono wiele menu i pasków narzędzi wstążkami. W konse-
kwencji menu i paski narzędzi tworzone przez użytkownika Microsoft Office 2003 nie
mają gdzie się pojawić. Są przenoszone na kartę Dodatki. Może to utrudnić zlokalizowa-
nie obiektu, a gdy zostanie on już odnaleziony, będzie działał poprawnie.
Makropolecenia w Microsoft Office 2007,

2010, 2013 i 2016
Dokumenty zapisywane w domyślnym formacie Microsoft Office 2007, Microsoft
Office 2010, Microsoft Office 2013 i Microsoft Office 2016 nie mogą zawierać makro-
poleceń. Czyni to dokumenty mniej podatnymi na zainfekowanie wirusami przechowy-
wanymi w dokumentach.
Wstęp 11
Za pomocą programów pakietów Microsoft Office 2007, Microsoft Office 2010, Microsoft
Office 2013 i Microsoft Office 2016 można otwierać, tworzyć i zapisywać dokumenty
w formatach zgodnych z wcześniejszymi wersjami pakietu Microsoft Office. W takich
przypadkach pliki będą zawierały makropolecenia. W tabeli w.1. podano rozszerzenia
plików, które pozwalają i nie pozwalają na zapisywanie w nich makropoleceń.
Tabela w.1. Wybrane rozszerzenia plików programów Word i Excel

Rozszerzenie Opis
.docx Domyślny format pliku programu Office Word 2007 i nowszych. Nie można w nim
przechowywać kodu makr języka VBA.
.docm Używa tego samego podstawowego formatu XML, co program Office Word 2007
i nowsze. Może przechowywać kod makr VBA. Ten typ pliku zostaje utworzony,
jeżeli w pliku jest zawarty kod makr VBA.
.dotx Domyślny format szablonu programu Word. Tworzony podczas zapisywania stylu
oraz formatowania dokumentu. Nie można w nim przechowywać kodu makr
języka VBA.
.dotm Przechowuje kod makr do zastosowania w innych dokumentach programu Word.
Nie zawsze zawiera kod makr, jednakże umożliwia jego przechowywanie.
Dokumenty programu Word utworzone z szablonu z obsługą makr nie przejmują
elementu VBAProject zawartego w szablonie. Domyślnie, dokumenty Office
Word 2007 i nowsze są zapisywane jako pliki w formacie .docx nawet wtedy,
gdy zostały utworzone na podstawie szablonu XML z obsługą makr.
.xlsx Domyślny format pliku programu Office Excel 2007 i nowszych. Nie można
w nim przechowywać kodu makr VBA ani arkuszy makr programu Microsoft
Excel 4.0 (pliki w formacie .xlm w programie Excel 4.0).
.xlsm Używa tego samego podstawowego formatu XML, co skoroszyt programu Office
Excel 2007 i nowsze, jednakże można w nim przechowywać kod makr VBA.
Zaleca się, aby tego formatu używali użytkownicy zapisujący skoroszyt XML
programu Office Excel 2007 i nowszych zawierający kod makr VBA lub arkusze
makr Excel 4.0 (pliki w formacie .xlm w programie Excel 4.0).
.xltx Domyślny format szablonu programu Excel. Nie można w nim przechowywać
kodu makr VBA ani arkuszy makr programu Microsoft Excel 4.0 (pliki w formacie
.xlm w programie Excel 4.0).
.xltm Może zawierać element VBAProject lub arkusz makr programu Excel 4.0 (pliki
w formacie .xlm w programie Excel 4.0). Skoroszyty utworzone na podstawie tego
szablonu przejmują element VBAProject lub arkusze makr programu Excel 4.0,
które są zawarte w tym szablonie.
Za pomocą programów wchodzących w skład pakietów Microsoft Office 2007,

Microsoft Office 2010, Microsoft Office 2013 i Microsoft Office 2016 można uru-
chamiać makropolecenia przechowywane w szablonach dokumentów z wcześniejszych
wersji Microsoft Office. Szablon dokumentów MS Word — normal.dot — wykorzystuje
makropolecenia. Domyślna czcionka, jej rozmiar, interlinia itp. są wynikiem makropo-
lecenia uruchamianego przy tworzeniu nowego dokumentu.
Bezpieczeństwo w Microsoft Office 2007,

2010, 2013 i 2016
Podobnie jak ma to miejsce w Microsoft Office 2003, pakiety Microsoft Office 2007,
2010, 2013 i 2016 domyślnie blokują wykonywanie makropoleceń. Zanim makropole-
cenie zostanie wykonane, jest wyświetlane okno informujące o próbie uruchomienia kodu.
Użytkownik musi podjąć decyzję, czy zezwala na wykonanie makropolecenia (rysunek
W.3 i W.4).
Rysunek W.3.
Dopiero po wyrażeniu
zgody makra zostaną
włączone. Okno
Microsoft Office 2016
Rysunek W.4.
W Microsoft Office 2013
i 2016 żółty pasek
został zastąpiony
przez trudniejsze
do przeoczenia
powiadomienie
o zabezpieczeniach
Jaką funkcję może pełnić VBA?

W różnorodności siła! W zespole pracowników powinny znajdować się osoby kreatywne
i takie, które punkt po punkcie, systematycznie wprowadzą pomysł w życie. Powierzenie
pracy z dokumentami osobie, która ma tysiąc pomysłów na godzinę, a obmyślenia kam-
panii reklamowej komuś, kto nie znosi eksperymentów i niepewności, nie da dobrego
efektu. Każdy najlepiej robi to, co jest zgodne z jego naturą.
Komputer wraz z odpowiednim oprogramowaniem również może stanowić uzupełnie-

nie człowieka. Podczas pracy z pakietem Microsoft Office wiele czynności trzeba wy-
konywać ręcznie. Komputer nie zastąpi człowieka przy pisaniu tekstów, wprowadzaniu
danych czy tworzeniu prezentacji. Ale maszyna sprawdzi się idealnie przy wykonywaniu
czynności powtarzalnych, które można opisać w postaci algorytmu.
Człowiek, który ma wyszukać w dokumencie wszystkie znaki wyróżnione kolorem

czerwonym lub spacje poprzedzające znaki interpunkcyjne, po kilku godzinach pracy
zmęczy się i popełni błąd. Komputer do takiej pracy nadaje się wyśmienicie. Nie męczy
się, zarówno na początku zadania, jak i na końcu będzie też pracował z taką samą szyb-
kością (W.5).
Wstęp 13
Rysunek W.5.
Komputer znacznie
szybciej wykona pracę,
która dla człowieka
jest męcząca przez
swą monotonię
Kiedy warto stosować VBA?

VBA jest narzędziem dla zaawansowanych użytkowników pakietu Office. Skąd użyt-
kownik, który nie korzystał jeszcze z VBA, ma wiedzieć, czy problem da się rozwią-
zać poprzez napisanie programu? Czy czas poświęcony na próby stworzenia progra-
mu nie zostanie zmarnowany, a zadania i tak nie trzeba będzie wykonać ręcznie?
Istnieją trzy przesłanki do stosowania VBA. Z VBA warto skorzystać wówczas, gdy:
1. Czynność jest powtarzalna. Zmiana stylu akapitu na górze każdej strony
utworzonej w edytorze Word, formatowanie wielu arkuszy programu Excel
czy aktualizacja wielu kontaktów programu Outlook są czynnościami, które
można zautomatyzować. Pozostaje do rozważenia kwestia, czy warto pisać
program, gdy tę samą czynność musimy powtórzyć 3 – 5 razy i więcej do niej
nie wracać. Moim zdaniem nie. Mniej czasu zajmie wykonanie tej czynności
ręcznie niż napisanie programu. Jeżeli natomiast jakąś operację musisz
wykonać sto lub więcej razy, to warto pokusić się o napisanie programu.
2. Pożądana jest interakcja z użytkownikiem. Nie można zmusić użytkownika,
aby np. w samym dokumencie utworzonym w edytorze Word czy arkuszu
Excela zapisał zmiany przed wykonaniem wydruku. Można w takiej sytuacji
napisać makropolecenie, które zmusi do tego użytkownika lub mu o tym
przypomni. Dzięki temu zmniejszy się prawdopodobieństwo powstawania
różnic między wydrukiem a wersją dokumentu zapisaną do pliku.
3. Pożądana jest interakcja między aplikacjami pakietu Microsoft Office.
Często jest spotykana sytuacja, w której dane są przygotowane w jednej
aplikacji, a wykorzystane w innej. Stajemy wówczas przed koniecznością
skopiowania kontaktów z programu Outlook do dokumentu edytora Word
i sformatowania ich lub skopiowania danych z arkusza Excel do prezentacji
utworzonej w programie PowerPoint. W tych zastosowaniach również można
posłużyć się VBA.
Kiedy nie warto stosować VBA?

Przestrzegam przed traktowaniem VBA jako antidotum na wszystkie bolączki. Użycie
VBA może doprowadzić do celu. Nie zawsze jednak jest to droga optymalna.
Przed rozpoczęciem pisania programu warto zadać sobie pytanie: „Czy istnieje prost-
szy sposób rozwiązania problemu niż ten, który nasuwa się w pierwszej kolejności?”.
Postawienie go i chwila zastanowienia mogą uchronić nas przed zabrnięciem w ślepą
uliczkę. Jeżeli musisz wykonać złożone zadanie edycyjne, może się okazać, że uda się
wykonać je raz przy wykorzystaniu stylów, a następnie… powtórzyć tyle razy, ile będzie
trzeba, naciskając kombinację klawiszy Ctrl+Y.
Kopiowany ze schowka tekst przyjmuje formatowanie dokumentu, do którego jest wsta-

wiany. Być może wykorzystanie tego faktu i utworzenie pustego dokumentu w odpo-
wiednim formacie, a następnie skopiowanie do niego starej wersji będzie szybszym roz-
wiązaniem problemu niż pisanie programu w VBA.
Zdecydowanie, ale to zdecydowanie, odradzam rozpoczynanie pisania programu, jeśli

nie masz warunków do skupienia się nad nim, nie dysponujesz pewną rezerwą czaso-
wą i jesteś początkującym programistą. Gdy pisze się program pod presją uciekające-
go czasu, łatwo popełnić błąd. Brak doświadczenia może spowodować zbyt optymi-
styczną ocenę czasu potrzebnego do napisania programu. Jeśli się spieszysz, możesz
skorzystać z konwencjonalnych metod. Kosztem wykonywania monotonnych i po-
wtarzalnych czynności wykonasz zadanie w możliwym do przewidzenia czasie.
Jak napisać
najprostszy program w VBA?
Żeby napisać program w VBA, wcale nie trzeba znać VBA. Wystarczy zarejestrować
makro (rysunek W.6).
Rysunek W.6.
Wystarczą trzy
kliknięcia myszą
i można
rejestrować
makro
Makro jest sekwencją automatycznie wykonywanych instrukcji VBA. Ma ono własną

nazwę. Zarejestrowane makro można wielokrotnie odtwarzać.
Polecenia wykonywane podczas rejestrowania makra są zapisywane do pliku. Makro-

polecenie można otworzyć w edytorze Visual Basic.
Jak zarejestrować makropolecenie i edytować je, dowiesz się z kolejnego rozdziału.

Wstęp 15
Podsumowanie
 Skrót VBA pochodzi od angielskich słów Visual Basic for Applications.
Został on zaimplementowany w aplikacjach pakietu Microsoft Office.
Pozwala na automatyzację pracy z dokumentami. Jednym z najprostszych
zastosowań VBA są makropolecenia.
 VBA jest instalowany wraz z pakietem Microsoft Office. Z jego aplikacji
korzystają wszyscy użytkownicy, np. wtedy, gdy uruchamiają arkusz
programu Excel lub edytor Word. Pisanie w nim programów wymaga dobrej
znajomości pakietu Office.
 Z VBA warto skorzystać wówczas, gdy w pakiecie Office wielokrotnie
wykonujesz tę samą czynność, pożądana jest interakcja z użytkownikiem
lub między aplikacjami pakietu Office.
 Zdecydowanie odradzam rozpoczynanie pisania programu, jeśli istnieje
prostsze narzędzie, nie masz warunków do skupienia się nad programem
lub nie dysponujesz pewną rezerwą czasową.
Rozdział 1.
Makropolecenia
 Jakie zastosowanie mają makropolecenia
 Jak przygotować się do zarejestrowania makropolecenia
 Jak zarejestrować makropolecenie
 Jak zapisać makropolecenie wraz z arkuszem
 Jak otworzyć makropolecenie do edycji
Przypadek 1. Wykonujesz określoną pracę przy wykorzystaniu programu z pakietu

Microsoft Office. Wymaga ona wybrania wielu poleceń i klikania przycisków. Pracę
udało Ci się wykonać. Nie możesz jednak przypomnieć sobie, w jaki sposób osiągnąłeś
wynik końcowy.
Przypadek 2. Opracowałeś supersposób przetwarzania danych wpisanych do arkusza
kalkulacyjnego Excel. Istotne jest, aby wszyscy pracownicy w firmie przetwarzali je w ten
sam sposób. Jak to zapewnić?
Przypadek 3. Chcesz napisać program w VBA. Ma on usuwać spacje wstawione
przed znakami interpunkcyjnymi. Jesteś początkującym programistą i hm... nie wiesz,
jak zacząć.
We wszystkich przypadkach można rozwiązać problem dzięki wykorzystaniu makro-
poleceń. Programy pakietu Microsoft Office mają wbudowane narzędzie do rejestro-
wania kolejno wykonywanych poleceń. Zarejestrowane czynności są opisywane in-
strukcjami języka VBA.
W pierwszym przypadku wystarczy pamiętać o rozpoczęciu rejestrowania w makro-
poleceniu kolejno wykonywanych czynności przed wykonaniem pierwszej z nich. Jeśli
makro będzie użyteczne, możesz z niego korzystać. Jeśli nie jesteś z niego zadowolony,
wystarczy je usunąć.
W drugim przypadku — zamiast pisać procedury — wystarczy zapisać makro i roz-
dać je tym, którzy mają z niego korzystać. Następnie trzeba je uruchomić, a wykona
ono dokładnie to, co zostało zarejestrowane.
W trzecim przypadku możesz „napisać” program w VBA bez znajomości VBA. Ty uru-
chamiasz rejestrator i wykonujesz czynności, które mają zostać zapisane w postaci pro-
gramu. Rejestrator opisuje wykonywane przez Ciebie czynności w języku VBA. Dba on
o poprawność składni. Ty musisz tylko:
 uruchomić rejestrator,
 wykonać czynności, które mają zostać zapamiętane,
 po wykonaniu wszystkich czynności wyłączyć rejestrator.
Dalsza lektura tego rozdziału pozwoli Ci dowiedzieć się, jak zarejestrować makro-
polecenie.
Microsoft Office 2007,

2010, 2013 i 2016
Na rynku są dostępne cztery pakiety Microsoft Office: 2007, 2010, 2013 (bardziej popular-
ny) i 2016 (najnowszy, ale zyskujący coraz większą liczbę zwolenników). Ze względu na
duże rozpowszechnienie pakietów Microsoft Office 2007, 2010 oraz 2013 i rosnącą rolę
pakietu Microsoft Office 2016 posługiwanie się makropoleceniami zostanie opisane
w odniesieniu do wszystkich czterech.
Planowanie makropolecenia
Poznawanie VBA zaczynamy od czynności najprostszej. Nie wymaga ona znajomości
zasad programowania, a jedynie posługiwania się arkuszem Excel. Czynnością tą jest
rejestrowanie makropolecenia. Nie znaczy to, że można ją wykonać bez przygotowania.
Postaraj się kilka razy wykonać czynności, które mają zostać zarejestrowane w makro-
poleceniu. Dla uzyskania powtarzalności wyników wykonania makropolecenia istotne
są warunki początkowe (np. to, która komórka jest zaznaczona, gdy makropolecenie
jest uruchamiane). Jeżeli istnieje choć jeden parametr, którego wykonanie może mieć
wpływ na wykonanie makropolecenia, zanotuj to spostrzeżenie. Nie zakładaj, że użyt-
kownik makropolecenia zachowa się dokładnie tak jak Ty. Uwzględnij to spostrzeżenie
w makropoleceniu lub zamieść odpowiedni komentarz.
Planując makropolecenie, zastanów się, jakie elementarne czynności trzeba wykonać,

aby uzyskać oczekiwany efekt. Zadanie należy podzielić na kroki. Muszą to być ele-
mentarne czynności, które można wykonać za pomocą klawiatury.
Rozdział 1.  Makropolecenia 19
Wcześniejsze wersje pakietu

W pakiecie Microsoft Office 2007, w porównaniu z wersjami wcześniejszymi, wprowa-
dzono nową organizację ekranu (rysunek 1.1). Ikony pogrupowano tematycznie i utwo-
rzono wstążki.
Rysunek 1.1. Okno Excel 2007
Rejestrowanie makropolecenia
Czynności wchodzące w skład makropolecenia powinny zostać przed zarejestrowaniem
przećwiczone. Nie trzeba wykonywać ich szybko. Ważne jest zachowanie logicznej
kolejności i zminimalizowanie liczby operacji.
Przykład 1.
Załóżmy, że w arkuszu Excel chcemy skopiować zawartość komórek od A1 – A3 do
C1 – C3.
Aby zarejestrować makropolecenie:

1. Wyświetl wstążkę Widok.
2. Kliknij czarną strzałkę widoczną pod przyciskiem Makra.
3. Z rozwiniętego menu wybierz polecenie Zarejestruj makro.
4. Zostało wyświetlone okno Rejestrowanie makra (rysunek 1.2). W polu
Nazwa makra wpisz nazwę, która będzie umożliwiała łatwe odnalezienie
makropolecenia. Powinna ona rozpoczynać się od litery lub podkreślenia.
Rysunek 1.2.
Dane makropolecenia
5. Makropolecenie może być uruchamiane po wybraniu polecenia Wyświetl

makra dostępnego pod przyciskiem Makra na wstążce Widok i wybraniu jego
nazwy lub po naciśnięciu skrótu klawiaturowego. Znacznie prostsza jest druga
metoda. Aby z niej skorzystać, w polu Klawisz skrótu wpisz z klawiatury znak,
którego naciśnięcie będzie powodowało uruchomienie makropolecenia.
6. Makropolecenie może być zarejestrowane tylko do użytku w jednym
dokumencie lub też może być dostępne we wszystkich dokumentach
użytkownika. Zakres dostępności można określić po rozwinięciu listy
Przechowuj makro w:. Wybranie opcji Ten skoroszyt pozwoli na to, by makro
było przechowane w bieżącym skoroszycie. Aby makro mogło być wykonywane,
skoroszyt z tym makrem musi być otwarty. Wybranie opcji Nowy skoroszyt
pozwoli na to, by makro było przechowane w innym skoroszycie. Aby je
wykonać, należy otworzyć ten skoroszyt. Wybranie opcji Skoroszyt makr
osobistych pozwoli na to, by makro zostało zachowane w tzw. skoroszycie
makr osobistych, który jest automatycznie wczytywany po uruchomieniu Excela.
7. W polu Opis Excel domyślnie „wstawia” datę i autora makra. Można w nim
wpisać własne informacje.
8. Aby rozpocząć rejestrację makra, naciśnij przycisk OK.
9. Okno dialogowe Rejestruj makro zostało zamknięte. Wykonane od tej pory
czynności zostaną zarejestrowane.
10. Po zakończeniu wykonywania czynności, które mają zostać zarejestrowane,
wyświetl wstążkę Widok (rysunek 1.3).
Rysunek 1.3. Polecenie umożliwia zakończenie rejestrowania makropolecenia

12. Z rozwiniętego menu wybierz polecenie Zatrzymaj rejestrowanie.
Edytowanie makropolecenia
Przykład 2.
Aby edytować makropolecenie:
1. Wyświetl wstążkę Widok.
3. Z rozwiniętego menu wybierz polecenie Wyświetl makra (rysunek 1.4).
Rysunek 1.4.
Na liście, która
jest rozwijana
po kliknięciu ikony,
znajdują się polecenia
umożliwiające
rejestrowanie i edycję
makropoleceń
4. Zostało wyświetlone okno Makro (rysunek 1.5).
Rysunek 1.5.
Okno programu
do zarządzania
makropoleceniami
5. Zaznacz makropolecenie, które chcesz otworzyć do edycji.

6. Kliknij przycisk Edycja.
7. W oknie edytora Visual Basic jest widoczna hierarchiczna lista wszystkich
otwartych skoroszytów i dodatków. Makro jest zapisane w gałęzi Module1.
Kliknij ją dwukrotnie. Kod makra został wyświetlony (rysunek 1.6).
8. Teraz możesz dokonać niezbędnych zmian.
Rysunek 1.6.
Okno
z wyświetlonym
kodem
makropolecenia
Zapisywanie arkusza
Przykład 3.
W dokumentach zapisanych w domyślnych formatach aplikacji pakietu Microsoft
Office 2007 nie można przechowywać makropoleceń. Sprawdzimy, jak ta właściwość
wpływa na zapisywanie dokumentów:
1. Zarejestruj makropolecenie.
2. Kliknij ikonę oznaczoną symbolem dyskietki (rysunek 1.7).
Rysunek 1.7.
Kliknięcie dyskietki
inicjuje zapisanie
dokumentu do pliku
3. Został wyświetlony komunikat informujący o tym, że w skoroszycie Microsoft

Excel 2007 nie można zapisać projektu VB (rysunek 1.8). Kliknij przycisk Nie.
Rysunek 1.8. Arkusz Microsoft Excel 2007 domyślnie nie może zawierać projektu VB
4. Zmienimy format pliku. Rozwiń listę Zapisz jako typ. Wybierz format
Skoroszyt programu Excel z obsługą makr (rysunek 1.9).
Rysunek 1.9. Arkusze można zapisywać w wielu formatach

5. Kliknij przycisk Zapisz.

6. Kolejna przeszkoda (rysunek 1.10). Można sobie z nią poradzić,
zmieniając nazwę pliku.
Rysunek 1.10. Zmiana nazwy pliku jest konieczna

7. W polu Nazwa pliku wpisz Kajet (rysunek 1.11). Nie zmieniaj ustawień
widocznych w polu Zapisz jako typ. Excel sam „doda” odpowiednie
rozszerzenie pliku.
Rysunek 1.11. Plik ma nie tylko zmieniony format, ale i zmienioną nazwę

9. Arkusz udało się zapisać do pliku. Świadczy o tym zmieniony tytuł dokumentu.
Informacja o tym jest wyświetlana na pasku tytułu (rysunek 1.12).
Rysunek 1.12. Na pasku u góry ekranu nazwa Zeszyt1 została zastąpiona przez Kajet
10. Sprawdzimy jeszcze, jak wygląda plik po zapisaniu. Wyświetl folder docelowy.
Jest w nim widoczna ikona pliku. W kolumnie Typ widnieje informacja Arkusz
programu Microsoft Office Excel z obsługą makr (rysunek 1.13).
Rysunek 1.13. O tym, że dokument został zapisany w formacie innym niż domyślny, informuje ikona
i zapis w kolumnie Typ

O ile — porównując wygląd okien programu Microsoft Excel 2003 i 2007 — odniosłem
wrażenie zmian rewolucyjnych, o tyle zmiany w Microsoft Excel 2010 w porównaniu
z Microsoft Excel 2007 sprawiają wrażenie ewolucyjnych (rysunek 1.14).
Rysunek 1.14. W Microsoft Excel 2010 zachowano wstążki i ikony pogrupowane tematycznie
Planowanie i rejestrowanie makropolecenia

Zaczniemy od wykonania zaplanowanej czynności (przykład 4.). Następnie włączymy
rejestrowanie makra. Ponownie wykonamy zaplanowane czynności (przykład 5.). Po
ich zakończeniu wyłączymy rejestrowanie makra.
Przykład 4.
Załóżmy, że w arkuszu Excel chcemy skopiować zawartość komórek A1 – A3 do C1– C3.
Musimy w tym celu:
1. Zaznaczyć komórki od A1 do A3 (rysunek 1.15).
Rysunek 1.15.
Obszar z danymi
2. Skopiować dane z zaznaczonego obszaru do schowka, np. posługując się

kombinacją klawiszy Ctrl+C (rysunek 1.16). Wokół obszaru pojawiła się
ramka rysowana linią przerywaną.
Rysunek 1.16.
Dane zostały
skopiowane
do schowka
3. Umieścić kursor w komórce C1. Możesz to zrobić, klikając komórkę C1

lub naciskając oznaczone strzałkami klawisze sterowania ruchem kursora
(rysunek 1.17).
Rysunek 1.17.
Zaznaczona komórka
wyznacza początek
obszaru docelowego
4. Wkleić zawartość schowka, np. posługując się kombinacją klawiszy Ctrl+V

(rysunek 1.18).
Rysunek 1.18.
Dane z obszaru A1 – A3
zostały skopiowane
do obszaru C1 – C3
5. Wcisnąć klawisz Esc (rysunek 1.19).

Rysunek 1.19.
Zaznaczenie
obszaru źródłowego
zostało usunięte
„Próba generalna” wypadła pomyślnie. Dane z obszaru A1 – A3 zostały skopiowane

do obszaru C1 – C3. Teraz można zarejestrować makropolecenie.
Rejestrowanie makropolecenia to nie casting do kolejnych odcinków kultowego serialu.
Nadal siedzisz przy komputerze. Jedyna różnica między ćwiczeniem a rejestrowaniem
makropolecenia polega na tym, że uruchamiasz program rejestrujący polecenia przezna-
czone do zrealizowania w arkuszu Excel.
Jeżeli się pomylisz — nic się nie stanie. Możesz przerwać rejestrowanie i uruchomić je
ponownie. Rejestrowanie możesz powtarzać tak długo, aż będziesz zadowolony z uzy-
skanego efektu.
Przykład 5.
Po sprawdzeniu, że polecenia, które chcemy zarejestrować, można wykonać, przepro-
wadź następujące operacje:
1. Wyświetl wstążkę Deweloper (rysunek 1.20). Jeżeli nie jest widoczna, możesz
ją włączyć, wybierając kolejno: Plik/Opcje/Dostosowywanie wstążki.
Rysunek 1.20.
W ten oto sposób staniesz się
deweloperem oprogramowania
2. Odszukaj sekcję Kod.

3. Kliknij przycisk Zarejestruj makro (rysunek 1.21).
Rysunek 1.21.
Sprawa wygląda
na poważną.
Będziemy tworzyć
kod programu!
4. Zostało wyświetlone okno dialogowe Rejestrowanie makra. W polu Nazwa

makra wpisz nazwę, która umożliwi łatwe odszukanie makropolecenia
(rysunek 1.22).
Rysunek 1.22.
Makropoleceniu
można nadać nazwę
5. Makropolecenie może być uruchamiane po naciśnięciu skrótu klawiaturowego.

Aby skorzystać z tej możliwości, kliknij w polu Klawisz skrótu. Wpisz
z klawiatury znak, którego naciśnięcie wraz z sekwencją klawiszy widoczną
na ekranie będzie powodowało uruchomienie makropolecenia (rysunek 1.23).
Rysunek 1.23.
Domyślnie jest wyświetlany
klawisz Ctrl. Wpisz literę,
która będzie uzupełniała skrót
6. Makropolecenie może być zarejestrowane tylko do użytku w jednym

dokumencie lub może być dostępne we wszystkich dokumentach użytkownika.
Zakres dostępności można określić po rozwinięciu listy Przechowuj makro w:
(rysunek 1.24). Wybranie opcji Ten skoroszyt pozwoli na to, by makro było
przechowywane w bieżącym skoroszycie. Aby makro mogło być wykonywane,
skoroszyt z tym makrem musi być otwarty. Wybranie opcji Nowy skoroszyt
pozwoli na to, by makro było przechowywane w innym skoroszycie. Aby
je wykonać, należy otworzyć ten skoroszyt. Wybranie opcji Skoroszyt makr
osobistych pozwoli na to, by makro zostało zachowane w tzw. skoroszycie
makr osobistych, który jest automatycznie wczytywany po uruchomieniu Excela.
Rysunek 1.24.
Miejsce
przechowywania
makra określa
jego dostępność
7. W polu Opis można wpisać z klawiatury informacje, które ułatwią

identyfikację makra (rysunek 1.25).
Rysunek 1.25.
Pole pozwala
na wprowadzenie
dodatkowego opisu
8. Aby rozpocząć rejestrację makra, naciśnij przycisk OK (rysunek 1.26).
Rysunek 1.26.
Okno Rejestrowanie
makra z wpisanymi
informacjami
9. Jeżeli podczas wpisywania informacji w oknie Rejestrowanie makra został

popełniony błąd, na ekranie zostanie wyświetlony komunikat ułatwiający jego
usunięcie (rysunek 1.27).
Rysunek 1.27.
Nazwa makropolecenia
zawiera spację
(patrz rysunek 1.26)
10. Po usunięciu błędu ponownie kliknij przycisk OK (rysunek 1.28).
Rysunek 1.28.
W nazwie
makropolecenia
występuje
podkreślenie
11. W sekcji Kod w miejscu przycisku Zarejestruj makro pojawił się przycisk
Zatrzymaj rejestrowanie (rysunek 1.29). Wykonane od tej pory czynności
zostaną zarejestrowane.
Rysunek 1.29.
Wykonywane
polecenia są
rejestrowane
w arkuszu
12. Po wykonaniu wszystkich czynności, które mają zostać zarejestrowane,

kliknij przycisk Zatrzymaj rejestrowanie (rysunek 1.30).
Rysunek 1.30.
Przycisk Zatrzymaj
rejestrowanie
13. W sekcji Kod ponownie pojawił się przycisk Zarejestruj makro (rysunek 1.31).
Makropolecenie zostało zarejestrowane.
Rysunek 1.31.
Sekcja Kod
po zakończeniu
rejestrowania
makropolecenia
Testowanie makropolecenia
Przetestowanie makropolecenia polega na wykonaniu go.
Dla poprawnego wykonania makropolecenia bardzo istotne jest, aby zostały zacho-
wane takie same warunki początkowe, jakie zastosowano podczas jego rejestrowania
(np. położenie komórki aktywnej).
Przykład 6.
Aby przetestować makropolecenie:
1. Przygotuj arkusz z wypełnionymi i zaznaczonymi tymi samymi komórkami,
którymi posłużyłeś się przy rejestrowaniu makropolecenia (rysunek 1.32).
Nie jest istotna zawartość komórek, ale ich położenie.
Rysunek 1.32.
Komórki A1, A2 i A3
wypełnione danymi
2. Kliknij wstążkę Deweloper (rysunek 1.33).
Rysunek 1.33.
Narzędzia do pracy
z makrami znajdują się
na wstążce Deweloper
3. W sekcji Kod kliknij ikonę Makra (rysunek 1.34).
Rysunek 1.34.
Sekcja Kod,
ikona Makra
Lista makropoleceń zostanie wyświetlona po naciśnięciu kombinacji klawiszy Alt+F8.
4. Po wyświetleniu okna Makro (rysunek 1.35) zaznacz makropolecenie,

które ma zostać uruchomione.
Rysunek 1.35.
Makro przeznaczone
do uruchomienia
5. Kliknij przycisk Uruchom.

6. Makropolecenie zostało wykonane. Porównaj wynik wykonania makropolecenia
(rysunek 1.36) i wynik tych samych czynności wykonywanych ręcznie
(rysunek 1.31).
Rysunek 1.36.
Komórki skopiowane
dzięki wykorzystaniu
makropolecenia
Jeżeli podczas rejestrowania makropolecenia został zdefiniowany klawisz skrótu,

możesz go użyć do uruchomienia makropolecenia.
Przypisanie makropolecenia przyciskowi

Uruchamianie makropolecenia za pomocą okna makra (rysunek 1.35) jest długotrwa-
łe. Można uruchomić makropolecenie szybciej, jeśli skorzysta się z klawisza skrótu
(rysunek 1.23). Trzeba jednak zapamiętać kombinację klawiszy. Rozwiązaniem, które
przyspiesza uruchamianie makra, a jednocześnie nie wymaga zapamiętania kombinacji
klawiszy, jest przypisanie makropolecenia przyciskowi.
Przykład 7.
Aby przypisać makropolecenie przyciskowi:
2. W sekcji Formanty kliknij ikonę Wstaw (rysunek 1.37).
Rysunek 1.37.
Nawet bez znajomości
nazw można wybrać
odpowiedni formant,
klikając jego miniaturę
3. Na liście Formanty formularza kliknij ikonę Przycisk.

4. Kursor zmienił kształt ze strzałki w krzyżyk (rysunek 1.38). Umieść kursor
tam, gdzie ma się znajdować lewy górny róg przycisku.
Rysunek 1.38.
Przecięcie ramion krzyża
wskazuje miejsce na arkuszu
5. Wciśnij i przytrzymaj lewy przycisk myszy.

6. Przeciągnij kursor tak, aby narysować prostokątny przycisk (rysunek 1.39).
Rysunek 1.39.
Wraz z kursorem
przemieszcza się narożnik
prostokąta przeciwległy
do tego, od którego
rozpoczęto rysowanie
7. Zwolnij lewy przycisk myszy.

8. Zostało wyświetlone okno dialogowe Przypisywanie makra (rysunek 1.40).
Zaznacz nazwę makropolecenia, które ma być uruchamiane po kliknięciu
przycisku.
Rysunek 1.40.
W oknie można
przypisać przyciskowi
nazwę makropolecenia
9. Kliknij przycisk OK.

10. W arkuszu pojawił się przycisk (rysunek 1.41). Nosi on nazwę, która
nie informuje o przeznaczeniu przypisanego mu makropolecenia.
Rysunek 1.41.
Przyciskowi jest
nadawana nazwa
domyślna
11. Zmienimy opis przycisku. Kliknij go prawym przyciskiem myszy.

12. Z podręcznego menu wybierz polecenie Edytuj tekst (rysunek 1.42).
Rysunek 1.42.
Tekst widoczny
na przycisku
można edytować
13. Wpisz tekst, który ma być widoczny na przycisku.

14. Przesuwając kółka widoczne w narożnikach lub kwadraty umieszczone
na bokach przycisku, dostosuj jego rozmiar do napisu (rysunek 1.43).
Rysunek 1.43.
Można zmienić opis
i rozmiary przycisku
15. Aby zakończyć edytowanie, kliknij gdziekolwiek obok przycisku. W arkuszu

pojawił się przycisk z nowym napisem i dostosowanymi do niego rozmiarami
(rysunek 1.44).
Rysunek 1.44.
Przycisk
ze zmienionym opisem
Przykład 8.
Aby przetestować działanie makropolecenia uruchamianego przyciskiem:
którymi posłużyłeś się przy rejestrowaniu makropolecenia (rysunek 1.45).
Nie jest istotna zawartość komórek, ale ich położenie.
Rysunek 1.45.
Arkusz przygotowany
do testowania
makropolecenia
2. Kliknij przycisk, któremu zostało przypisane makropolecenie.

3. Dane zostały skopiowane (rysunek 1.46).
Rysunek 1.46.
Efekt działania
makropolecenia
uruchamianego
przyciskiem
Przykład 9.
Aby zmienić krój czcionki używanej do opisywania przycisku:
1. Kliknij przycisk prawym klawiszem myszy.
2. Stosując przeciąganie, zaznacz opis przycisku.
3. Ponownie kliknij przycisk prawym klawiszem myszy.
4. Z menu podręcznego wybierz polecenie Formatuj formant (rysunek 1.47).
Rysunek 1.47.
Opis przycisku
został przygotowany
do edycji
5. Zostało wyświetlone okno Formatowanie formantu (rysunek 1.48).

Wybierz w nim czcionkę, którą chcesz zastosować do opisu przycisku.
7. Wybrane atrybuty zostały zastosowane do opisu przycisku (rysunek 1.49).
Rysunek 1.48.
Można zmienić
nie tylko krój czcionki,
ale i istotne jej atrybuty
Rysunek 1.49.
Przycisk
o zmodyfikowanym
wyglądzie
Zapisywanie makropolecenia
Domyślny format arkusza programu Excel 2010 nie pozwala na zapisanie arkusza wraz
z makropoleceniem. Użytkownik jest ostrzegany przed utratą makropolecenia, ale gdy
zbagatelizuje komunikat, makropolecenie przestanie działać.
Aby nie utracić makropolecenia, należy do zapisu wybrać format pozwalający na ob-
sługę makropoleceń. Podczas wczytywania pliku z makropoleceniem trzeba wyrazić
zgodę na uruchomienie makra.
Jest to nieco skomplikowane. Myślę, że prześledzenie przykładów 10. i 11. rozwieje

wszystkie wątpliwości związane z zapisywaniem arkuszy z makropoleceniami.
Przykład 10.
Aby zapisać arkusz zawierający makropolecenie w formacie pozwalającym na obsługę
makr:
1. Utwórz nowy arkusz z makropoleceniem.
2. Kliknij ikonę Zapisz (rysunek 1.50).
3. Zostało wyświetlone okno Zapisywanie jako. Zmień nazwę pliku, aby można
było łatwo zorientować się, którego przykładu dotyczy (rysunek 1.51).
Rysunek 1.50.
Arkusz
z makropoleceniem,
który nie był jeszcze
zapisywany
Rysunek 1.51. Arkusz zostanie zapisany w formacie pozwalającym na obsługę makropoleceń
4. Z listy Zapisz jako typ wybierz Skoroszyt programu Excel z obsługą makr
(*.xlsm).
6. Sprawdzimy, czy właściwości arkusza nie uległy zmianie. Zamknij arkusz.
7. Odszukaj plik, do którego został zapisany arkusz (rysunek 1.52).
Rysunek 1.52.
Plik zawierający makra
można rozpoznać po:
rozszerzeniu xlsm,
ikonie z wykrzyknikiem,
informacji wyświetlanej
po wskazaniu pliku myszą
8. Dwukrotnie kliknij plik.

9. Plik został załadowany. Aby makra działały, należy wyrazić zgodę na ich
włączenie (rysunek 1.53).
10. Sprawdź, czy makropolecenie działa (patrz rysunki 1.45 i 1.46).
Rysunek 1.53. Bez wyrażenia zgody na uaktywnienie makr będzie widoczny tylko przycisk
Przykład 11.
Aby zapisać arkusz zawierający makropolecenie w formacie niepozwalającym na ob-
sługę makr:
1. Wybierz kolejno polecenia Plik/Zapisz jako (rysunek 1.54).
Rysunek 1.54.
Arkusz z przykładu 10.
zostanie zapisany
pod inną nazwą
Rysunek 1.55.
Arkusz zostanie
zapisany w formacie
domyślnym
— niepozwalającym
na obsługę
makropoleceń
3. Z listy Zapisz jako typ wybierz Skoroszyt programu Excel (*.xlsx).

5. Zostało wyświetlone okno z informacją, że w wybranym formacie makropolecenia
nie są obsługiwane (rysunek 1.56). Potwierdź wykonanie operacji.
Rysunek 1.56. W formacie domyślnym arkusz zostanie pozbawiony makropoleceń

Rysunek 1.57.
Plik niezawierający makr
rozszerzeniu xlsx, ikonie
z wykresem słupkowym,
braku informacji
o makropoleceniu
w dymku wyświetlanym

9. Plik został załadowany. Nie pojawiła się informacja o tym, że plik zawiera
makra (patrz rysunek 1.53).
10. Zaznacz dane przeznaczone do skopiowania i kliknij przycisk uruchamiający
makropolecenie (rysunek 1.58).
Rysunek 1.58.
Arkusz przygotowany
do testowania
makropolecenia
11. Dane nie zostały skopiowane, natomiast został wyświetlony komunikat

informujący o niemożności wykonania makra (rysunek 1.59).
Rysunek 1.59. Makro nie może zostać wykonane
Otworzenie makropolecenia do edycji

Rejestrowane makropolecenie jest zapisywane w postaci poleceń języka VBA. Powstaje
więc program. Można go edytować. Warto to zrobić np. po wykryciu błędu (patrz
przykład 11.).
Przykład 12.
Aby wczytać do edycji makro z przykładu 11.:
1. Dwukrotnie kliknij plik (rysunek 1.57).
2. Po wczytaniu pliku kliknij wstążkę Deweloper.
Rysunek 1.60.
Ikona Makra
4. Zostało wyświetlone okno Makro (rysunek 1.61). Nie widać w nim żadnych
makropoleceń.
Rysunek 1.61.
Arkusz nie zawiera
makropoleceń
Przykład 13.
5. Zaznacz nazwę makropolecenia, które będzie edytowane.
7. W oknie edytora Visual Basic for Applications jest widoczna hierarchiczna
lista wszystkich otwartych skoroszytów i dodatków. Makro jest zapisane
w gałęzi Module1. Kliknij ją dwukrotnie. Kod makra został wyświetlony
(rysunek 1.63).
Rysunek 1.62.
W tym arkuszu są
dostępne
makropolecenia
Rysunek 1.63. Makropolecenie zostało otwarte do edycji
Polecenia są wpisane pomiędzy słowami Sub i End Sub.
Na początku makra, po apostrofach, są wstawione linie komentarza. Nie wpływają

one na realizację makra. Zawarte w nich informacje pozwolą zaoszczędzić wiele czasu,
gdy przyjdzie Ci edytować cudze makro lub makro własne po pewnym czasie od jego
zarejestrowania. W przykładzie zostały one skopiowane z okna opisu (rysunki 1.22 i 1.25).
Po komentarzach znajdują się linie programu. Aby poprawić makro, należy zmienić frag-
ment kodu makra. Jest do tego niezbędna znajomość poleceń Visual Basic. Najpierw
trzeba zrozumieć, co jest zapisane w programie, a następnie wiedzieć, co wpisać, aby
uzyskać oczekiwaną zmianę działania makropolecenia.
Jeżeli nie umiesz programować w Visual Basicu, najprostszym sposobem poprawienia

makropolecenia będzie zarejestrowanie go pod tą samą nazwą.

Osoba, która pracowała z arkuszem Microsoft Excel 2010 lub 2007, nie będzie miała
dużych problemów z korzystaniem z programem Microsoft Excel 2013. W wyglądzie
interfejsu programu nie zostały wprowadzone znaczące zmiany (rysunek 1.64).
Rysunek 1.64. Microsoft Excel 2013. Wstążki pozornie nie różnią się od znanych z Microsoft Excel 2010

Przykład 14.
Załóżmy, że w arkuszu Excel chcemy skopiować zawartość komórek A1 – A3 do
C1 – C3. Musimy w tym celu:
Rysunek 1.65.
Obszar z danymi
2. Skopiować dane z zaznaczonego obszaru do schowka, np. poprzez posłużenie

się kombinacją klawiszy Ctrl+C (rysunek 1.66). Wokół obszaru pojawiła się
Rysunek 1.66.
Dane zostały
skopiowane
do schowka

(rysunek 1.67).
Rysunek 1.67.
Zaznaczona komórka
wyznacza początek
obszaru docelowego
4. Wkleić zawartość schowka, np. poprzez posłużenie się kombinacją klawiszy

Ctrl+V (rysunek 1.68).
Rysunek 1.68.
Dane z obszaru
A1 – A3 zostały
skopiowane
Rysunek 1.69.
Zaznaczenie
zostało usunięte

Do rejestrowania makropolecenia należy przystąpić wówczas, gdy zostało sprawdzone
w praktyce, że wykonanie sekwencji czynności w arkuszu Excel prowadzi do oczeki-
wanego rezultatu.
Ważne jest, aby makropolecenie było rejestrowane przy takich samych warunkach począt-
kowych (np. aktywna komórka), przy jakich sekwencja czynności została sprawdzona.
skanego efektu.
Przykład 15.
1. Wyświetl wstążkę Deweloper (rysunek 1.70). Jeżeli nie jest widoczna,
możesz ją włączyć, wybierając kolejno: Plik/Opcje/Dostosowywanie wstążki.
Rysunek 1.70.
2. Odszukaj sekcję Kod.

3. Kliknij przycisk Zarejestruj makro (rysunek 1.71).
Rysunek 1.71.
Kliknięcie przycisku
rozpoczyna
rejestrowanie makra
4. Zostało wyświetlone okno dialogowe Rejestrowanie makra. W polu Nazwa makra

wpisz nazwę, która umożliwi łatwe odszukanie makropolecenia (rysunek 1.72).
Dodatkowe informacje można umieścić w polu Opis (rysunek 1.75).
Rysunek 1.72.
Makropoleceniu

Rysunek 1.73.
6. Makropolecenie może być zarejestrowane tylko do użytku w bieżącym

skoroszycie, nowym skoroszycie lub może być dostępne we wszystkich
dokumentach użytkownika. Zakres dostępności można określić po rozwinięciu
listy Przechowuj makro w: (rysunek 1.74). Wybranie opcji Ten skoroszyt
pozwoli na to, by makro było przechowywane w bieżącym skoroszycie.
Aby makro mogło być wykonywane, skoroszyt z tym makrem musi być
otwarty. Wybranie opcji Nowy skoroszyt pozwoli na to, by makro było
przechowywane w innym skoroszycie. Aby je wykonać, należy otworzyć
ten skoroszyt. Wybranie opcji Skoroszyt makr osobistych pozwoli na to, by
makro zostało zachowane w tzw. skoroszycie makr osobistych, który jest
automatycznie wczytywany po uruchomieniu Excela.
Rysunek 1.74.
Miejsce
przechowywania
makra określa
jego dostępność
7. W polu Opis można wpisać z klawiatury informacje, które ułatwią identyfikację

makra (rysunek 1.75).
Rysunek 1.75.
Pole pozwala
na wprowadzenie
dodatkowego opisu
Rysunek 1.76.
Okno Rejestrowanie
makra z wpisanymi
informacjami

Rysunek 1.77. Nazwa makropolecenia zawiera spację (patrz rysunek 1.76)
Rysunek 1.78.
Podkreślenie w nazwie
makropolecenia jest
akceptowane
11. W sekcji Kod w miejscu przycisku Zarejestruj makro pojawił się przycisk
Zatrzymaj rejestrowanie (rysunek 1.79). Wykonane od tej pory czynności
zostaną zarejestrowane.
Rysunek 1.79.
Arkusz „rejestruje”
wykonywane polecenia

kliknij przycisk Zatrzymaj rejestrowanie (rysunek 1.80).
Rysunek 1.80.
Do klinięcia przycisku
Zatrzymaj wszystkie
polecenia wydane
z klawiatury są
rejestrowane
13. W sekcji Kod ponownie pojawił się przycisk Zarejestruj makro (rysunek 1.81).
Makropolecenie zostało zarejestrowane.
Rysunek 1.81.
Sekcja Kod
po zakończeniu
rejestrowania
makropolecenia
wane takie same warunki początkowe, jakie wykorzystano podczas jego rejestrowania
(np. położenie komórki aktywnej).
Przykład 16.
co przy rejestrowaniu makropolecenia (rysunek 1.82). Nie jest istotna zawartość
komórek, ale ich położenie.
Rysunek 1.82.
wypełnione danymi
Rysunek 1.83.
Narzędzia do pracy
na wstążce Deweloper
Rysunek 1.84.
Sekcja Kod,
ikona Makra
Lista makropoleceń zostanie również wyświetlona po naciśnięciu kombinacji klawi-

szy Alt+F8.

Rysunek 1.85.
Makro przeznaczone
do uruchomienia

(rysunek 1.86) i wynik tych samych czynności wykonywanych ręcznie
(rysunek 1.69).
Rysunek 1.86.
Komórki skopiowane
makropolecenia


Uruchamianie makropolecenia za pomocą okna makra (rysunek 1.85) jest długotrwałe.
Można uruchomić makropolecenie szybciej, jeśli skorzysta się z klawisza skrótu (ry-
sunek 1.78). Trzeba jednak zapamiętać kombinację klawiszy. Rozwiązaniem, które przy-
spiesza uruchamianie makra, a jednocześnie nie wymaga zapamiętania kombinacji kla-
wiszy, jest przypisanie makropolecenia przyciskowi.
Przykład 17.
Rysunek 1.87.
nazw można wybrać
odpowiedni formant,
klikając jego
miniaturę
3. Na liście Formanty formularza kliknij ikonę Przycisk.

4. Kursor zmienił kształt ze strzałki w krzyżyk (rysunek 1.88). Umieść kursor tam,
gdzie ma się znajdować lewy górny róg przycisku.
Rysunek 1.88.

6. Przeciągnij kursor tak, aby narysować przycisk (rysunek 1.89).
Rysunek 1.89.
Wraz z kursorem

przycisku.
Rysunek 1.90.
W oknie można

Rysunek 1.91.
Przyciskowi jest
nadawana nazwa
domyślna

Rysunek 1.92.
Tekst widoczny
na przycisku
można edytować

Rysunek 1.93.
15. Aby zakończyć edytowanie, kliknij obok przycisku. W arkuszu pojawił się
przycisk z nowym napisem i dostosowanymi do niego rozmiarami (rysunek 1.94).
Rysunek 1.94.
Przycisk
Przykład 18.
Rysunek 1.95.
Arkusz przygotowany
do testowania
makropolecenia

Rysunek 1.96.
Efekt działania
makropolecenia
uruchamianego
przyciskiem
Przykład 19.
Rysunek 1.97.
Opis przycisku
do edycji

Rysunek 1.98.
Można zmienić
ale i jej istotne
atrybuty

Rysunek 1.99.
Przycisk
o zmodyfikowanym
wyglądzie
Udostępnianie makropolecenia
Aby makro było dostępne zawsze, gdy jest używany program Excel, należy przy zapisie
wybrać pozycję Osobisty skoroszyt makr. Po jej wybraniu w programie Excel zostanie
utworzony (jeśli jeszcze nie istnieje) ukryty osobisty skoroszyt makr (Personal.xlsb)
i makro zostanie w tym skoroszycie.
Pliku Personal.xlsb nie można współużytkować na wielu komputerach, ale można go

skopiować do folderu XLSTART na innych komputerach.
Aby udostępnić innym osobom tylko jedno makro lub kilka makr, można przesłać im
skoroszyt zawierający te makra w wiadomości e-mail. Skoroszyt można także upu-
blicznić na udostępnionym dysku sieciowym lub przez bibliotekę programu SharePoint
Services.
Jeśli zachodzi potrzeba skopiowania makr ze skoroszytu osobistego do innego skoroszytu

lub odwrotnie, można to zrobić w eksploratorze projektu, który znajduje się w Edytorze
Visual Basic.
Domyślny format arkusza programu Excel 2013 nie pozwala na zapisanie arkusza
wraz z makropoleceniem. Użytkownik jest ostrzegany przed utratą makropolecenia,
ale gdy zbagatelizuje komunikat, makropolecenie przestanie działać.

Przykład 20.
makr:
Rysunek 1.100.
Arkusz
z makropoleceniem,
nie był on jeszcze
zapisywany
3. Wskaż lokalizację, w której ma zostać zapisany plik (rysunek 1.101).
Rysunek 1.101.
Arkusz
z makropoleceniem,
zostanie zapisany
na dysku twardym
było łatwo zorientować się, którego przykładu on dotyczy (rysunek 1.102).
5. Z listy Zapisz jako typ wybierz Skoroszyt programu Excel z obsługą makr.
Rysunek 1.103.
rozszerzeniu xlsm,
Rysunek 1.104. Bez wyrażenia zgody na uaktywnienie makr będzie widoczny tylko przycisk
11. Sprawdź, czy makropolecenie działa (patrz rysunki od 1.70 do 1.81).
Przykład 21.
sługę makr:
Rysunek 1.105.
zostanie zapisany
pod inną nazwą
2. Wybierz lokalizację i w oknie Zapisywanie jako zmień nazwę pliku, aby można
3. Z listy Zapisz jako typ wybierz Skoroszyt programu Excel.
Rysunek 1.106. Arkusz zostanie zapisany w formacie domyślnym — niepozwalającym na obsługę

makropoleceń
5. Zostało wyświetlone okno z informacją, że w wybranym formacie
makropolecenia nie są obsługiwane (rysunek 1.107). Potwierdź wykonanie
operacji.

Rysunek 1.108.
Plik niezawierający makra
ikonie z wykresem
słupkowym

9. Zaznacz dane przeznaczone do skopiowania i naciśnij kombinację klawiszy
Ctrl+F8.
10. Okno Makro nie zawiera makropolecenia (rysunek 1.109).
Rysunek 1.109.
Arkusz przygotowany
do testowania
makropolecenia
11. Jeżeli zapiszesz arkusz w formacie bez obsługi makr, a następnie spróbujesz je
uruchomić, zostanie wyświetlony komunikat informujący o niemożności
wykonania makra (rysunek 1.110).

Rejestrowane makropolecenie jest zapisywane w postaci poleceń języka VBA. Po-
wstaje więc program. Można go edytować. Warto to zrobić np. po wykryciu błędu
(patrz przykład 21.).
Przykład 22.
Rysunek 1.111.
Ikona Makra
4. Zostało wyświetlone okno Makro (rysunek 1.112). Nie widać w nim żadnych
makropoleceń.
Rysunek 1.112.
Arkusz nie zawiera
makropoleceń
Przykład 23.
Rysunek 1.113.
Arkusz
z makropoleceniami

4. Zostało wyświetlone okno Makro.

(rysunek 1.114).
Na początku makra, po apostrofach, są wstawione linie komentarza. Nie wpływają one

na realizację makra. Zawarte w nich informacje pozwolą zaoszczędzić wiele czasu,
gdy przyjdzie Ci edytować cudze makro lub makro własne po pewnym czasie od jego za-
rejestrowania. W przykładzie zostały one skopiowane z okna opisu (rysunki 1.22 i 1.25).
Po komentarzach znajdują się linie programu. Aby poprawić makro, należy zmienić linie
programu. Jest do tego niezbędna znajomość poleceń Visual Basic. Najpierw trzeba zro-
zumieć, co jest zapisane w programie, a następnie wiedzieć, co wpisać, aby uzyskać
oczekiwaną zmianę działania makropolecenia.
Jeżeli nie umiesz programować w Visual Basicu, najprostszym sposobem poprawienia

makropolecenia będzie zarejestrowanie go pod tą samą nazwą.

Arkusz Microsoft Excel 2016 wita nas interfejsem, do którego użytkownicy trzech
poprzednich wersji zdążyli się już przyzwyczaić (rysunek 1.115).
Rysunek 1.115. Wstążka pragramu Microsoft Excel 2016

Przykład 24.
Załóżmy, że w arkuszu Excel chcemy skopiować zawartość komórek A1 – A3 do
C1 – C3. Musimy w tym celu:
Rysunek 1.116.
Obszar z danymi
2. Skopiować dane z zaznaczonego obszaru do schowka, np. poprzez posłużenie

się kombinacją klawiszy Ctrl+C (rysunek 1.117). Wokół obszaru pojawiła się
Rysunek 1.117.
Dane zostały
skopiowane
do schowka

(rysunek 1.118).
Rysunek 1.118.
Zaznaczona komórka
wyznacza początek
obszaru docelowego
4. Wkleić zawartość schowka, np. poprzez posłużenie się kombinacją klawiszy

Ctrl+V (rysunek 1.119).
Rysunek 1.119.
Dane z obszaru
A1 – A3 zostały
skopiowane
Rysunek 1.120.
Zaznaczenie
zostało usunięte

Do rejestrowania makropolecenia należy przystąpić wówczas, gdy zostało sprawdzone
w praktyce, że wykonanie sekwencji czynności w arkuszu Excel prowadzi do oczeki-
wanego rezultatu.
Ważne jest, aby makropolecenie było rejestrowane przy takich samych warunkach począt-
kowych (np. aktywna komórka), przy jakich sekwencja czynności została sprawdzona.
skanego efektu.
Przykład 25.
1. Wyświetl wstążkę Widok (rysunek 1.121). Jeżeli nie jest widoczna, możesz ją
włączyć, wybierając kolejno: Plik/Opcje/Dostosowywanie wstążki.
Rysunek 1.121.
2. Kliknij czarną strzałkę na ikonie Makra.

3. Naciśnij przycisk Zarejestruj makro (rysunek 1.122).
Rysunek 1.122.
Naciśnięcie przycisku
rozpoczyna
rejestrowanie makra
4. Zostało wyświetlone okno dialogowe Rejestrowanie makra. W polu Nazwa

makra wpisz nazwę, która umożliwi łatwe odszukanie makropolecenia
(rysunek 1.123). Dodatkowe informacje można umieścić w polu Opis
(rysunek 1.126).
Rysunek 1.123.
Makropoleceniu

Rysunek 1.124.
6. Makropolecenie może być zarejestrowane tylko do użytku w bieżącym

skoroszycie, nowym skoroszycie lub może być dostępne we wszystkich
dokumentach użytkownika. Zakres dostępności można określić po rozwinięciu
listy Przechowuj makro w: (rysunek 1.125). Wybranie opcji Ten skoroszyt
pozwoli na to, by makro było przechowywane w bieżącym skoroszycie.
Aby makro mogło być wykonywane, skoroszyt z tym makrem musi być
otwarty. Wybranie opcji Nowy skoroszyt pozwoli na to, by makro było
przechowywane w innym skoroszycie. Aby je wykonać, należy otworzyć
ten skoroszyt. Wybranie opcji Skoroszyt makr osobistych pozwoli na to,
by makro zostało zachowane w tzw. skoroszycie makr osobistych, który
jest automatycznie wczytywany po uruchomieniu Excela.
Rysunek 1.125.
Miejsce
przechowywania
makra określa
jego dostępność
7. W polu Opis można wpisać z klawiatury informacje, które ułatwią

identyfikację makra (rysunek 1.126).
Rysunek 1.126.
Pole pozwala
na wprowadzenie
dodatkowego opisu
Rysunek 1.127.
Okno Rejestrowanie
makra z wpisanymi
informacjami

Rysunek 1.128.
Nazwa makropolecenia
zawiera spację
(patrz rysunek 1.123)

Rysunek 1.129.
Podkreślenie w nazwie
makropolecenia
jest akceptowane
11. W menu, które pojawia się po kliknięciu czarnej strzałki widocznej pod
napisem Makra w miejscu przycisku Zarejestruj makro (rysunek 1.122),
pojawił się przycisk Zatrzymaj rejestrowanie (rysunek 1.130). Wykonane
od tej pory czynności zostaną zarejestrowane.
Rysunek 1.130.
Arkusz „rejestruje”
wykonywane polecenia

kliknij przycisk Zatrzymaj rejestrowanie.
13. W sekcji Makra ponownie pojawił się przycisk Zarejestruj makro

(rysunek 1.131). Makropolecenie zostało zarejestrowane.
Rysunek 1.131.
Sekcja Makra
po zakończeniu
rejestrowania
makropolecenia
wane takie same warunki początkowe, jakie wykorzystano podczas jego rejestro-
wania (np. położenie komórki aktywnej).
Przykład 26.
co przy rejestrowaniu makropolecenia (rysunek 1.132). Nie jest istotna
zawartość komórek, ale ich położenie.
Rysunek 1.132.
wypełnione danymi
2. Kliknij wstążkę Widok (rysunek 1.133).
Rysunek 1.133.
Narzędzia do pracy
na wstążce Widok
3. W sekcji Makra kliknij ikonę Makra (rysunek 1.134).
Rysunek 1.134.
Sekcja Kod,
ikona Makra
Lista makropoleceń zostanie wyświetlona również po naciśnięciu kombinacji klawiszy

Alt+F8.

Rysunek 1.135.
Makro przeznaczone
do uruchomienia

(rysunek 1.136) i wynik tych samych czynności wykonywanych ręcznie.
Rysunek 1.136.
Komórki skopiowane
makropolecenia


Uruchamianie makropolecenia za pomocą okna makra (rysunek 1.135) jest długotrwałe.
Można uruchomić makropolecenie szybciej, jeśli skorzysta się z klawisza skrótu. Trzeba
jednak zapamiętać kombinację klawiszy. Rozwiązaniem, które przyspiesza uruchamianie
makra, a jednocześnie nie wymaga zapamiętania kombinacji klawiszy, jest przypisanie
makropolecenia przyciskowi.
Przykład 27.
1. Kliknij wstążkę Deweloper. Jeżeli nie jest ona widoczna, wybierz kolejno
polecenia: Plik/Opcje/Dostosowywanie Wstążki/Deweloper/OK (rysunek 1.137).
Rysunek 1.137. Wstążka Deweloper domyślnie nie jest widoczna

Rysunek 1.138.
nazw można wybrać
odpowiedni formant,
klikając jego miniaturę
3. Na liście Kontrolki formularza kliknij ikonę Przycisk (rysunek 1.139).
Rysunek 1.139.
Symbol przypomina
przycisk. Nie widać
tylko na nim napisu
4. Kursor zmienił kształt ze strzałki w krzyżyk (rysunek 1.140). Umieść kursor
tam, gdzie ma się znajdować lewy górny róg przycisku.
Rysunek 1.140.

6. Przeciągnij kursor tak, aby narysować przycisk (rysunek 1.141).
Rysunek 1.141.
Wraz z kursorem

przycisku.
Rysunek 1.142.
W oknie można
Rysunek 1.143.
Przyciskowi jest
nadawana nazwa
domyślna

Rysunek 1.144.
Tekst widoczny
na przycisku
można edytować

Rysunek 1.145.
15. Aby zakończyć edytowanie, kliknij obok przycisku. W arkuszu pojawił

się przycisk z nowym napisem i dostosowanymi do niego rozmiarami
(rysunek 1.146).
Rysunek 1.146.
Przycisk
Przykład 28.
Rysunek 1.147.
Arkusz przygotowany
do testowania
makropolecenia

Rysunek 1.148.
Efekt działania
makropolecenia
uruchamianego
przyciskiem
Przykład 29.
Rysunek 1.149.
Opis przycisku
do edycji

Rysunek 1.150.
Zmienić można
ale i jej istotne atrybuty

Rysunek 1.151.
Przycisk o zmodyfikowanym
wyglądzie
Domyślny format arkusza programu Excel 2016 nie pozwala na zapisanie arkusza
wraz z makropoleceniem. Użytkownik jest ostrzegany przed utratą makropolecenia,
ale gdy zbagatelizuje komunikat, makropolecenie przestanie działać.

Przykład 30.
makr:
Rysunek 1.152.
Arkusz z makropoleceniem,
nie był on jeszcze zapisywany
3. Wskaż lokalizację, w której ma zostać zapisany plik (rysunek 1.153).
Rysunek 1.153
Arkusz
z makropoleceniem,
zostanie zapisany
na dysku twardym
było łatwo zorientować się, którego przykładu on dotyczy (rysunek 1.154).

5. Z listy Zapisz jako typ wybierz Skoroszyt programu Excel z obsługą makr.
Rysunek 1.155.
rozszerzeniu xlsm,

Rysunek 1.156.
Bez wyrażenia zgody
na uaktywnienie makr
będzie widoczny tylko
przycisk
11. Sprawdź, czy makropolecenie działa (patrz rysunki od 1.147 i 1.148).
Przykład 31.
sługę makr:
Rysunek 1.157.
zostanie zapisany
pod inną nazwą
2. Wybierz lokalizację i w oknie Zapisywanie jako zmień nazwę pliku, aby można
Rysunek 1.158. Arkusz zostanie zapisany w formacie domyślnym — niepozwalającym na obsługę

makropoleceń
3. Z listy Zapisz jako typ wybierz Skoroszyt programu Excel.

5. Zostało wyświetlone okno z informacją, że w wybranym formacie
makropolecenia nie są obsługiwane (rysunek 1.159). Potwierdź wykonanie
operacji.

Rysunek 1.160.
Plik niezawierający makra
ikonie z wykresem
słupkowym

10. Zaznacz dane przeznaczone do skopiowania i naciśnij kombinację klawiszy
Alt+F8.
11. Okno Makro nie zawiera makropolecenia (rysunek 1.161).
Rysunek 1.161.
W arluszu nie są
dostępne żadne
makropolecenia
12. Jeżeli zapiszesz arkusz w formacie bez obsługi makr, a następnie spróbujesz je
uruchomić, zostanie wyświetlony komunikat informujący o niemożności
wykonania makra (rysunek 1.162).


Rejestrowane makropolecenie jest zapisywane w postaci poleceń języka VBA. Powstaje
więc program. Można go edytować. Warto to zrobić np. po wykryciu błędu (patrz
przykład 31.).
Przykład 32.
Rysunek 1.163.
Ikona Makra
Rysunek 1.164.
Okno wyboru
makropolecenia

(rysunek 1.165).
Na początku makra, po apostrofach, zostały wstawione linie komentarza. Nie wpływają

one na realizację makra. Zawarte w nich informacje pozwolą zaoszczędzić wiele cza-
su, gdy przyjdzie Ci edytować cudze makro lub makro własne po pewnym czasie od jego
zarejestrowania. W przykładzie zostały one skopiowane z okna opisu (rysunek 1.129).
Po komentarzach znajdują się linie programu. Aby poprawić makro, należy zmienić linie
programu. Jest do tego niezbędna znajomość poleceń Visual Basic. Najpierw trzeba zro-
zumieć, co jest zapisane w programie, a następnie wiedzieć, co wpisać, aby uzyskać ocze-
kiwaną zmianę działania makropolecenia.
Odwołania względne i bezwzględne

Przygotuj arkusz z wypełnionymi i zaznaczonymi tymi samymi komórkami, co przy
rejestrowaniu makropolecenia.
W opisanych wcześniej przykładach kopiowane komórki są zapisywane w komórkach

od A1 do A3. Zarejestrowane makropolecenie „kopiuje” nie trzy komórki znajdujące
się kolejno pod sobą, ale wyłącznie komórki od A1 do A3.
Kopiowanie formuł jest niezwykle użyteczne w Excelu. Formuła raz napisana może
być skopiowana w ciągu kilku sekund do wielu komórek i właściwe wartości zostaną
obliczone w każdej z nich. W przypadku formuł należy jednak uważać przy ich kopio-
waniu. Istotne są bowiem adresy komórek.
Jako domyślne jest stosowane przez program adresowanie względne. Ma ono postać
np. A1.
W adresowaniu bezwzględnym istotny jest konkretny adres komórki, a nie jej położenie
względem innych danych. Aby komórkę oznaczyć adresem bezwzględnym, należy do
adresu komórki wprowadzić dodatkowe oznaczenia w postaci symbolu $, np. $A$1.
Znak $ może też zostać wprowadzony poprzez ustawienie kursora w odpowiednim

miejscu, przytrzymanie klawisza Shift i wciśnięcie cyfry 4.
Używanie klawisza F4 pozwoli znacznie przyspieszyć pracę. Wciskając klawisz F4

kilkukrotnie, będziemy mogli wprowadzić różne kombinacje znaków $ w adresie ko-
mórki. Prześledźmy to na przykładzie komórki A1:
 pierwsze wciśnięcie F4 pozwala dodać znaki $ do wiersza i kolumny — $A$1,
 drugie wciśnięcie F4 pozwala dodać znak $ tylko do wiersza — A$1,
 trzecie wciśnięcie F4 pozwala dodać znak $ tylko do kolumny — $A1,
 czwarte wciśnięcie F4 pozwala przywrócić oryginalny adres bez $, czyli A1.
Każde kolejne wciśnięcie F4 powoduje ponowne przejście przez powyżej opisany cykl.
Przy adresowaniu względnym adresy komórek zostaną wyrażone względem aktualnie

zaznaczonej komórki. Przy rejestrowaniu bezwzględnym makro zostanie wykonane
identycznie, jak zostało zarejestrowane, niezależnie od komórki wyjściowej.
Tyle teorii. A teraz dobra wiadomość dla praktyków. Excel 2016 pozwala na reje-
strowanie makropoleceń z zastosowaniem odwołań względnych (rysunek 1.166).
Rysunek 1.166.
Okno wyboru
makropolecenia
Krok za krokiem
Tworzenie makropoleceń jest prawdziwą sztuką. Z podręcznika można poznać jedy-
nie ogólne jej zasady. Dalsze umiejętności można zdobyć poprzez rejestrowanie ma-
kropoleceń i ich testowanie. Kolejnym stopniem wtajemniczenia jest rejestrowanie
makropoleceń, które wywołują inne makropolecenia.
Nie wszystko można wykonać, gdy korzysta się z makropoleceń. Narzędziem znacznie
potężniejszym, ale wymagającym głębszej wiedzy, jest korzystanie z języka programo-
wania Visual Basic for Applications. Do posługiwania się nim są konieczne:
 poznanie kilku pojęć,
 umiejętność obsługi edytora VBA,
 poznanie zasad programowania w VBA.
Wszystkie niezbędne informacje znajdziesz w kolejnych rozdziałach.

Podsumowanie
 Makropolecenie umożliwia zarejestrowanie czynności wykonywanych
w arkuszu.
 Planując makropolecenie, zastanów się, jakie czynności elementarne trzeba
wykonać, aby uzyskać oczekiwany efekt. Zadanie należy podzielić na kroki.
Muszą to być elementarne czynności, które można wykonać za pomocą
klawiatury.
 Zanim przystąpisz do rejestrowania makropolecenia, postaraj się kilka razy
wykonać czynności, które mają zostać zarejestrowane w makropoleceniu.
Dla uzyskania powtarzalności wyników wykonania makropolecenia istotne są
warunki początkowe (np. to, która komórka jest zaznaczona, gdy makropolecenie
jest uruchamiane). Jeżeli istnieje choć jeden parametr, którego wykonanie
może mieć wpływ na wykonanie makropolecenia, zanotuj to spostrzeżenie.
Nie zakładaj, że użytkownik makropolecenia zachowa się dokładnie tak jak
Ty. Uwzględnij to spostrzeżenie w makropoleceniu lub zamieść odpowiedni
komentarz.
 Domyślny format arkusza programu Excel 2010, 2013 i 2016 nie pozwala na
zapisanie arkusza wraz z makropoleceniem. Aby nie utracić makropolecenia,
należy do zapisu wybrać format pozwalający na obsługę makropoleceń.
Podczas wczytywania pliku z makropoleceniem trzeba wyrazić zgodę na
uruchomienie makra.
 Makropolecenia można edytować, korzystając z edytora Visual Basic for
Applications.
Rozdział 2.
Jak uruchomić
edytor Visual Basic
for Applications
 Jak uruchomić edytor VBA
 Jakie są domyślne zabezpieczenia arkusza Excela przed makropoleceniami
 Jak napisać i uruchomić najprostszy program w VBA
Edytor Visual Basic lub Visual Basic for Applications umożliwiają edycję makropole-
ceń i programów napisanych w VBA. Edytora nie można używać bez wcześniejszego
uruchomienia aplikacji, która z nim współdziała, np. arkusza Excela.
W dalszej części książki zostanie opisane posługiwanie się edytorem Visual Basic
współdziałającym z arkuszem kalkulacyjnym Excel 2007 i Visual Basic for Applications
współdziałającym z arkuszem kalkulacyjnym Excel 2010, 2013 i 2016.
Jeżeli korzystasz ze starszej wersji arkusza kalkulacyjnego, nie wszystkie polecenia

będą miały do niej zastosowanie. Aby uzyskać maksymalną zgodność informacji za-
wartych w książce i możliwości edytora, jest zalecane korzystanie z arkusza programu
Excel 2007, Excel 2010, Excel 2013 lub Excel 2016.
Excel 2007
Edytor Visual Basic można uruchomić na dwa sposoby:
1. Posługując się skrótem klawiaturowym.
2. Posługując się przyciskiem umieszczonym na wstążce.
Przykład 33.
Aby uruchomić edytor Visual Basic, posługując się skrótem klawiaturowym:
1. Uruchom aplikację, z którą edytor ma współdziałać, np. arkusz kalkulacyjny
Excel.
2. Wciśnij kombinację klawiszy Alt+F11.
Zapis „Alt+F11” oznacza: wciśnij i przytrzymaj klawisz Alt, naciśnij klawisz F11, po
czym zwolnij oba klawisze.
3. Po chwili na ekranie zostanie wyświetlone okno edytora Visual Basic for

Applications (rysunek 2.1).
Rysunek 2.1. Okno edytora Visual Basic

Rozdział 2.  Jak uruchomić edytor Visual Basic for Applications 79
Przykład 34.
Aby uruchomić edytor Visual Basic, posługując się przyciskiem umieszczonym na
wstążce:
1. Wczytaj arkusz zawierający makropolecenie.
2. W arkuszu Excel jest domyślnie włączone blokowanie makropoleceń.
O wyłączeniu makr informuje komunikat wyświetlony pod wstążkami
(rysunek 2.2). Kliknij przycisk Opcje.
Rysunek 2.2.
Komunikat informujący
o wyłączeniu makr
3. Zostało wyświetlone okno Opcje zabezpieczeń pakietu Microsoft Office

(rysunek 2.3). W postaci makropolecenia do komputera może dostać się
szkodliwy program. Jeżeli jesteś pewien, że makropolecenie, które zostanie
uruchomione, nie spowoduje szkody, możesz wyrazić zgodę na jego uruchomienie.
Zaznacz opcję Włącz tę zawartość.
Rysunek 2.3.
Makropolecenie
zostanie włączone

Rysunek 2.4. Po kliknięciu wstążki Widok będzie ona wyświetlana na pierwszym planie
6. Po prawej stronie wstążki Widok znajduje się ikona Makra (rysunek 2.5).
Kliknij widoczną poniżej ikony strzałkę.
Rysunek 2.5.
Pod ikoną Makra
znajduje się czarna
strzałka skierowana
ku dołowi
7. Została rozwinięta lista poleceń. Kliknij pozycję Wyświetl makra (rysunek 2.6).
Rysunek 2.6.
Lista poleceń,
które można wykonać,
wykorzystując
makropolecenia,
nie jest długa
8. Zostało wyświetlone okno Makro (rysunek 2.7). Jest w nim widoczna lista
poleceń dostępnych we wszystkich otwartych skoroszytach. Zaznacz nazwę
makropolecenia, które będzie edytowane.
Rysunek 2.7.
Makropolecenie
Kopiuj zostanie
poddane edycji

10. Zaznaczone makro zostało wyświetlone w oknie edytora Visual Basic
(rysunek 2.8).
Rysunek 2.8. Kod makra wyświetlony w oknie edytora Visual Basic
Czy makropolecenia są groźne?

W poprzednim przykładzie zetknęliśmy się z zabezpieczeniem polegającym na wyłą-
czeniu makropoleceń. Czy rzeczywiście makropolecenie może być niebezpieczne? Oka-
zuje się, że wystarczą trzy linijki kodu, aby wprowadzić w zakłopotanie osobę, która
uruchomi makro.
Przykład 35.
1. Otwórz edytor Visual Basic.
2. Wpisz w nim program:
Sub Raport()
x = MsgBox("Zawartość partycji systemowej została skasowana", vbOKOnly +
vbInformation, "Wykryto nielicencjonowane oprogramowanie")
End Sub
3. Zapisz program.
4. Uruchom makropolecenie Raport.
5. Na ekranie został wyświetlony komunikat (rysunek 2.9).
Rysunek 2.9. Czy rzeczywiście zawartość partycji systemowej została usunięta?

Oczywiście zastosowanie makropolecenia nie spowodowało żadnych zmian w partycji

systemowej. Doprowadziło jedynie do wyświetlenia komunikatu. Okno z informacją
może wyglądać bardziej przekonująco, gdy zamiast symbolu informacji będzie zawierało
symbol błędu (patrz przykład 36.).
Przykład 36.
Sub Raport()
vbCritical, "Wykryto nielicencjonowane oprogramowanie")
End Sub
3. Zapisz program.
4. Uruchom makropolecenie Raport.
Rysunek 2.10. Czy takie okno wygląda bardziej przekonująco?
Jak mogłeś zorientować się na podstawie przykładów 35. i 36., napisanie programiku,
którego wykonanie może wprowadzić w konsternację osobę uruchomiającą go, nie
zajmuje wiele czasu. Z drugiej strony skutki działania makra nie są bardzo destrukcyjne.
Przykłady pokazują mechanizm działania programu, który może zostać wykorzystany

do wyrządzenia szkody. W pliku pod nazwą Raport kryje się makropolecenie. Jeżeli
zawierzymy dobrym intencjom autora i zasugerujemy się tytułem makra — najpraw-
dopodobniej zostanie ono uruchomione. Może ono na przykład — zamiast wyświetlać
napis — losowo zamieniać liczby w komórkach arkusza.
Mam nadzieję, że wiedzy zdobytej podczas lektury tej książki nie będziesz wykorzy-
stywał do takich celów. Chciałem Ci jedynie pokazać, z jakimi niebezpieczeństwami
może się wiązać uruchamianie makropoleceń.
Excel 2010, 2013 i 2016

Obsługa edytora VBA w arkuszu Excel 2016 różni się nieco od obsługi edytora VBA
w arkuszu Excel 2007. W tym rozdziale opiszę pracę z edytorem VBA w środowisku
Excel 2016. Jest ona bardzo podobna do obsługi edytora VBA w środowisku Excel
2010 i Excel 2013. W tym rozdziale i kolejnych rozdziałach książki będę zajmował
się głównie najnowszą wersją edytora. Osoby, które mają starszą wersję programu i na-
potkają problemy z odszukaniem poleceń, proszę o powrót do rozdziału 1.
Edytor Visual Basic for Applications można uruchomić na dwa sposoby:

1. Posługując się skrótem klawiaturowym.
2. Posługując się przyciskiem umieszczonym na wstążce.
Przykład 37.
Aby uruchomić edytor Visual Basic, posługując się skrótem klawiaturowym:
1. Uruchom aplikację, z którą edytor ma współdziałać, np. arkusz kalkulacyjny
Excel.
2. Wciśnij kombinację klawiszy Alt+F11.
Zapis „Alt+F11” oznacza: wciśnij i przytrzymaj klawisz Alt, naciśnij klawisz F11,
następnie zwolnij oba klawisze.
Po chwili na ekranie zostanie wyświetlone okno edytora Visual Basic for Applications
(rysunek 2.11).
Rysunek 2.11. Okno edytora Visual Basic for Applications
Przykład 38.
Aby uruchomić edytor Visual Basic for Applications, posługując się przyciskiem umiesz-
czonym na wstążce:
1. Wczytaj arkusz zawierający makropolecenie.
2. W arkuszu Excel jest domyślnie włączone blokowanie makropoleceń.

(rysunek 2.12). W postaci makropolecenia do komputera może dostać się
szkodliwy program. Jeżeli jesteś pewien, że makropolecenie, które
zostanie uruchomione, nie spowoduje szkody, możesz wyrazić zgodę
na jego uruchomienie. Kliknij przycisk Włącz zawartość.
Rysunek 2.12.
Komunikat informujący
o wyłączeniu makr
Rysunek 2.13. Po kliknięciu wstążki Widok będzie ona wyświetlana na pierwszym planie
4. Po prawej stronie wstążki Widok znajduje się ikona Makra (rysunek 2.14).
Kliknij widoczną poniżej ikony strzałkę.
Rysunek 2.14.
Pod ikoną Makra
znajduje się czarna
strzałka skierowana
ku dołowi
5. Została rozwinięta lista poleceń. Kliknij pozycję Wyświetl makra
(rysunek 2.15).
Rysunek 2.15.
Lista poleceń,
które można wykonać,
wykorzystując
makropolecenia,
nie jest długa
6. Zostało wyświetlone okno Makro (rysunek 2.16). Jest w nim widoczna lista
poleceń dostępnych we wszystkich otwartych skoroszytach. Zaznacz nazwę
makropolecenia, które będzie edytowane.
Przycisk Makra może znajdować się również na wstążce Deweloper. Sposób jej wy-
świetlenia został omówiony w rozdziale 1.
Rysunek 2.16.
Makropolecenie
Kopiowanie_komórek
zostanie poddane
edycji
Aby zmienić treść opisu makra, po wyświetleniu okna Makro i zaznaczeniu nazwy
kliknij przycisk Opcje. W polu Opis wprowadź nowy opis.
Aby zmienić kombinację klawiszy, która uruchamia makro, po wyświetleniu okna

Makro i zaznaczeniu nazwy kliknij przycisk Opcje. W polu Klawisz skrótu wprowadź
nową kombinację.
8. Zaznaczone makro zostało wyświetlone w oknie edytora Visual Basic for

Applications (rysunek 2.17).
Rysunek 2.17. Kod makra wyświetlony w oknie edytora Visual Basic for Applications
Czy makropolecenie
może spowodować szkody?
Makropolecenie to nic innego jak program. Może on wykonać rzecz pożyteczną. Może
też siać spustoszenie. W celach dydaktycznych uruchomimy program, który może na-
straszyć użytkownika. Nic nie stoi na przeszkodzie, aby program wykonał groźbę. Zagro-
żenie jest realne.
Przykład 39.
1. Uruchom arkusz Excela.
2. Kliknij kartę Deweloper.
3. W sekcji Kod kliknij ikonę Visual Basic (rysunek 2.18).
Rysunek 2.18.
Ikona, za pomocą
której można
uruchomić edytor VBA
4. Zostało wyświetlone puste okno edytora. Dwukrotnie kliknij pozycję Arkusz1

(Arkusz1) (rysunek 2.19).
Rysunek 2.19. Edytor z pustym oknem
5. Zostało wyświetlone okno do wpisywania kodu (rysunek 2.20).

Rysunek 2.20. Edytor z pustym oknem do wpisywania kodu

Sub Raport()
vbInformation, "Wykryto nielicencjonowane oprogramowanie")
End Sub
7. Zapisz program (rysunek 2.21).
Rysunek 2.21.
Polecenia
umożliwiające
zapisanie programu
do pliku
8. Wybierz format zezwalający na obsługę makr (rysunek 2.22).

9. Uruchom makropolecenie (rysunek 2.23).
Rysunek 2.22.
Aby program
napisany w VBA
został zapisany
do pliku, należy
wybrać format
obsługujący makra
Rysunek 2.23.
Program można
uruchomić,
klikając ikonę
Rysunek 2.24.
Czy rzeczywiście
zawartość partycji
systemowej została
usunięta?
Oczywiście zastosowanie makropolecenia nie spowodowało żadnych zmian w party-

cji systemowej. Doprowadziło jedynie do wyświetlenia komunikatu. Okno z informacją
może wyglądać bardziej przekonująco, gdy zamiast symbolu informacji będzie zawierało
symbol błędu (patrz przykład 40.).
Alternatywnym sposobem uruchomienia programu napisanego w VBA jest naciśnięcie

klawisza funkcyjnego F5.
Przykład 40.
Alternatywnym sposobem uruchomienia edytora VBA jest naciśnięcie klawiszy

Alt+F11.
3. Zostało wyświetlone puste okno edytora. Dwukrotnie kliknij pozycję Arkusz1

(Arkusz1) (rysunek 2.19).
4. Zostało wyświetlone okno do wpisywania kodu (rysunek 2.20).
Sub Raport()
vbCritical, "Wykryto nielicencjonowane oprogramowanie")
End Sub
6. Zapisz program. Wybierz format zezwalający na obsługę makr.

7. Uruchom makropolecenie (rysunek 2.25).
Rysunek 2.25.
Program został
zapisany do arkusza
Przyklad_040.xlm
Rysunek 2.26.
Czy takie okno wygląda
bardziej przekonująco?
Jak mogłeś zorientować się na podstawie przykładów 39. i 40., napisanie niewielkiego
programu, którego wykonanie może wprowadzić w konsternację osobę uruchomiającą
go, nie zajmuje wiele czasu. Z drugiej strony skutki działania makra nie są bardzo de-
strukcyjne.
Przykłady pokazują mechanizm działania programu, który po uruchomieniu może wyrzą-

dzić szkody. Jeżeli zawierzymy dobrym intencjom autora i zasugerujemy się tytułem
makra, najprawdopodobniej zostanie ono uruchomione. Może ono na przykład — zamiast
wyświetlać napis — generować raport i losowo zamieniać liczby w komórkach arkusza.
Mam nadzieję, że wiedzy zdobytej podczas lektury tej książki nie będziesz wykorzy-
stywał do takich celów. Chciałem Ci jedynie pokazać, z jakimi niebezpieczeństwami
może się wiązać uruchamianie makropoleceń.
Podsumowanie
 Aby uruchomić edytor Visual Basic, posługując się skrótem klawiaturowym,
załaduj aplikację, z którą edytor ma współdziałać, np. arkusz kalkulacyjny
Excel. Wciśnij kombinację klawiszy Alt+F11.
 W arkuszu Excel jest domyślnie włączone blokowanie makropoleceń.
(rysunek 2.12). W postaci makropolecenia do komputera może dostać
się szkodliwy program. Jeżeli jesteś pewien, że makropolecenie, które
zostanie uruchomione, nie spowoduje szkody, możesz wyrazić zgodę
na jego uruchomienie. Kliknij przycisk Włącz zawartość.
 Aby napisać program w VBA, otwórz edytor VBA. Zostało wyświetlone
puste okno edytora. Dwukrotnie kliknij pozycję Arkusz1 (Arkusz1). Zostało
wyświetlone okno do wpisywania kodu. Wpisz w nim program, a następnie
go zapisz. Wybierz format zezwalający na obsługę makr.
Rozdział 3.
Okno edytora Visual
Basic for Applications
 W której części okna edytora VBA można odczytać, jakie skoroszyty
są otwarte w Excelu
 Gdzie w oknie edytora VBA można edytować właściwości obiektów
 Jak umieścić obiekt na formatce VBA
 Czy można wyrównać wymiary i położenie obiektów
Pomiędzy edytorem VBA instalowanym wraz z arkuszami Excel w wersjach 2007,

2010, 2013 i 2016 nie ma zasadniczych różnic. Opiszę edytor dostępny w pakiecie MS
Office 2016. Podane informacje będą użyteczne również dla osób korzystających z pa-
kietu z wcześniejszych wersji MS Office.
Po otwarciu edytora Visual Basic for Applications (rozdział 2. został poświęcony uru-
chamianiu edytora VBA) są domyślnie wyświetlane dwa okna (rysunek 3.1):
 Project (eksplorator projektów),
 Properties (właściwości projektów).
Rysunek 3.1. Okno edytora Visual Basic for Applications
Okno Project
W oknie Project są wyświetlone w postaci drzewa skoroszyty otwarte w Excelu. Na
rysunku 3.2 pokazano bieżący projekt, który nosi nazwę VBAProject. Poniżej jest wi-
doczny jeden arkusz (Arkusz1). Pod nim znajduje się skoroszyt (Ten_skoroszyt).
Rysunek 3.2.
Eksplorator projektów
Jeżeli skoroszyt zawiera makra, znajdują się one w folderze Modules. Moduły klas i for-
mularze użytkownika znajdują się w folderach Class Modules (moduły klas) i Forms
(formularze) (rysunek 3.3). Moduły klas są definicjami obiektów zdefiniowanych przez
użytkownika dla danego skoroszytu.
Rysunek 3.3.
Wygląd okna
eksploratora
projektów jest zależny
od zawartości projektu
Rozdział 3.  Okno edytora Visual Basic for Applications 95
Dzięki formularzom zostaje zapewniona powierzchnia, na której można umieszczać np.:

przyciski, obrazy, obszary tekstu.
Jeżeli otworzymy kolejne okno Excela, to obiekty w nim występujące zostaną rów-
nież wyświetlone w sekcji Project – VBAProject (rysunek 3.4).
Rysunek 3.4.
Mimo, że zostały
otworzone dwa
oddzielne zeszyty,
to informacje
o nich są dostępne
w jednym oknie
Okno Properties
Pod oknem Project znajduje się okno Properties. Umożliwia ono odczytywanie i edy-
towanie właściwości obiektu zaznaczonego w oknie Project.
Liczba właściwości zależy od zaznaczonego obiektu (rysunki 3.5 i 3.6).
Rysunek 3.5.
Właściwości arkusza
Rysunek 3.6.
Właściwości
formularza
Właściwością modułu jest nazwa (ang. Name). Nazwa obiektu w polu właściwości nie
musi pokrywać się z nazwą obiektu w programie Excel.
Arkusze mają więcej właściwości. Niektóre z nich mają wartość logiczną (ang. True
— prawda, opcja aktywna, lub ang. False — fałsz, opcja wyłączona). Do tej grupy należy
np. Enable Calculation (zezwól na wykonywanie obliczeń). Inne parametry mają wartość
liczbową, np.: StandardWidth (standardowa szerokość arkusza).
Okno Code
Okno Code w nowym arkuszu domyślnie nie jest widoczne (patrz rysunek 3.1). Aby
je wyświetlić, dwukrotnie kliknij nazwę arkusza lub skoroszytu, któremu ma zostać
przypisane (rysunek 3.7).
Okno Code jest największym spośród okien edytora Visual Basic for Applications.
W jego górnej części są widoczne dwie listy rozwijane.
Lista rozwijana z lewej strony służy do wybierania edytowanego obiektu. Podczas pracy
z samym kodem w polu listy jest wyświetlany domyślny obiekt General (ogólny).
Lista rozwijana z prawej strony służy do wybierania poszczególnych makr, programów

w obrębie bieżącego modułu.
Rysunek 3.7. Okno Code dla Arkusza
Pasek menu
W górnej części okna edytora VBA jest widoczny pasek menu (rysunek 3.8).
Rysunek 3.8. Pasek menu
Kliknięcie polecenia pozwala rozwinąć menu. Polecenia są w nich pogrupowane te-

matycznie:
 File (plik) — importowanie, eksportowanie, zapisywanie i drukowanie
programów,
 Edit (edycja) — edycja kodu programu,
 View (widok) — wybór opcji wyświetlania okna programu,
 Insert (wstaw) — wstawianie formularzy i modułów do projektu,
 Format (format) — porządkowanie wyglądu okna projektu,
 Debug (debug) — uruchamianie narzędzi do lokalizowania i usuwania błędów
w programie,
 Run (uruchom) — uruchamianie i zatrzymywanie programu,
 Tools (narzędzia) — konfigurowanie środowiska Microsoft Visual Basic,
 Add-Ins (dodatki) — dodawanie składników do programu Visual Basic,

 Window (okno) — określanie sposobu wyświetlania okien,
 Help (pomoc) — wyświetlanie pomocy ekranowej dotyczącej Visual Basic.
Pasek narzędziowy
Zasady posługiwania się ikonami znajdującymi się na standardowym pasku narzę-
dziowym (rysunek 3.9) poznamy w praktyce, pisząc pierwszy program w VBA.
Rysunek 3.9. Pasek narzędziowy
Pierwszy program
Czy programowanie w Visual Basicu jest trudne? Zależy to od zadania, które ma re-
alizować program. Korzystając ze zdobytych do tej pory wiadomości, możesz napisać
program, który po kliknięciu przycisku będzie wyświetlał komunikat. Pracę podzielimy na
kilka etapów:
1. Przygotowanie formularza (formatki) (przykład 41.).
2. Umieszczenie przycisku (przykład 42.).
3. Przypisanie zdarzenia przyciskowi (przykład 43.).
4. Określenie reakcji na zdarzenie (przykład 44.).
Przykład 41.
Aby przygotować formatkę:
1. Uruchom arkusz Excela 2016.
Rysunek 3.10. Narzędzia do zarządzania projektem w VBA znajdują się na wstążce Deweloper
3. W sekcji Kod kliknij ikonę Visual Basic (rysunek 3.11).
Rysunek 3.11.
Ikona Visual Basic nie jest
widoczna na pierwszym
planie bezpośrednio
po uruchomieniu arkusza
4. Zostało wyświetlone okno edytora VBA. Kliknij czarną strzałkę widoczną

obok ikony UserForm. Z listy obiektów wybierz UserForm (rysunek 3.12).
Rysunek 3.12.
Ikona Insert
UserForm
5. W oknie edytora Visual Basic for Applications pojawił się szary prostokąt
(rysunek 3.13). Jest to obszar, na którym można umieszczać obiekty.
Obok jest wyświetlany pasek narzędziowy elementów kontrolnych.
Rysunek 3.13.
Formatka i pasek
narzędziowy
Aby wyświetlić lub ukryć pasek narzędziowy, kliknij przycisk Toolbox (rysunek 3.14).
Rysunek 3.14.
Przycisk umożliwiający ukrywanie lub
wyświetlanie paska narzędziowego
6. Wyświetlona formatka ma właściwości domyślne. Pozwalają one na rozpoczęcie

z nią pracy. Można je zmienić. Najprościej jest kliknąć puste pole wewnątrz
formatki i z podręcznego menu wybrać polecenie Properties (rysunek 3.15).
Rysunek 3.15.
Z podręcznego
menu można
wybrać polecenie
umożliwiające zmianę
właściwości formatki
7. Zmienimy nazwę formatki. W oknie Properties dwukrotnie kliknij właściwość

Name (rysunek 3.16).
Rysunek 3.16.
Właściwość Name
odpowiada
za nazwę formatki
8. Wpisz z klawiatury Projekt1. W nazwie nie może występować spacja.

9. Naciśnij klawisz Enter.
10. Nazwa formatki została zmieniona (rysunek 3.17).
Rysunek 3.17.
Formatka
ma nową nazwę
11. Zmienimy kolor tła formatki. W oknie Properties kliknij właściwość BackColor.
12. Kliknij czarną strzałkę skierowaną ku dołowi (rysunek 3.18). Zostały

wyświetlone barwy dostępne w systemie.
Rysunek 3.18.
Barwy dostępne
w systemie
13. Kliknij kartę Palette (rysunek 3.19). Została wyświetlona pełna paleta barw.
Rysunek 3.19.
Pełna paleta barw
14. Kliknij kolor żółty. Formatka zmieniła kolor (rysunek 3.20).
Rysunek 3.20.
Formatka
zmieniła kolor
15. Zmienimy domyślne położenie formatki. W oknie Properties kliknij właściwość

StartUpPosition.
16. Kliknij czarną strzałkę skierowaną ku dołowi, która znajduje się na prawo
od wartości właściwości.
17. Z rozwiniętej listy opcji wybierz 2 - CenterScreen (rysunek 3.21).
Rysunek 3.21.
Formatka
będzie wyświetlana
na środku ekranu
18. Sprawdzimy, czy ustawienia zostały prawidłowo zapamiętane. Kliknij pasek

tytułu okna formatki. Naciśnij klawisz F5.
19. Został wyświetlony arkusz Excela wraz z formatką (rysunek 3.22).
Centrowanie dotyczy całego ekranu, a nie okna o aktualnych wymiarach.
Rysunek 3.22. Arkusz wraz z formatką
Przykład 42.
Aby umieścić na formatce przycisk:
1. Wykonaj polecenia zawarte w przykładzie 41.
2. Zatrzymaj działanie programu. W oknie edytora Microsoft Visual Basic for
Application kliknij ikonę Reset (rysunek 3.23).
Rysunek 3.23.
Przed rozpoczęciem edycji
programu należy zatrzymać
jego działanie
3. Na pasku Toolbox kliknij przycisk CommandButton (rysunek 3.24).
Rysunek 3.24.
Przycisk
CommandButton
znajduje się
na pasku Toolbox
4. Umieść kursor nad formatką. Zmienił on kształt ze strzałki na krzyżyk

z prostokątem. Krzyżyk wskazuje, gdzie zostanie umieszczony obiekt.
Prostokąt informuje o rodzaju obiektu (rysunek 3.25).
Rysunek 3.25.
Krzyżyk wskazuje,
gdzie zostanie
umieszczony obiekt.
Prostokąt informuje
o rodzaju obiektu
5. Umieść kursor nad miejscem, w którym ma się znaleźć jeden narożnik przycisku.
7. Przeciągnij kursor do miejsca, w którym ma się znaleźć przeciwległy
narożnik przycisku.
9. Na formatce pojawił się przycisk (rysunek 3.26).
10. Zmienimy kolor przycisku. Kliknij przycisk lewym klawiszem myszy.
11. Z podręcznego menu wybierz polecenie Properties.
12. W oknie Properties kliknij właściwość BackColor.
Rysunek 3.26.
Na formatce
pojawił się przycisk
13. Kliknij czarną strzałkę skierowaną ku dołowi (rysunek 3.27). Zostały

wyświetlone barwy dostępne w systemie.
Rysunek 3.27.
Barwy dostępne
w systemie
14. Kliknij kartę Palette (rysunek 3.28). Została wyświetlona pełna paleta barw.
Rysunek 3.28.
Pełna paleta barw
15. Kliknij kolor zielony. Przycisk zmienił kolor (rysunek 3.29).
Rysunek 3.29.
Przycisk zmienił kolor
16. Zmienimy napis na przycisku. W oknie Properties dwukrotnie kliknij

właściwość Caption (rysunek 3.30).
Rysunek 3.30.
Napis na przycisku
można edytować
17. Wpisz nazwę Klikacz (rysunek 3.31).
Rysunek 3.31.
Tekst wpisywany
w polu Caption
jest widoczny
na przycisku
18. Zmienimy krój czcionki na przycisku. W oknie Properties kliknij właściwość

Font (rysunek 3.32).
Rysunek 3.32.
Trzy kropki wskazują,
że po kliknięciu
właściwości zostanie
otworzone okno
19. Z listy czcionek wybierz Arial, styl — Pogrubiona, rozmiar 16 (rysunek 3.33).
Rysunek 3.33.
Zmiana wyglądu
napisu na przycisku

21. Nowe ustawienia zostały zastosowane do napisu (rysunek 3.34).
Rysunek 3.34.
Napis na przycisku
po zmianie
wyglądu czcionki
Przykład 43.
Aby automatycznie dostosować rozmiar przycisku do napisu:
1. Wykonaj przykład 42.
2. W oknie Properties odszukaj właściwość AutoSize (rysunek 3.35). Rozwiń
listę dostępnych wartości. Zaznacz True (prawda).
Rysunek 3.35.
Wartość True
powoduje, że opcja
staje się aktywna
3. Rozmiar przycisku został dostosowany do napisu (rysunek 3.36).
Rysunek 3.36.
Wartość True
powoduje, że opcja
staje się aktywna
4. Zmień opis przycisku (rysunek 3.37).
Rysunek 3.37.
Zmiana rozmiaru
napisu powoduje, że
przycisk dostosowuje
swoje rozmiary
Przykład 44.
Aby przypisać zdarzenie przyciskowi:
1. Wykonaj przykład 43.
2. Kliknij puste pole obok przycisku, aby usunąć zaznaczenie (rysunek 3.38).
Rysunek 3.38.
Przycisk nie jest
aktywnym obiektem
3. Dwukrotnie kliknij przycisk widoczny na formatce.

4. Zostało wyświetlone okno edycji kodu (rysunek 3.39).
Rysunek 3.39.
Okno edycji kodu
z początkiem
i końcem kodu
obsługi pojedynczego
kliknięcia
5. W oknie Code rozwiń listę znajdującą się po prawej stronie. Zaznacz DblClick
(rysunek 3.40).
Rysunek 3.40.
Zdarzenie DblClick
zachodzi, gdy przycisk
zostanie dwukrotnie
kliknięty
6. Usuń kod obsługi zdarzenia CommandButton1_Click() (rysunek 3.41).
Rysunek 3.41.
Okno z zaznaczonym
kodem obsługi
pojedynczego
kliknięcia
Przykład 45.
Aby określić reakcję na zdarzenie:
2. W oknie kodu pomiędzy liniami początku i końca procedury wpisz
X=MsgBox("Hej!") (rysunek 3.42).
Rysunek 3.42. Po dwukrotnym kliknięciu przycisku na ekranie powinno pojawić się okno z tekstem: Hej!
3. Pora na uruchomienie programu. Naciśnij klawisz F5.

4. Program został uruchomiony. Na ekranie została wyświetlona formatka

z przyciskiem (rysunek 3.43).
Rysunek 3.43. Formatka z przyciskiem

5. Kliknij przycisk. Nie wywołasz żadnej reakcji ze strony programu, ponieważ
została usunięta obsługa pojedynczego kliknięcia (rysunek 3.42).
6. Dwukrotnie kliknij przycisk.
7. Zostało wyświetlone okno komunikatu (rysunek 3.44).
Rysunek 3.44.
Okno komunikatu
Przełączanie między widokami

Wykonując czynności opisane w przykładach od 41. do 45., można napisać prosty program
reagujący na zdarzenie. Warto jeszcze zastanowić się, jak ułatwić sobie ciężką pracę
twórcy programów.
Przykład 46.
Aby przełączać program między widokiem kodu a obiektu:
2. Wybierz polecenia View/Code lub naciśnij klawisz F7 (rysunek 3.45).
Rysunek 3.45.
Polecenia
umożliwiające
wyświetlenie
widoku kodu
3. Na pierwszym planie zostało wyświetlone okno kodu (rysunek 3.46).
Rysunek 3.46. Na pierwszym planie jest widoczne okno kodu programu
4. Wybierz polecenia View/Object lub naciśnij klawisze Shift+F7 (rysunek 3.47).
Rysunek 3.47. Na pierwszym planie jest widoczne okno z widokiem obiektów

Wyrównywanie obiektów
Obiekty na formularzu można umieszczać ręcznie. Aby miały one równe wymiary
i były wyrównane do linii, trzeba żmudnie śledzić kropki rastra. Pół biedy, gdy trzeba
umieścić dwa przyciski. O oczopląs może przyprawić umieszczenie kilkudziesięciu.
Na szczęście tę czynność można przerzucić na program.
Przykład 47.
Aby wyrównać wymiary obiektów na formularzu:
1. Umieść na formatce dwa przyciski (patrz przykład 42.).
2. Wciśnij i przytrzymaj klawisz Shift.
3. Kliknij oba obiekty.
4. Zwolnij klawisz Shift (rysunek 3.48).
Rysunek 3.48.
Formatka
z zaznaczonymi
dwoma przyciskami
5. Wybierz polecenie Format/Make Same Size/Both (rysunek 3.49).
Rysunek 3.49.
Przyciski będą miały
tę samą szerokość
i wysokość
6. Wymiary przycisków zostały wyrównane (rysunek 3.50).
Rysunek 3.50.
Przyciski
z rysunku 3.48
mają ujednolicone
wymiary
Przykład 48.
Aby wyrównać do lewej krawędzi położenie obiektów na formularzu:
1. Umieść na formatce dwa przyciski i wyrównaj ich wymiary
(patrz przykłady 42. i 47.). Istotna jest kolejność zaznaczania obiektów.
Punktem odniesienia jest element, który został wybrany jako ostatni.
2. Wybierz polecenie Format/Align/Lefts (rysunek 3.51).
Rysunek 3.51.
Przyciski zostaną
wyrównane do lewej
3. Położenie przycisków z rysunku 3.40 zostało wyrównane do lewej

(rysunek 3.52).
Rysunek 3.52.
Przyciski
z rysunku 3.50 zostały
wyrównane do lewej
krawędzi przycisku
odniesienia
Przykład 49.
Aby wycentrować w poziomie położenie obiektów na formularzu:
(patrz przykłady 42. i 47.).
2. Wybierz polecenie Format/Center in Form/Horizontally (rysunek 3.53).
Rysunek 3.53.
Przyciski zostaną
wyśrodkowane
w poziomie
3. Położenie przycisków zostało wycentrowane (rysunek 3.54).

Rysunek 3.54.
Przyciski zostały
wyśrodkowane
w poziomie
Przykład 50.
Aby obiekty umieścić jeden pod drugim:
(patrz przykłady 42. i 47.).
2. Wybierz polecenie Format/Vertical spacing/Remove (rysunek 3.55).
Rysunek 3.55.
Przyciski zostaną
umieszczone
jeden pod drugim
3. Odległość w pionie pomiędzy przyciskami została zredukowana do zera

(rysunek 3.56).
Rysunek 3.56.
Przyciski zostały
umieszczone jeden
przy drugim. Punktem
odniesienia jest
element, który został
wybrany jako ostatni.
Strzelanie z armaty do komara

W rozdziale pierwszym poznaliście zasady rejestrowania makropoleceń. Czy jest sens
korzystać z języka VBA, skoro makropolecenia pozwalają na automatyzowanie pracy
w programach pakietu Microsoft Office? Czy VBA nie jest zbyt potężnym narzędziem?
Makropolecenia mają istotne ograniczenia. Podczas pracy w środowisku Windows bar-

dzo często korzystamy z myszy: klikamy coś, zaznaczamy itp. Rejestrator makropoleceń
nie zapisuje ruchów myszy. Zapisywane są jedynie polecenia „wydane” programowi oraz
ich skutki.
W środowisku Windows często stosuje się technikę „przeciągnij i upuść”. Jest ona wy-
konywana przy wykorzystaniu myszy, dlatego rejestrator makropoleceń jej nie zapisze.
Kiedy korzystać z makropoleceń, a kiedy z programów napisanych w VBA? Makro-

polecenia są dostępne dla użytkowników, którzy nie znają VBA. Pozwalają one np.
na tworzenie globalnych przypisań klawiszy, wykonywanie akcji lub ich serii podczas
uruchamiania arkusza Excela. Programy napisane w VBA pozwalają: korzystać z funkcji
wbudowanych lub tworzyć własne, obsługiwać komunikaty o błędach, tworzyć lub mo-
dyfikować obiekty, wykonywać działania na poziomie systemu, przekazywać argumenty
do własnych procedur języka Visual Basic.
Jeśli terminy użyte w ostatnim akapicie zabrzmiały obco — nie zrażaj się. Co one ozna-
czają i jak praktycznie z nich korzystać, dowiesz się z kolejnych rozdziałów książki.
Podsumowanie
 W oknie Project są wyświetlone w postaci drzewa skoroszyty otwarte w Excelu.
Okno Properties umożliwia odczytywanie i edytowanie właściwości obiektu
zaznaczonego w oknie Project. Okno Code umożliwia edycję kodu programu.
 Obiekty można umieszczać na formatce, wybierając je na pasku Toolbox,
a następnie wskazując miejsce, w którym mają się znaleźć.
 Aby wyrównać położenie lub wymiary obiektów, trzeba je zaznaczyć,
a następnie wybrać polecenie Format/Align i symbol linii wyrównania
lub Make Same Size i symbol wymiaru, który ma zostać ujednolicony.
 Aby wyrównać do lewej krawędzi położenie obiektów, trzeba je zaznaczyć,
a następnie wybrać polecenie Format/Align/Lefts.
 Aby wycentrować położenie obiektów na formularzu, trzeba je zaznaczyć,
a następnie wybrać polecenie Format/Center in Form/Horizontally.
 Aby umieścić obiekty jeden pod drugim, trzeba je zaznaczyć, a następnie
wybrać polecenie Format/Vertical spacing/Remove.
 Punktem odniesienia jest element, który został wybrany jako ostatni.
Rozdział 4.
Zmienne
 Czy zmienna może mieć dowolną nazwę
 Jaką rolę odgrywają deklaracje typów danych
 Jak wymusić deklarowanie wszystkich zmiennych
Arkusza Excela używamy do przetwarzania danych. W najprostszym wypadku dane

mogą znajdować się w zakresach arkusza (rysunek 4.1). Użytkownik musi tylko pa-
miętać, aby dane były aktualne i poprawnie wpisane. Autor programu z kolei musi za-
dbać o to, aby zastosowanie programu umożliwiło odczytanie danych z odpowiednich
komórek.
Rysunek 4.1.
Dane zawarte
w zakresie arkusza
Innym rozwiązaniem jest przechowywanie danych w zadeklarowanych zmiennych.

Zmienna to nazwane miejsce w pamięci. Przechowuje ona wartość aż do następnego
przypisania lub zakończenia pracy programu.
Przypisanie ma postać:
Nazwa_zmiennej = wartość_zmiennej
Nazwy zmiennych znajdują się po lewej stronie znaku równości.

Nazwy zmiennych w VBA

Nazwa zmiennej nie może być dowolna. Przy jej nadawaniu należy zwracać uwagę na
poniższe warunki:
 Pierwszy znak nazwy zmiennej musi być literą.
 W nazwie mogą występować znaki alfanumeryczne i niektóre znaki
interpunkcyjne.
 W nazwach nie mogą występować słowa zastrzeżone (np. if, next).
 W nazwach nie mogą występować spacje i kropki.
 W celu zwiększenia czytelności nazw zamiast spacji można używać znaku
podkreślenia _, np. rata_kredytu.
 W VBA w nazwach nie jest rozróżniana wielkość liter. W celu zwiększenia
czytelności złożonych nazw można stosować w środku wyrazów wielkie
litery, np. RataKredytu.
 W nazwach nie można umieszczać znaków używanych w deklaracjach:
#, $, & oraz !.
 Maksymalna długość nazwy wynosi 256 znaków. To ograniczenie rzadko ma
znaczenie praktyczne, ponieważ nazwy stosowane w programach są znacznie krótsze.
Zamieszczone w dalszej części książki przykłady wymagają uruchomienia arkusza

kalkulacyjnego Excel, a następnie edytora VBA — patrz przykład 37.
Przykład 51.
Aby sprawdzić, jak edytor VBA sygnalizuje wprowadzenie nazwy zmiennej, która nie
jest literą:
1. Kliknij arkusz prawym przyciskiem myszy.
2. Z podręcznego menu wybierz polecenie View Code (rysunek 4.2).
Rysunek 4.2.
Polecenie,
które pozwala
na wyświetlenie
okna służącego
do edycji kodu
programu
Rozdział 4.  Zmienne 117
3. Zostało wyświetlone okno Code (rysunek 4.3).
Rysunek 4.3. Okno edytora VBA z pustym oknem Code

4. W oknie Code wpisz Sub zmienne(). Oznacza to początek procedury noszącej
nazwę zmienne (rysunek 4.4).
Rysunek 4.4.
Pierwsza linia kodu

6. Znak wstawiania przeskoczył o jedną linię w dół. Edytor dodał linię End Sub
(rysunek 4.5) oznaczającą koniec procedury.
Rysunek 4.5.
Linie wyznaczające
początek i koniec
procedury
7. Sprawdzimy, jak zostanie zasygnalizowana sytuacja, w której nazwa zmiennej

będzie rozpoczynała się od znaku innego niż litera. Wpisz @=1 (rysunek 4.6).
Rysunek 4.6.
Dopóki nie damy edytorowi
znać, że skończyliśmy
wpisywanie linii, błąd
nie jest sygnalizowany
8. Naciśnij klawisz F5.

9. Został wyświetlony komunikat o błędzie (rysunek 4.7). Podświetlenie pokazuje
miejsce wystąpienia błędu.
Rysunek 4.7.
Nazwa zmiennej nie
zaczyna się od litery

11. Wiemy już, jak jest sygnalizowany błąd. Trzeba go jeszcze usunąć.
Zastąp znak @ przez x.
13. W liniach programu nie wykryto błędu (rysunek 4.8).
Rysunek 4.8.
Nazwa zmiennej
została zaakceptowana
Przykład 52.
Aby sprawdzić, jak edytor VBA sygnalizuje wprowadzenie nazwy zmiennej, która będzie
identyczna jak słowo zastrzeżone:
1. Wykonaj polecenia z przykładu 30. do punktu 6. włącznie.
2. Sprawdzimy, jak zostanie zasygnalizowana sytuacja, w której nazwa zmiennej
będzie identyczna jak słowo zastrzeżone. Wpisz if=1 (rysunek 4.9).
Rysunek 4.9.
Nazwa zmiennej
jest identyczna jak
słowo zastrzeżone

4. Został wyświetlony komunikat o błędzie (rysunek 4.10). Podświetlenie

pokazuje miejsce wystąpienia błędu.
Rysunek 4.10.
Nazwa zmiennej
jest identyczna
jak instrukcja
programu

6. Wiemy już, jak jest sygnalizowany błąd. Trzeba go jeszcze usunąć.
Zastąp if przez ii.
8. W liniach programu nie wykryto błędu (rysunek 4.11).
Rysunek 4.11.
ii jest poprawną
nazwą zmiennej
Pułapki systemu komunikatów

System komunikatów nie jest idealny. W niektórych przypadkach wskazuje wystąpienie
błędu i wyjaśnia jego przyczynę. W innych może wprowadzać w błąd.
Na rysunku 4.7 jest widoczny komunikat Syntax error, czyli „błąd składni”. W połą-
czeniu z zaznaczeniem znaku, którego dotyczy, pozwala na wydedukowanie, co trzeba
poprawić.
Na rysunku 4.10 został wyświetlony komunikat Syntax error. Edytor analizuje kod od
strony lewej do prawej. Po napotkaniu instrukcji if zakłada, że została ona użyta pra-
widłowo, a błędne jest to, co znajduje się na prawo od instrukcji. W przykładzie chodziło
nam o przypisanie zmiennej wartości liczbowej. Prawidłowe jest to, co znajduje się na
prawo od zmiennej. Błędna jest nazwa zmiennej.
Typy danych
Typy danych określają, ile miejsca powinno być zarezerwowane w pamięci dla da-
nych określonego typu oraz jak należy interpretować zawartość tej pamięci. Teore-
tycznie użytkownik nie musi zastanawiać się, jakiego rodzaju lub z jakiego przedziału
wartości zostaną przypisane zmiennej. Visual Basic for Applications zrobi to za niego.
Zdanie się na ustawienia domyślne powoduje, że spada szybkość działania programu,
a zarządzanie zasobami pamięci jest bardzo rozrzutne. Podczas pracy z małymi progra-
mami nie jest to istotna wada. Z czasem Twoje programy będą coraz większe. Może
dojść do sytuacji, w której ich wykonywanie będzie trwało zbyt długo lub nie powiedzie się
z powodu braku pamięci. Warto zatem od samego początku nauki programowania zwra-
cać uwagę na zakres wartości, jakie mogą przyjmować przetwarzane dane (tabela 4.1).
Tabela 4.1. Typy danych w języku VBA

Liczba używanych
Typ danych Zakres wartości
bajtów
Byte (bajt) 1 bajt Od 0 do 255
Boolean (wartość logiczna) 2 bajty True (prawda) lub False (fałsz)
Integer (liczba całkowita). 2 bajty Od –32 768 do 32 767
Z tego typu danych można
korzystać, jeśli wiadomo,
że zmienna będzie przyjmowała
wartości całkowite i nie
przekroczy 32 767.
W przeciwnym razie należy
używać zmiennej typu Long.
Long (długa liczba całkowita) 4 bajty Od –2 147 483 648 do 2 147 483 647
LongLong (liczba całkowita 8 bajtów Od –9 223 372 036 854 775 808
LongLong) do 9 223 372 036 854 775 807
LongPtr (liczba całkowita Long 4 bajty w systemach Od –2 147 483 648 do 2 147 483 647
w systemach 32-bitowych 32-bitowych w systemach 32-bitowych lub
lub 64-bitowych) lub 8 bajtów od –9 223 372 036 854 775 808
w systemach do 9 223 372 036 854 775 807
64-bitowych w systemach 64-bitowych
Single (liczba pojedynczej 4 bajty Od –3,402823E38 do –1,401298E–45
precyzji z zapisem dla wartości ujemnych. Od 1,401298E–45
zmiennoprzecinkowym) do 3,402823E38 dla wartości dodatnich
Double (liczba podwójnej 8 bajtów Od –1,79769313486231E308
precyzji z zapisem do –4,94065645841247E–324
zmiennoprzecinkowym). dla wartości ujemnych.
Excel w obliczeniach używa Od 4,94065645841247E–324
danych typu Double. Aby nie do 1,79769313486232E308
utracić dokładności, używanie dla wartości dodatnich
tego typu danych do obliczeń
jest zalecane.
Currency (format walutowy, 8 bajtów Od –9223372036854775808
liczba całkowita skalowana) do 922337203 685477,5807
Tabela 4.1. Typy danych w języku VBA (ciąg dalszy)

Liczba używanych
Typ danych Zakres wartości
bajtów
Decimal (liczba dziesiętna) 14 bajtów +/–79228162514264337593543950335
bez części dziesiętnej
+/–7,9228162514264337593543950335
z 28 miejscami po przecinku.
Najmniejszą liczbą jest
+/–0,0000000000000000000000000001
Date (data) 8 bajtów Od 8 stycznia 100 roku do 31 grudnia
9999 roku
Object (obiekt) 4 bajty Dowolne odwołanie do obiektu
String (łańcuch o zmiennej 10 bajtów + długość Od 0 do 2 bilionów
długości) łańcucha
String (łańcuch o stałej długości) Długość łańcucha Od 1 do około 65 400
Variant (z liczbami) 16 bajtów Dowolna wartość liczbowa mniejsza
od maksymalnej wartości zakresu typu
danych Double
Variant (ze znakami) 22 bajty + długość Od 0 do 2 bilionów
łańcucha
Type (zdefiniowany przez Liczba zależna Zakres wartości każdego elementu zależy
użytkownika) od elementów od jego typu danych
Do numerowania wierszy arkusza należy używać zmiennej typu Long. Zmiennej typu
Integer nie stosuje się w tym celu z uwagi na zbyt małą wartość.
Przykład 53.
Aby zadeklarować, że zmienna Gucio może przyjmować wartości logiczne:
1. Wyświetl okno Code (rysunek 4.3).
2. W oknie Code wpisz Sub Gucio() (rysunek 4.12).
Rysunek 4.12.
Pierwsza linijka
programu

4. Znak wstawiania przeskoczył o jedną linię w dół. Edytor dodał linię End Sub.
5. Umieść znak wstawiania pomiędzy deklaracją początku i końca procedury
(rysunek 4.13).
Rysunek 4.13.
Pierwsza i ostatnia
linia procedury
6. Wpisz z klawiatury deklarację Dim Gucio As B. Zostały wyświetlone możliwe

do wpisania słowa. Lista rozpoczyna się od takiej litery, jaka została wpisana
z klawiatury — czyli od B. Zaznacz Boolean (rysunek 4.14).
Rysunek 4.14.
Edytor podpowiada,
jakiego słowa można
użyć w programie

8. Deklaracja została uzupełniona słowem z listy (rysunek 4.15).
Rysunek 4.15.
Zmienna Gucio
może przyjmować
wartość logiczną
9. Edytor będzie pamiętał, że zmienna Gucio ma przyjmować jedną z dwóch

wartości logicznych: prawda (ang. True) lub fałsz (ang. False). Pod deklaracją
typu zmiennej wpisz Gucio =.
10. Zostało wyświetlone menu z dostępnymi wartościami. Zależą one od
zadeklarowanego typu zmiennej (rysunek 4.16). Zaznacz wartość False (Fałsz).
Rysunek 4.16.
Zmienna logiczna
może przyjmować
dwie wartości
11. Potwierdź wybór naciśnięciem klawisza Enter.

12. Zmiennej Gucio została przypisana wartość logiczna. Punkt wstawiania
przeskoczył do kolejnej linii (rysunek 4.17).
Rysunek 4.17.
Zmienna logiczna
z przypisaną wartością
Zmienna nie musi, ale może nazywać się tak samo jak procedura.
Przykład 54.
Aby sprawdzić, jak deklaracje typów danych wpływają na czas wykonywania programu:
1. Uruchom arkusz kalkulacyjny Excel i edytor VBA. W oknie Code wpisz
program (rysunek 4.18). Składa się on z modułu deklaracji, wyliczeń oraz
pomiaru czasu. Zmienne: A, B, C, D, E, F, i, j są typu Integer. Mogą
przechowywać liczby całkowite. W przykładzie jest to wystarczające. Pozwala
na oszczędność miejsca w pamięci (jedna zmienna jest zapisywana przy
wykorzystaniu 2 bajtów — patrz tabela 4.1). Zmienne: Start, Koniec są typu
Date. Przechowują one informacje o czasie. Jedna zmienna jest zapisywana
przy wykorzystaniu 8 bajtów. Jest to oszczędność w porównaniu z brakiem
deklaracji. Jeżeli typ danych nie zostanie wyspecyfikowany, VBA domyślnie
zarezerwuje dla niego maksymalną liczbę bajtów, czyli… 22 bajty + długość
łańcucha.
Rysunek 4.18.
Program do pomiaru
wpływu deklaracji
na czas wykonywania
programu
2. Naciśnij klawisz F5. Program został uruchomiony. Przez chwilę na ekranie

— zamiast strzałki kursora — jest wyświetlana klepsydra.
3. Po zakończeniu programu jest wyświetlane okno z podanym w sekundach
czasem wykonywania programu (rysunek 4.19).
Rysunek 4.19.
Czas wykonania
programu
z deklaracjami
typu zmiennych
4. Odczytaj wyniki i kliknij przycisk OK.

5. Usuń z programu deklaracje (rysunek 4.20).
Rysunek 4.20.
Program
z rysunku 4.19
po usunięciu
deklaracji typów
zmiennych

czasem wykonywania programu (rysunek 4.21).
Rysunek 4.21.
Czas wykonywania
programu bez
deklaracji typów
zmiennych był
pięć razy dłuższy
Czasy wykonywania obu wersji programu na różnych komputerach mogą się różnić
od pokazanych na obrazkach, ale generalnie zadeklarowanie typów zmiennych skraca
czas wykonywania programu.
9. Sprawdzimy jeszcze, jak na czas wykonania programu wpływa zadeklarowanie

zmiennych w typie o zbyt dużej długości. W oknie Code wpisz program
(rysunek 4.22). Zmienne: A, B, C, D, E, F, i, j są typu Variant. Jedna
zmienna jest zapisywana przy wykorzystaniu 22 bajtów + długość łańcucha.
Rysunek 4.22.
Program
z rysunku 4.19
po zmianie deklaracji
typów zmiennych
jednoliterowych
na Variant
czasem wykonywania programu (rysunek 4.23). Zadeklarowanie typu zmiennej
na wyrost powoduje takie same problemy jak niezadeklarowanie jej w ogóle.
Rysunek 4.23.
Czas wykonywania
programu bez deklaracji
typów zmiennych
i z deklaracją zmiennych
typu Variant
jest identyczny

13. Sprawdzimy, czy program będzie działał, gdy jako zmienne zadeklarujemy
liczby używające pamięci w sposób najbardziej oszczędny. W oknie Code
wpisz program (rysunek 4.24). Zmienne: A, B, C, D, E, F, i, j są typu Byte.
Jedna zmienna jest zapisywana przy wykorzystaniu 1 bajta.
Rysunek 4.24.
Program
z rysunku 4.19
po zmianie deklaracji
typów zmiennych
jednoliterowych
na Byte
14. Naciśnij klawisz F5. Program został uruchomiony.

15. Na ekranie został wyświetlony komunikat o przekroczeniu zadeklarowanego
zakresu danych (rysunek 4.25).
Rysunek 4.25.
Program nie został
wykonany. Wyliczona
wartość nie zmieściła
się w przewidzianym
dla niej typie zmiennej
16. Sprawdzimy, jak program wskazuje miejsce wystąpienia błędu.

Kliknij przycisk Debug.
17. Zostało wyświetlone okno programu. Kolorem i strzałką jest zaznaczony etap,
podczas wykonywania którego powstał błąd (rysunek 4.26).
Rysunek 4.26.
W programie zostaje
wyróżnione miejsce,
w którym wykryto
błąd. Nie oznacza to,
że wyróżniona
instrukcja jest
niepoprawna.
W przykładzie błędna
jest deklaracja na
samym początku
programu. Podczas
wykonywania pętli
błąd dał o sobie znać
Przy deklarowaniu typów zmiennych należy posługiwać się typami, zajmującymi naj-
mniejszą liczbę bajtów, ale obsługującymi wszystkie dane, które mogą im zostać
przypisane.
Domyślnym formatem liczbowym stosowanym w programie Excel przy wpisywaniu

liczb jest Ogólny. Aby nie utracić dokładności danych, należy w deklaracjach uży-
wać zmiennych, które nie będą zmniejszać dokładności obliczeń.
Pułapki braku deklaracji

Zdanie się na program przy deklarowaniu typu zmiennych prowadzi nie tylko do roz-
rzutnego gospodarowania pamięcią. Innym zagrożeniem są… możliwe błędy w obli-
czeniach. Dane typu Variant zmieniają bowiem swój typ w zależności od operacji wy-
konywanej na danych.
Przykład 55.
Aby sprawdzić, jak zmieniają się typy danych w zależności od wykonanego działania:
1. Uruchom arkusz kalkulacyjny Excel i edytor VBA. W oknie Code wpisz program
(rysunek 4.27). W drugiej linii zmiennej Zmienna jest przypisywany trójznakowy
łańcuch 002. W linii trzeciej jest wyświetlana zawartość zmiennej Zmienna.
Rysunek 4.27.
Program obrazujący,
jak interpreter
zmienia typy danych
W linii czwartej na zmiennej jest wykonywane działanie. Jest ona dzielona

przez jeden. Interpreter nie sygnalizuje błędu, ale… zmienia typ danych
na liczbowy. Działanie jest wykonywane. W linii piątej jest wyświetlana
zawartość zmiennej Zmienna.
3. Na ekranie został wyświetlony komunikat pierwszy (rysunek 4.28).
Rysunek 4.28.
Po dojściu do linii
trzeciej zmienna
ma wartość tekstową
— na lewo od liczby
są wyświetlane zera

5. Na ekranie został wyświetlony komunikat drugi (rysunek 4.29).
Rysunek 4.29.
Po dojściu do linii
piątej zmienna
ma wartość liczbową
— na lewo od liczby
nie są wyświetlane
zera
Przykład 56.
Aby sprawdzić, jak nieuwzględnienie typu danych może wprowadzić w błąd:
program (rysunek 4.30). W drugiej linii zmiennej Zmienna jest przypisywany
trójznakowy łańcuch 002. W linii trzeciej jest wyświetlana zawartość zmiennej
Zmienna. W linii czwartej na zmiennej jest wykonywane działanie. Jest ona
sumowana z taką samą zmienną. W linii piątej jest wyświetlana zawartość
zmiennej Zmienna.
Rysunek 4.30.
Program obrazujący,
jak nieuwzględnienie
typu danych prowadzi
do błędu

Rysunek 4.31.
Zmienna o nazwie
Zmienna zawiera
liczbę 002

Rysunek 4.32.
W przypadku łańcuchów
znaków znak + został
potraktowany nie jako
symbol dodawania,
ale łączenia łańcuchów

7. Sprawdzimy, co się stanie, gdy zamiast sumować zmienną z taką samą
zmienną, pomnożymy ją przez dwa. Zmień czwartą linię programu
(rysunek 4.33).
Rysunek 4.33.
Zsumowanie zmiennej
z taką samą zmienną
zostało zastąpione
pomnożeniem
przez dwa

Rysunek 4.34.
Znak * został
potraktowany jako
symbol mnożenia
Wymuszanie deklarowania zmiennych

Z powyższych przykładów wynika, moim zdaniem, ważny wniosek. Brak deklaracji zmien-
nych może prowadzić do spowolnienia działania lub błędnego wykonania programu.
W edytorze VBA można wymusić deklarowanie zmiennych. Jeżeli w trakcie wykony-

wania programu interpreter napotka zmienną niezadeklarowaną, zasygnalizuje błąd.
Przykład 57.
Aby włączyć wymuszanie deklarowania zmiennych:
1. Uruchom arkusz kalkulacyjny Excel i edytor VBA. Wybierz polecenia
Tools/Options (rysunek 4.35).
Rysunek 4.35.
Fragment menu Tools
2. Zostało wyświetlone okno Options (rysunek 4.36). Domyślnie aktywna jest karta
Editor. W sekcji Code Settings zaznacz opcję Require Variable Declaration.
Rysunek 4.36.
Interpreter
może wymuszać
deklarowanie
wszystkich zmiennych
Aby ustawienia odnosiły się do programu, należy w pierwszym wierszu wpisać in-
strukcję Option Explicit.
Przykład 58.
Aby sprawdzić, jak sygnalizowany jest brak deklaracji zmiennej:
program (rysunek 4.37). W linii pierwszej jest wpisana instrukcja wymuszająca
sprawdzanie zadeklarowania wszystkich zmiennych. W liniach trzeciej
i czwartej są zadeklarowane typy zmiennych x i y. W liniach piątej i szóstej są
przypisane wartości zmiennych x i y. W linii siódmej znajduje się zmienna Z,
której typ nie został zadeklarowany.
Rysunek 4.37.
Program
z niezadeklarowaną
zmienną

3. Na ekranie został wyświetlony komunikat o błędzie (rysunek 4.38).
Rysunek 4.38.
Zostało zaznaczone
miejsce wykrycia błędu
4. Kliknij przycisk Pomoc.

5. Zostało otworzone okno przeglądarki. Po chwili została załadowana strona

pomocy (rysunek 4.39).
Rysunek 4.39. Podpowiedź, gdzie należy szukać błędu
Zasięg deklaracji
W przykładzie 53. do deklarowania zmiennych było używane wyrażenie Dim. W za-
leżności od miejsca zastosowania deklaracji w programie ma ona różny zasięg.
Zmienne lokalne
Jeżeli deklaracja zostanie umieszczona wewnątrz procedury, obowiązuje tylko wewnątrz
tej procedury. Zmienna jest wówczas zwana zmienną lokalną. Po zakończeniu procedury
zmienna lokalna przestaje istnieć, a zajmowany przez nią obszar pamięci jest zwalniany.
Jeżeli w deklaracji zmiennej zamiast wyrażenia Dim zostanie użyte wyrażenie Static,
zmienna zachowa swą wartość po zakończeniu procedury. Zmienna przestanie istnieć,
jeśli procedura jest zakończona instrukcją End.
Zmienne obowiązujące wewnątrz całego modułu

Jeżeli deklaracja zostanie umieszczona na początku modułu, w sekcji Declarations,
obejmuje swoim działaniem cały moduł.
Zmienne globalne
Aby deklaracja obowiązywała we wszystkich modułach, przed pierwszą procedurą
modułu należy zadeklarować zmienną za pomocą wyrażenia Public, np. Public A As
String. Tak zadeklarowaną zmienną nazywamy zmienną globalną.
Przykład 59.
Aby sprawdzić, jaki wpływ na działanie programu ma zadeklarowanie różnych typów
tej samej zmiennej:
program (rysunek 4.40). Edytor nie zasygnalizował błędu.
Rysunek 4.40.
Zmiennej A wewnątrz
tej samej procedury
przypisano dwa
różne typy

3. Na ekranie został wyświetlony komunikat Duplicate declaration in current
scope (rysunek 4.41). Informuje on o dwukrotnym zadeklarowaniu typu tej
samej zmiennej.
Rysunek 4.41.
Komunikat o błędzie

Przykład 60.
Aby sprawdzić, jaki wpływ na działanie programu ma zadeklarowanie różnych typów
tej samej zmiennej w oddzielnych procedurach:
program. Rozdziel go na dwie procedury. Pierwszej procedurze nadaj nazwę
deklaracja1. Pozostaw w niej deklarację Dim A As String. Drugiej
procedurze nadaj nazwę procedura2. Umieść w niej deklarację Dim A As
Integer (rysunek 4.42).
Rysunek 4.42.
Dla tej samej
zmiennej w różnych
procedurach
zadeklarowano
różne typy

3. Program nie zgłosił błędu (rysunek 4.43).
Rysunek 4.43.
Program został
wykonany. Zmienna A
ma wartość 0
Ta sama zmienna w różnych procedurach może przechowywać dane różnego typu.
Przykład 61.
Aby sprawdzić, jaki wpływ na wartość zmiennej ma jej zasięg:
program (rysunek 4.44). W procedurze pierwszej zmiennej jest przypisana
wartość 1. W kolejnej linii jest wyświetlane okno z informacją o wartości
zmiennej. W procedurze drugiej zmiennej nie jest przypisana żadna wartość.
Domyślnie ma ona wartość zero. W kolejnej linii jest wyświetlane okno
z informacją o wartości zmiennej. W procedurze trzeciej są kolejno
wywoływane dwie pierwsze procedury. Wywołanie procedury polega
na podaniu jej nazwy.
Rysunek 4.44.
Program obrazujący
zasięg deklaracji
procedury
2. Umieść znak wstawiania za ostatnim znakiem ostatniej procedury.

4. W oknie Macros wybierz nazwę procedury deklaracje (rysunek 4.45).
Rysunek 4.45.
Zostanie
uruchomiona
procedura
zawierająca
wywołania dwóch
pozostałych
5. Kliknij przycisk Run.

6. Zostało wyświetlone okno, w którym jest zawarta informacja o rezultacie
wykonania procedury deklaracja1 (rysunek 4.46)
Rysunek 4.46.
Zmienna A
ma wartość 1

wykonania procedury deklaracja2 (rysunek 4.47).
Rysunek 4.47.
Zmienna A
ma wartość 0
Przykład 62.
Aby sprawdzić, jaki zasięg ma deklaracja zmiennej w procedurze wywołującej inne
procedury:
program (rysunek 4.48). W procedurze pierwszej jest wyświetlana wartość
zmiennej A. W procedurze drugiej jest wyświetlana wartość zmiennej A.
W procedurze trzeciej jest wywoływana procedura pierwsza. Zmiennej A
jest nadawana wartość, a następnie jest ona wyświetlana. Na koniec jest
wyświetlana procedura druga.
Rysunek 4.48.
Program obrazujący
zasięg przypisania
wartości zmiennej

4. W oknie Macros wybierz nazwę procedury deklaracje (rysunek 4.45).
Rysunek 4.49.
Zmienna ma wartość
domyślną, czyli 0

przypisania zmiennej A wartości 1 i wyświetlenia wartości zmiennej
(rysunek 4.50).
Rysunek 4.50.
Zmiennej A została
przypisana wartość 1

Rysunek 4.51.
Wywołanie procedury
powoduje
wyzerowanie
wartości zmiennych
Do przekazywania wartości zmiennych pomiędzy procedurami można wykorzystać

zmienną globalną lub wywołać procedurę B(zmienna1) z procedury A.
Przekazanie wartości przez zmienną globalną

Przykład 63.
Aby sprawdzić, czy deklaracja zmiennej w procedurze wywołującej inne procedury
ma wpływ na jej zasięg:
program (rysunek 4.52). Rozpoczyna się on od zadeklarowania zmiennej A
jako globalnej typu integer. W procedurze pierwszej jest wyświetlana wartość
Rysunek 4.52.
Program obrazujący
zasięg przypisania
wartości zmiennej
zmiennej A. W procedurze drugiej jest wyświetlana wartość zmiennej A.

W procedurze trzeciej jest wywoływana procedura pierwsza. Zmiennej A
jest nadawana wartość 1, a następnie jest ona wyświetlana. Na koniec
jest wyświetlana procedura druga.
4. Wybierz procedurę deklaracje i naciśnij klawisz Run.
5. Została wywołana procedura deklaracja1 (rysunek 4.53).
Rysunek 4.53.
Zmienna ma wartość
domyślną, czyli 0

7. Zmiennej A została przypisana wartość 1, a następnie została ona wyświetlona
(rysunek 4.54).
Rysunek 4.54.
Przypisanie wartości
zmiennej o zasiegu
globalnym

9. Została wywołana procedura deklaracja2 (rysunek 4.55). Zmienna A

ma wartość przypisaną w procedurze deklaracje . Ponieważ ma ona zasięg
globalny, wartość została przekazana do procedury deklaracja2.
Rysunek 4.55.
Przypisanie wartości
zmiennej o zasiegu
globalnym

11. Została przypisana wartość 1, a następnie została ona wyświetlona
(rysunek 4.55).
Ponowne wykonanie programu, bez zamknięcia i ponownego wczytania arkusza, da

inny wynik. Deklaracja globalna jest ważna po zakończeniu wykonywania programu.
Przekazanie wartości
przez wywołanie procedury z parametrem
Przykład 64.
Aby sprawdzić, czy jest możliwe przekazanie do procedury wartości przez wywołanie jej:
1. Uruchom arkusz kalkulacyjny Excel. Wypełnij komórki tak, jak pokazano
na rysunku 4.56.
Rysunek 4.56.
Dane zostały wpisane
do arkusza
2. Uruchom edytor VBA. W oknie Code wpisz program (rysunek 4.57).

Rozpoczyna się on od procedury zarobki. Została zadeklarowana zmienna
pensja jako liczba typu Long. Zostaje jej przypisana wartość wpisana
do komórki B1. Następnie jest wywoływana procedura odliczeniePodatku.
W postaci parametru pensja zostaje jej przekazana wartość odczytana
z komórki B1. Zmiennej pensja jest przypisywana raz wartość brutto (odczyt
z komórki A2), a raz netto (zapis do komórki B2). Dzięki temu operujemy
jedną zmienną i oszczędzamy pamięć. Z tej praktyki należy jednak zrezygnować
w większych programach. Procedura odliczeniePodatku powoduje odjęcie
od podstawy brutto kwoty podatku przy stopie podatkowej w wysokości 19%.
Rysunek 4.57.
Program
wykorzystujący dane
zawarte w arkuszu

5. W oknie Macros wybierz ThisWorkbook.zarobki i kliknij przycisk Run.
6. Wyświetl arkusz Excela (rysunek 4.58). W komórce B2 została wpisana
wartość pensji netto.
Rysunek 4.58.
W komórce
nie ma formuły,
a pojawiła się wartość
Formuła jest aktualizowana na bieżąco. Program w VBA jest wykonywany jednokrot-

nie, chyba że pracuje w pętli. Zmiana wartości w komórce A1 (rysunek 4.58) nie
spowoduje zmiany w komórce A2 aż do ponownego uruchomienia programu.
Deklaracja typu
i instrukcja przypisania
W tabeli 4.1 zebrano typy danych używanych w VBA. Co one oznaczają w praktyce?
Jakiego typu powinna być zmienna, aby przechowywała tekst? Odpowiedzi na te pytania
uzyskamy, wykonując polecenia zawarte w przykładach.
Przykład 65.
Nadaj zmiennej x wartość Konstantynopolitaneczka. Wyświetl wartość przypisaną
zmiennej x w oknie komunikatu.
(rysunek 4.59). Zmienna x jest typu String. W wyniku zastosowania funkcji
MsgBox zostaje wyświetlone okno.
Rysunek 4.59. Program, którego zastosowanie prowadzi do wyświetlenia zawartości zmiennej x

w oknie komunikatu
3. Wybierz do wykonania formułę przypisania.
5. Program został wykonany (rysunek 4.60).
Rysunek 4.60.
W oknie została
wyświetlona wartość
zmiennej x

7. Zmień typ danych ze String na Variant (rysunek 4.61).
Rysunek 4.61. Program z rysunku 4.59 ze zmienioną deklaracją typu zmiennej

Rysunek 4.62.
Zadeklarowanie typu
zmiennej Variant
nie wpłynęło na
wykonanie programu

11. Zmień typ danych z Variant na Integer (rysunek 4.63).
13. Został wyświetlony komunikat informujący o błędnym typie danych
(rysunek 4.64).
Rysunek 4.63. Zmiennej typu Integer przypisano łańcuch tekstowy
Rysunek 4.64. Efekt nieprawidłowego zadeklarowania typu zmiennej

Przykład 66.
Sprawdź, jakie wartości mają domyślnie zmienna typu Boolean oraz Date.
(rysunek 4.65). Zmienna x jest typu Boolean. W wyniku zastosowania funkcji
MsgBox zostaje wyświetlone okno.
Rysunek 4.65. Program, którego zastosowanie pozwala wyświetlić domyślną wartość zmiennej x
w oknie komunikatu
Rysunek 4.66.
Zmienna typu
logicznego domyślnie
ma wartość False

5. Zmień typ danych z Boolean na Date (rysunek 4.67).
Rysunek 4.67. Zmienna x będzie przechowywała datę


Rysunek 4.68.
Domyślnie zmiennym
jest przypisywana
wartość zero. Sposób
jej wyświetlania zależy
od zadeklarowanego
typu zmiennej
Komórka arkusza jako zmienna

Visual Basic for Applications może odczytywać dane z komórek arkusza, przetwarzać
je i umieszczać wyniki w komórkach arkusza. Jak przebiega ten proces, można zo-
rientować się, wykonując przykład 67.
Przykład 67.
Napisz program, którego zastosowanie pozwoli odczytać dane z komórek A1 i A2,
zsumować je, a wynik zapisać w komórce A3.
program (rysunek 4.69).
Rysunek 4.69. Program, którego zastosowanie pozwala zsumować zawartość komórek A1 i A2,
a wynik wyświetlić w komórce A3

3. Program został wykonany. Wyświetl okno arkusza Excela (rysunek 4.70).
Rysunek 4.70.
Puste komórki mają
wartość zero, a zatem
wynik sumowania
również wynosi 0
4. Wpisz w komórce A1 liczbę 2.

5. Wpisz w komórce A2 liczbę 3 (rysunek 4.71).
Rysunek 4.71.
Wynik nie został
automatycznie
zaktualizowany
6. Wyświetl okno edytora VBA.

8. Program został wykonany. Wyświetl okno arkusza Excela.
9. Zaznacz komórkę A3 (rysunek 4.72). Jest w niej widoczna suma komórek
A1 i A2. Sumowanie zostało wykonane nie za pomocą formuły,
ale w programie VBA.
Rysunek 4.72.
Liczba jest widoczna
zarówno w komórce,
jak i na pasku formuły
W programowaniu wiele zadań można rozwiązać na więcej niż jeden sposobów. Oprócz
niepodważalnych kryteriów, takich jak maksymalizacja szybkości działania programu,
minimalizacja zajętości pamięci, jest wiele innych zależnych od przyjętych w programie
konwencji. W przykładzie 67. komórki były adresowane przez podanie adresu (tak jak
w grze w okręty). Alternatywnym sposobem adresowania jest zapis Cells(numer_
wiersza, numer_kolumny). Ponieważ obie wartości są liczbowe, łatwiej jest z nich ko-
rzystać np. przy konstruowaniu pętli, która przeszukuje kolejne komórki.
Przykład 68.
Napisz program, którego zastosowanie pozwoli odczytać dane z komórek A1 i A2,
zsumować je, a wynik zapisać w komórce A3. Do adresowania komórek wykorzystaj
zapis Cells(numer_wiersza, numer_kolumny).
program (rysunek 4.73).
Rysunek 4.73. Program, którego zastosowanie pozwala zsumować zawartość komórek A1 i A2,
a wynik wyświetlić w komórce A3
Rysunek 4.74.
Puste komórki mają
wartość zero, a zatem
wynik sumowania
również wynosi 0
4. Wpisz w komórce A1 liczbę 2.

5. Wpisz w komórce A2 liczbę 3 (rysunek 4.75).
Rysunek 4.75.
Wynik nie został
automatycznie
zaktualizowany

8. Program został wykonany. Wyświetl okno arkusza Excela.
9. Zaznacz komórkę A3 (rysunek 4.76). Jest w niej widoczna suma komórek
A1 i A2. Sumowanie zostało wykonane nie za pomocą formuły,
ale w programie VBA. Mimo zastosowania innego sposobu adresowania
wynik jest identyczny jak w przykładzie 67.
Rysunek 4.76.
Liczba widoczna jest
Dla osób mających doświadczenie w pracy z arkuszem Excel może być zaskocze-
niem, że wynik nie jest aktualizowany po zmianie danych. Co się stanie, jeśli komórce,
która zawiera formułę, przypiszemy wynik wykonania programu w VBA? Najlepiej
sprawdzić to na przykładzie.
Przykład 69.
Wykonaj przykład 68. W arkuszu w komórki B1 i B2 wpisz liczby. W komórce A3
wyświetl wynik ich sumowania przy użyciu formuły. Wykonaj program w VBA. Sprawdź,
czy nadpisanie formuły przez wynik obliczeń jest sygnalizowane.
1. Uruchom arkusz kalkulacyjny Excel i edytor VBA.
2. W arkuszu zostały przygotowane dane i wpisana formuła (rysunek 4.77).
Rysunek 4.77.
Liczba jest widoczna
3. Wyświetl okno edytora VBA (rysunek 4.78).
Rysunek 4.78. Program zsumuje zawartość komórek A1 oraz A2, a wynik wstawi do komórki A3
Rysunek 4.79.
W komórce A5
formuła została
nadpisana przez wynik
wykonania programu
Czy można zabezpieczyć arkusz przed wpisywaniem danych przez programy VBA?
Tak, można włączyć ochronę arkusza (Recenzja/Chroń arkusz). Przy próbie wpisania
do komórki chronionego arkusza przez program VBA zostanie wyświetlony komunikat
o błędzie (rysunek 4.80).
Rysunek 4.80.
Tak jest
sygnalizowana próba
wpisania przez
program VBA do
chronionego arkusza
Tekst jako wartość zmiennej

Komputer nie umie czytać ― w takim znaczeniu, w jakim robi to człowiek. Potrafi on
przetwarzać dane. Jeżeli zadeklaruje się tekst jako zmienną, komputer wykona na nim
operację. Dla niewtajemniczonego obserwatora będzie to wyglądało jak czytanie i pi-
sanie ze zrozumieniem.
Przykład 70.
Napisz program, którego zastosowanie pozwoli ciągi znaków przypisane zmiennym
połączyć w jeden ciąg i zapisać je w komórce A1 arkusza.
program (rysunek 4.81). W trzecim wierszu znajduje się instrukcja przypisania
zawartości komórki A1 zmiennej A. W czwartym wierszu znajduje się instrukcja
przypisania zawartości komórki B1 zmiennej B. W piątym wierszu obie
zmienne są łączone. Wynik łączenia zostaje wyświetlony w komórce C1.
Rysunek 4.81. Program, którego zastosowanie pozwala dokonać łączenia łańcuchów tekstowych
2. W arkuszu kalkulacyjnym wpisz dane (rysunek 4.82).
Rysunek 4.82.
W komórkach A1 i B1
zostały wpisane
ciągi znaków
3. Wyświetl edytor VBA.

4. Uruchom program. Naciśnij klawisz F5.
5. Wyświetl arkusz kalkulacyjny Excel.
6. W komórce C1 jest widoczny napis powstały przez połączenie zmiennych
A oraz B (rysunek 4.83).
Rysunek 4.83.
Wynik połączenia
ciągów został wstawiony
do komórki C1
Co się stanie, gdy zamiast tekstów w komórki A1 i A2 wpiszemy liczby? Czy kom-
puter zorientuje się, że dane mają charakter liczbowy, a nie tekstowy? Najłatwiej do-
wiedzieć się o tym, analizując przykład.
Przykład 71.
Sprawdź, jak działa program z przykładu 70., gdy argumentami są liczby.
1. W komórki A1 i A2 wpisz liczby 11 i 12 (rysunek 4.84).
Rysunek 4.84.
Komórki zawierają
liczby
2. Uruchom program z przykładu 70. Wynik został wpisany do komórki C1

(rysunek 4.85).
Rysunek 4.85.
Rezultatem połączenia
dwóch liczb jest ciąg
tekstowy
3. Sprawdź, jaki charakter ma wynik wyświetlany w komórce C1. W komórce

D1 wpisz liczbę 1. W komórce E1 zsumuj zawartość komórek C1 i D1
(rysunek 4.86).
Rysunek 4.86.
Według Excela wartość
komórki C1 wynosi zero
Komputer wraz z oprogramowaniem jest świetnym narzędziem. Korzystając z niego,

należy pamiętać, że coś, co może zaskoczyć człowieka (np. wygląd wyniku), nie spo-
woduje żadnej reakcji programu — o ile takiej reakcji uprzednio nie zaprogramujemy.
Przykład 72.
Napisz program, którego zastosowanie pozwoli z adresu w postaci kod_pocztowy nazwa_
miejscowości wydzielić kod pocztowy.
program (rysunek 4.87). W trzecim wierszu znajduje się instrukcja przypisania
zawartości zmiennej N. W czwartym wierszu znajduje się instrukcja
przypisania zawartości komórki A1 zmiennej A. W piątym do komórki B1 jest
wpisywanych N pierwszych od lewej znaków wczytanych z komórki A1.
Rysunek 4.87. Program, którego zastosowanie pozwala wpisać N pierwszych znaków z komórki A1
do komórki B1
2. W arkuszu kalkulacyjnym wpisz dane (rysunek 4.88).
Rysunek 4.88.
W komórce A1 zostały
wpisane dane

5. Wyświetl arkusz kalkulacyjny Excel.
6. W komórce B1 jest widocznych sześć pierwszych znaków z komórki A1
(rysunek 4.89).
Rysunek 4.89.
Wydzielenie ciągu
o stałej długości znaków
Podsumowanie
 Nazwa zmiennej nie może być dowolna. Pierwszy znak nazwy zmiennej musi
być literą. W nazwie mogą występować znaki alfanumeryczne i niektóre znaki
interpunkcyjne. W nazwach nie mogą znajdować się słowa zastrzeżone
(np. if, next). W nazwach nie mogą występować spacje i kropki. W celu
zwiększenia czytelności nazw zamiast spacji można używać znaku
podkreślenia _, np. rata_kredytu. W VBA w nazwach nie jest rozróżniana
wielkość liter. Aby zwiększyć czytelność złożonych nazw, można stosować
w środku wyrazów wielkie litery, np. RataKredytu. W nazwach nie można
umieszczać znaków używanych w deklaracjach: #, $, & oraz !. Maksymalna
długość nazwy wynosi 256 znaków. To ograniczenie rzadko ma znaczenie
praktyczne, ponieważ nazwy stosowane w programach są znacznie krótsze.
 Deklaracje typów danych pozwalają na racjonalne gospodarowanie zasobami
komputera oraz wskazują programowi, jak ma poprawnie interpretować dane.
 Aby włączyć wymuszanie deklarowania zmiennych, uruchom arkusz
kalkulacyjny Excel i edytor VBA. Wybierz polecenia Tools/Options.
W sekcji Code Settings zaznacz opcję Require Variable Declaration.
Kliknij przycisk OK. W pierwszym wierszu programu wpisz instrukcję
Option Explicit.
Rozdział 5.
Komunikacja
z użytkownikiem
 Jaka instrukcja służy do wyświetlenia okna dialogowego
 Jaka instrukcja umożliwia wyświetlenie okna komunikatu
 Jaka instrukcja pozwala na wpisywanie danych do komórek arkusza
 Jak rozpoznać, który przycisk okna został kliknięty
 Jak sprawdzać poprawność wpisywanych danych
W poprzednim rozdziale dane niezbędne do działania programów były wprowadzane

najczęściej przez przypisanie wartości zmiennym. Jest to rozwiązanie najprostsze
z punktu widzenia programisty.
To, co jest najprostsze dla programisty, zwykle jest najbardziej uciążliwe dla użytkow-
nika. Wprowadzanie nowych danych wymaga ingerencji w kod programu. Nie każdy
użytkownik ma ochotę edytować program i potrafi to zrobić. Jeśli programista zezwo-
li na taki sposób wprowadzania danych, może on przyczynić się do tego, że użytkow-
nik zmodyfikuje jeszcze jakąś część programu, który w efekcie przestanie działać.
Wprowadzanie danych przez podstawianie ich do zmiennych nie jest więc optymalnym
rozwiązaniem.
Inny sposób polega na wprowadzaniu danych do komórek arkusza. Wyniki również

są wyświetlane w komórkach. Użytkownik musi poprawnie wpisać dane. Programista
powinien zadbać o umieszczenie w arkuszu opisów, które pozwolą wprowadzić dane,
a następnie zinterpretować wynik. To rozwiązanie jest wygodne, gdy danych jest nie-
wiele. Jeżeli jednak jest wprowadzanych kilkaset pozycji, wówczas korzystanie z arku-
sza, który nie mieści się na ekranie, jest kłopotliwe.
Rozwiązaniem, które najbardziej przypadło mi do gustu, jest posługiwanie się oknami

dialogowymi. Mogą one służyć zarówno do wprowadzania informacji, jak i wyświetla-
nia ich. Zwykłe formuły Excela tylko zwracają wynik. W oknie dialogowym można
umieścić przyciski, które pozwolą użytkownikowi na podjęcie decyzji.
Wprowadzanie danych
Do wprowadzania danych służy funkcja InputBox. Umożliwia ona: wyświetlenie okna
dialogowego z polem do wpisania informacji, wstrzymanie wykonywania programu
do czasu wprowadzania przez użytkownika informacji i kliknięcia przycisku, przypi-
sanie wartości zmiennej.
Ma ona następującą składnię:

InputBox(prompt[, title] [, default] [, xpos] [, ypos] [, helpfile, context])
gdzie:
 prompt — parametr wymagany. Zawiera on tekst wyświetlany w oknie
dialogowym. Maksymalna długość tekstu wynosi 1024 znaki. Jest
ona dodatkowo zależna od szerokości używanych znaków. Jeżeli tekst ma być
wyświetlany w więcej niż jednej linii, należy zastosować znak separujący.
W tym celu są używane (Chr(13)) — carriage return lub (Chr(10)) —
linefeed character. Jest również możliwe łączenie obu znaków (Chr(13)
& Chr(10)) pomiędzy każdą linią.
 title — parametr opcjonalny. Zawiera on tekst wyświetlany na pasku
tytułu okna dialogowego. Jeżeli parametr zostanie pominięty, na pasku
tytułu zostanie wyświetlona nazwa aplikacji.
 default — parametr opcjonalny. Zawiera on tekst wyświetlany w polu
edycji jako domyślny. Jeżeli parametr zostanie pominięty, jest wyświetlane
puste pole edycji.
 xpos — parametr opcjonalny. Wyrażenie liczbowe określające odległość
w poziomie lewej krawędzi okna dialogowego od krawędzi ekranu.
Jeżeli parametr zostanie pominięty, okno jest centrowane w poziomie.
 ypos — parametr opcjonalny. Wyrażenie liczbowe określające odległość
w pionie górnej krawędzi okna dialogowego od krawędzi ekranu.
Jeżeli parametr zostanie pominięty, okno jest wyświetlane w ⅓ wysokości,
licząc od góry ekranu.
 helpfile — parametr opcjonalny. Zawiera ciąg znaków, który umożliwia
korzystanie z pomocy kontekstowej dla okna.
 context — parametr opcjonalny. Wyrażenie liczbowe wskazujące na numer
tematu pomocy.
Aby uniknąć dwuznaczności, w opisach funkcji użyłem terminów anglojęzycznych.

Są one identyczne z występującymi w pomocy programowej. Ich znaczenie wyjaśni-
łem przy opisie funkcji.
Rozdział 5.  Komunikacja z użytkownikiem 155
Jeżeli zostaną użyte zarówno helpfile, jak i context, naciśnięcie klawisza F1 spowoduje
wyświetlenie tematu pomocy odpowiadającego kontekstowi. Niektóre aplikacje, jak np.
Microsoft Excel, automatycznie dodają przycisk pomocy do okna dialogowego.
Jeżeli użytkownik kliknie przycisk OK lub naciśnie klawisz Enter, funkcja InputBox
zwraca ciąg znaków wpisany w polu edycji. Jeśli użytkownik kliknie przycisk Anuluj
lub naciśnie klawisz Esc, funkcja InputBox zwraca łańcuch o długości zerowej.
Przykład 73.
Wyświetl okno funkcji InputBox zawierające: w pasku tytułu tekst Tytuł okna, w miejscu
przeznaczonym na objaśnienia tekst Treść objaśnienia, a w polu edycji tekst Pole edycji.
2. Wpisz w nim program (rysunek 5.1). Pierwsza linia zawiera wymuszenie
deklaracji wszystkich zmiennych. W programie dane między podprogramami
są przekazywane za pośrednictwem zmiennych. Zmienne muszą być
zadeklarowane globalnie — na początku programu, a nie w procedurze.
W linijce drugiej i trzeciej są zadeklarowane zmienne, które będą przechowywać
ciągi znaków. Podprogram główny ma za zadanie wywołanie podprogramów:
czytacz i pisacz. Zastosowanie podprogramu czytacz prowadzi do wyświetlenia
okna dialogowego. W polu edycji jest wpisany ciąg znaków. Zastosowanie
podprogramu pisacz prowadzi do wyświetlenia ciągu znaków wpisanych
w polu edycji.
Rysunek 5.1. Treść programu

Miejsce, w którym znajduje się punkt wstawiania (kursor) podczas naciskania kla-
wisza F5, wskazuje procedurę, która zostanie uruchomiona.
4. Zaznacz procedurę, która ma być wykonana (rysunek 5.2).
Rysunek 5.2.
Zostanie uruchomiony
podprogram główny

6. Na ekranie zostało wyświetlone okno (rysunek 5.3). Ciągi znaków widoczne
w pasku tytułu, centralnej części okna oraz w polu dialogowym są parametrami
procedury czytacz. W polu dialogowym można wpisywać znaki z klawiatury
lub pozostawić ciąg domyślny. W przykładzie pozostawimy wartość domyślną.
Rysunek 5.3.
Okno wyświetlone
w trakcie wykonania
podprogramu czytacz

8. Na ekranie zostało wyświetlone okno (rysunek 5.4). Ciągi znaków widoczne
w centralnej części okna oraz polu dialogowym są parametrami procedury
pisacz oraz ciągiem znaków przypisanych zmiennej a.
Rysunek 5.4.
Okno wyświetlone
w trakcie wykonania
podprogramu pisacz

Przykład 74.
Wyświetl okno funkcji InputBox zawierające: w pasku tytułu tekst Tytuł okna, w miejscu
przeznaczonym na objaśnienia tekst Wpisz dane do komórki A1, a w polu edycji —
puste miejsce. Ciąg znaków wprowadzony w polu edycji wpisz do komórki A1 arkusza.
deklaracji wszystkich zmiennych. Dane między podprogramami są przekazywane
za pośrednictwem zmiennych. Zmienne muszą być zadeklarowane globalnie
— na początku programu, a nie w procedurze. W linijce drugiej i trzeciej są
zadeklarowane zmienne, które będą przechowywać ciągi znaków. Podprogram
główny ma za zadanie wywołanie podprogramów: czytacz i pisacz. Zastosowanie
podprogramu czytacz prowadzi do wyświetlenia okna dialogowego. Zastosowanie
podprogramu pisacz prowadzi do wpisania do komórki A1 ciągu znaków
zarejestrowanego w polu edycji.
Rysunek 5.5. Program, za pomocą którego wczytany ciąg znaków zostaje umieszczony w komórce A1

4. Zostało wyświetlone okno Macros (rysunek 5.6). Zaznacz program,
który ma zostać uruchomiony.
6. Zostało wyświetlone okno, w którym należy wpisać ciąg znaków (rysunek 5.7).
7. W polu dialogowym wpisz dowolne znaki.
Rysunek 5.6.
Zostanie uruchomiony
podprogram główny
Rysunek 5.7.
Okno do wpisywania
danych — efekt
wykonania
podprogramu
czytacz
9. W arkuszu kalkulacyjnym do komórki A1 został skopiowany tekst z pola

dialogowego (rysunek 5.8).
Rysunek 5.8.
Arkusz z wypełnioną
komórką
Częstą praktyką jest modyfikowanie działającego programu tak, aby realizował

nowe zadania. Program z przykładu 74. powstał przez wprowadzenie zmiany w progra-
mie z przykładu 73.
Czasami program powstały przy wykorzystaniu już istniejącego może zawierać

niepotrzebne elementy. Tak też jest w przykładzie 74. W programie (rysunek 5.5) zo-
stała zadeklarowana zmienna b, która nie została wykorzystana. Program nie sygnali-
zuje, że obszar pamięci został zarezerwowany i niewykorzystany. Niestety, obowiązek
rozwiązania tego problemu spoczywa na programiście.
Przykład 75.
Napisz program, który pozwala na wczytanie adresu komórki, danych i wpisanie ich do
wybranej w pierwszym oknie komórki arkusza.
deklaracji wszystkich zmiennych. Dane między podprogramami są przekazywane
za pośrednictwem zmiennych. Zmienne muszą być zadeklarowane globalnie
— na początku programu, a nie w procedurze. W linijce drugiej i trzeciej są
zadeklarowane zmienne, które będą przechowywać ciągi znaków. Podprogram
główny ma za zadanie wywołanie podprogramów: komórka, dane i arkusz.
Zastosowanie podprogramu komórka prowadzi do wyświetlenia okna dialogowego
z prośbą o wpisanie adresu komórki. Adres jest przypisany zmiennej k.
Zastosowanie podprogramu dane prowadzi do wyświetlenia okna dialogowego
z prośbą o wpisanie danych (zawartości komórki). Dane są przypisane
zmiennej a. Zastosowanie podprogramu arkusz prowadzi do wpisania
do komórki k ciągu a.
Rysunek 5.9. Program, którego zastosowanie prowadzi do umieszczenia wczytanego ciągu znaków
w komórce o adresie podanym przez użytkownika

4. Zostało wyświetlone okno Macros (rysunek 5.10). Zaznacz program,
który ma zostać wykonany w pierwszej kolejności — główny.
Rysunek 5.10.
Lista programów.
Najtrudniej wybrać
właściwy — później
wszystko następuje
automatycznie
8. Zostało wyświetlone okno, w którym można wpisać adres komórki.

Wpisz go w polu dialogowym (rysunek 5.11).
Rysunek 5.11.
Współrzędne komórki

10. Zostało wyświetlone okno, w którym można wpisać dane. Wpisz je w polu
dialogowym (rysunek 5.12).
Rysunek 5.12.
Zawartość,
która ma zostać
wprowadzona
do komórki
o współrzędnych
z rysunku 5.11
12. Wyświetl arkusz kalkulacyjny (rysunek 5.13). Do komórki o adresie

widocznym na rysunku 5.11 zostały wpisane dane z rysunku 5.12.
Rysunek 5.13.
Ciąg znaków został
wpisany do komórki
o podanym przez
użytkownika adresie
Wykonanie programu z przykładu 75. spowodowało wpisanie danych do komórki,

która nie była zaznaczona.
Przykład 76.
Okno dialogowe wyświetl tak, aby jego lewy górny róg znajdował się w lewym górnym
rogu ekranu.
2. Wpisz w nim program (rysunek 5.14).

4. Po wyświetleniu okna Macros zaznacz przykład76.
6. Program został uruchomiony.
7. Na ekranie zostało wyświetlone okno (rysunek 5.15).
Rysunek 5.15.
Okno wyświetlone
po wykonaniu
programu
z rysunku 5.14
Napisanie programu wymaga wysiłku. Znacznie bardziej pracochłonne jest… za-

bezpieczenie go przed użytkownikiem. W przykładzie 75. na ilustracjach pokazano
działanie programu przy wpisywaniu poprawnych danych. Jeżeli jednak użytkownik
— zamiast wpisać współrzędne komórki (rysunek 5.11) — tylko kliknie przycisk,
wówczas program przejdzie do wykonywania kolejnej procedury, uniemożliwiając użyt-
kownikowi poprawienie danych.
Przykład 77.
Napisz program, który będzie wyświetlał okno z prośbą o wpisanie ciągu znaków. Jeśli
nic nie zostanie wpisane, ponowi prośbę. Gdy ciąg zostanie wprowadzony, program
wyświetli go w oknie komunikatu i zakończy działanie.
2. Wpisz w nim program (rysunek 5.16). Będzie w nim używana tylko jedna
zmienna ciąg. Program składa się z dwóch podprogramów: niepusta i komunikat.
Podprogram niepusta rozpoczyna się od wyzerowania zmiennej ciąg. Przy
pierwszym uruchomieniu programu jest ona niepotrzebna. Jeżeli program
zostanie wykonany ponownie, wówczas zmiennej ciąg zostanie przypisana
wartość… z poprzedniego wykonania. Instrukcje zawarte pomiędzy Do Until
i Loop są wykonywane, aż zostanie spełniony warunek ciąg <> "". Ten zapis
oznacza, że zmienna ciąg ma być niepusta. Dopóki zmiennej nie zostanie nic
przypisane, będzie wyświetlane okno z prośbą o wpisanie ciągu. Gdy ciąg zostanie
wpisany, zostaje on przypisany zmiennej ciąg. Jest wówczas wykonywana
procedura komunikat, której zadaniem jest wyświetlenie zawartości
zmiennej ciąg.

4. Na ekranie zostało wyświetlone okno (rysunek 5.17). Należy w nim wskazać,

który program ma zostać uruchomiony jako pierwszy. Zaznacz główny.
Rysunek 5.17.
Programy warto
nazywać tak,
aby nawet osoba
niewtajemniczona
dokonała dobrego
wyboru

6. Zostało wyświetlone okno zatytułowane Ciąg znaków (rysunek 5.18).
Oznacza to, że jest wykonywany podprogram niepusta.
Rysunek 5.18.
Okno jest wyświetlane tak długo,
aż w polu dialogowym zostanie
wpisany znak. Nawet próba
zamknięcia okna przez kliknięcie
przycisku X widocznego w prawym
górnym rogu na nic się nie zdaje

8. Ponownie zostało wyświetlone okno zatytułowane Ciąg znaków (rysunek 5.18).
9. Kliknij przycisk Cancel.
10. Ponownie zostało wyświetlone okno zatytułowane Ciąg znaków (rysunek 5.18).
11. W polu dialogowym wpisz dowolny ciąg znaków (rysunek 5.19).
Rysunek 5.19.
Ciąg znaków
został wpisany

13. Zostało wyświetlone okno komunikatu (rysunek 5.20). Oznacza to, że jest
wykonywany podprogram komunikat.
Rysunek 5.20.
Ciąg znaków wpisany
w polu dialogowym
(rysunek 5.19)
został wyświetlony
w oknie komunikatu
Program z rysunku (rysunek 5.16) realizuje wyznaczone mu zadanie. Jeżeli jednak

w polu dialogowym (rysunek 5.19) zostanie wpisana spacja, to i w oknie komunikatu
(rysunek 5.20) zostanie wyświetlona spacja, czyli puste miejsce (rysunek 5.21).
Rysunek 5.21.
Teoretycznie spacja
też jest znakiem,
ale okno wygląda
dziwnie
Wyświetlanie komunikatów
Do wyświetlania komunikatów służy funkcja MsgBox. Umożliwia ona: wyświetlenie
okna komunikatu, wstrzymanie wykonywania programu do czasu kliknięcia przycisku,
zwrócenie liczby całkowitej (zmienna typu Integer) o wartości zależnej od klikniętego
przycisku.

MsgBox(prompt[, buttons] [, title] [, helpfile, context])
gdzie:
 prompt — parametr wymagany. Zawiera on tekst wyświetlany w oknie
komunikatu. Maksymalna długość tekstu wynosi 1024 znaki. Jest
ona dodatkowo zależna od szerokości używanych znaków. Jeżeli tekst ma
być wyświetlany w więcej niż jednej linii, należy zastosować znak separujący.
Do tego celu są używane (Chr(13)) — carriage return lub (Chr(10))
— linefeed character. Możliwe jest również łączenie obu znaków
(Chr(13) & Chr(10)) pomiędzy każdą linią.
 buttons — parametr opcjonalny. Wyrażenie numeryczne, które jest sumą
wartości określającej liczbę i typ wyświetlanych przycisków, styl ikony,
przycisk domyślny, modalność okna. Wyrażenie numeryczne jednoznacznie
określa wygląd okna. Jeżeli parametr nie zostanie podany, jest przyjmowana
wartość 0. Sposób generowania przycisków szerzej opisano w tabeli 5.1.
 title — parametr opcjonalny. Zawiera on tekst wyświetlany na pasku tytułu

okna dialogowego. Jeżeli parametr zostanie pominięty, na pasku tytułu
zostanie wyświetlona nazwa aplikacji.
 helpfile — parametr opcjonalny. Zawiera ciąg znaków, który umożliwia
korzystanie z pomocy kontekstowej dla okna.
 context — parametr opcjonalny. Wyrażenie liczbowe wskazujące na numer
tematu pomocy.
Jeżeli zostaną użyte zarówno helpfile, jak i context, naciśnięcie klawisza F1 spowoduje
wyświetlenie tematu pomocy odpowiadającego kontekstowi.
W wywołaniu funkcji jednocześnie możesz użyć tylko jednego parametru z każdej

z tabel od 5.1 do 5.5 włącznie.
Z tabel od 5.1 do 5.6 możesz się dowiedzieć, jak wartość poszczególnych parametrów
wpływa na wygląd wyświetlanego okna oraz wartość zwracaną.
Tabela 5.1. Przyciski wyświetlane w oknie komunikatu

Stała Wartość liczbowa Wyświetlane przyciski
vbOKOnly 0
vbOKCancel 1
vbAbortRetryIgnore 2
vbYesNoCancel 3
Tabela 5.1. Przyciski wyświetlane w oknie komunikatu (ciąg dalszy)

Stała Wartość liczbowa Wyświetlane przyciski
vbYesNo 4
vbRetryCancel 5
Naciśnięcie klawisza Esc daje taki sam efekt jak kliknięcie przycisku Anuluj.
Tabela 5.2. Ikony wyświetlane w oknie komunikatu

Stała Wartość liczbowa Wyświetlana ikona
vbCritical 16
vbQuestion 32
vbExclamation 48
vbInformation 64
Tabela 5.3. Przyciski domyślnie aktywne

Stała Wartość liczbowa Przycisk aktywnie domyślny
vbDefaultButton1 0
vbDefaultButton2 256
vbDefaultButton3 512
VbDefaultButton4 768
Aby dodać do okna przycisk Pomoc, użyj parametru vbMsgBoxHelpButton.
Tabela 5.4. Modalność okna

Stała Wartość liczbowa Modalność
vbApplicationModal 0 Modalność aplikacji. Użytkownik musi zareagować
na okno komunikatu, aby móc kontynuować pracę
w bieżącej aplikacji
vbSystemModal 4096 Modalność systemu. Wszystkie aplikacje są zablokowane
do czasu zareagowania na okno komunikatu
Tabela 5.5. Justowanie i kierunek tekstu

Stała Wartość liczbowa Układ tekstu
vbMsgBoxRight 524288 Wyrównany do prawego marginesu
vbMsgBoxRtlReading 1048576 Tekst wyświetla się od prawej do lewej. Ustawienie
używane przy korzystaniu z alfabetu hebrajskiego
i arabskiego
Tabela 5.6. Wartości zwracane przez przyciski

Kliknięty przycisk Wartość zwracana
OK 1
Anuluj 2
Przerwij 3
Ponów próbę 4
Ignoruj 5
Tak 6
Nie 7
Przykład 78.
Wyświetl w oknie Excela okno komunikatu, które będzie zawierało przycisk OK. Na
pasku tytułu będzie widoczny napis Tytuł okna. Nad przyciskiem będzie widoczny napis
Komunikat.
zmienna x. Do niej funkcja MsgBox zwraca (czyli zapisuje) wynik swojego
działania. W jednej procedurze może wystąpić tylko jedna zmienna o danej
nazwie. Program składa się z deklaracji i programu właściwego. W linii
czwartej znajduje się przypisanie zmiennej okna komunikatu. Parametrami
wyświetlenia okna są: napis wyświetlany nad przyciskiem, typ okna, napis
wyświetlany na pasku tytułu.
Rysunek 5.22.
Program, którego
zastosowanie
prowadzi do
wyświetlenia
okna komunikatu
z przyciskiem OK
3. Uruchom program.
4. Wyświetl okno arkusza Excela. Na pierwszym planie jest widoczne okno
komunikatu (rysunek 5.23).
Rysunek 5.23.
Okno wyświetlone
w wyniku wykonania
programu
z rysunku 5.22
5. Kliknij przycisk widoczny w oknie.

Przykład 79.
Wyświetl w oknie Excela okno komunikatu, które będzie zawierało przyciski Anuluj
oraz OK. Na pasku tytułu będzie widoczny napis Tytuł okna. Nad przyciskiem będzie
widoczny napis Komunikat.
zmienna x. Program składa się z deklaracji i programu właściwego. W linii
wyświetlany na pasku tytułu.
Rysunek 5.24.
Program, którego
wykonanie prowadzi
do wyświetlenia
okna komunikatu
z przyciskami
Anuluj i OK
3. Uruchom program.
4. Wyświetl okno arkusza Excela. Na pierwszym planie jest widoczne okno
komunikatu (rysunek 5.25).
Rysunek 5.25.
Okno arkusza Excela
wyświetlone w wyniku
wykonania programu
z rysunku 5.24
5. Aby zamknąć okno, kliknij jeden z widocznych w nim przycisków.
Przykład 80.
Wyświetl w oknie Excela okno komunikatu jak w przykładzie 79. Odczytaj i wyświetl na
ekranie wartości zwracane przez program w zależności od naciśniętego przycisku.

zmienna x. Program składa się z deklaracji i programu właściwego. W linii
wyświetlany na pasku tytułu. W zależności od klikniętego przycisku zmiennej
x jest przypisywana inna wartość. W linii piątej jest wyświetlana zmienna x.
Rysunek 5.26.
Program, którego
wykonanie prowadzi
do wyświetlenia
okna komunikatu
z przyciskami
Anuluj i OK oraz
wartością zmiennej x
3. Uruchom program.
4. Zostało wyświetlone okno Macros. Zaznacz w nim jedyny program,
który można uruchomić — okna.
6. Zostało wyświetlone okno z dwoma przyciskami (rysunek 5.27).
Jest to wynik wykonania czwartej linii programu. Kliknij przycisk OK.
Rysunek 5.27.
Użytkownik widzi
okno z przyciskami.
Klika jeden z nich.
Jaka informacja
jest przekazywana
do programu?
7. Zostało wyświetlone okno z wartością liczbową (rysunek 5.28).
Rysunek 5.28.
Naciśnięcie przycisku
OK (rysunek 5.27)
spowodowało nadanie
zmiennej x wartości 1

9. Uruchom program ponownie. Sprawdź, jaką wartość będzie miała zmienna x
po kliknięciu przycisku Anuluj (rysunek 5.27).
Przykład 81.
Wyświetl w oknie Excela okno oznaczone znakiem zapytania. Musi ono zawierać cztery
przyciski: Tak, Nie, Anuluj, Pomoc. Przycisk drugi będzie domyślny. Na pasku tytułu
będzie widoczny napis: Próba wyjścia z programu bez zapisania danych! Nad przyciska-
mi będzie wyświetlony napis: Czy chcesz zamknąć program? Odczytaj i wyświetl
na ekranie wartości zwracane przez program w zależności od naciśniętego przycisku.

Option Explicit
Dim x As Integer
Sub Przykład51()
x = MsgBox("Czy chcesz zamknąć program?", vbQuestion + vbYesNoCancel +
vbMsgBoxHelpButton + vbDefaultButton2, "Próba wyjścia z programu
bez zapisania danych!")
MsgBox x
End Sub
3. Będzie tu używana tylko jedna zmienna x. Program składa się z deklaracji

i programu właściwego. W linii czwartej znajduje się przypisanie zmiennej
okna komunikatu. Parametrami wyświetlenia okna są: napis wyświetlany
nad przyciskiem, rodzaj przycisków, napis wyświetlany na pasku tytułu.
W zależności od klikniętego przycisku zmiennej x jest przypisywana inna
wartość. W linii piątej jest wyświetlana zmienna x.
4. Uruchom program.
5. Na pierwszym planie jest widoczne okno komunikatu (rysunek 5.29).
Kliknij przycisk Tak.
Rysunek 5.29.
Okno z czterema
przyciskami
do wyboru
6. Zostało wyświetlone okno z wartością liczbową (rysunek 5.30).
Rysunek 5.30.
Kliknięcie przycisku
Tak spowodowało
nadanie zmiennej x
wartości 6

8. Uruchom program ponownie. Sprawdź, jaką wartość będzie miała zmienna x
po kliknięciu innych przycisków (rysunek 5.29).
Przykład 82.
Wyświetl okno komunikatu, które będzie zawierało przycisk OK. Na pasku tytułu będzie
widoczny napis: Tytuł okna. Nad przyciskiem będzie widoczny napis w dwóch wierszach.
W górnym wierszu będzie znajdował się tekst: Wiersz1. W dolnym wierszu będzie
znajdował się tekst: Wiersz2.
2. Wpisz w nim program (rysunek 5.31). Będą używane następujące zmienne:
napis1, napis2 oraz x. Po części z deklaracjami zmiennym napis1 i napis2
zostają przypisane ciągi znaków. W kolejnej linii znajduje się przypisanie
zmiennej okna komunikatu. Pomiędzy zmiennymi napis1 i napis2 znajduje
się znak przejścia do nowej linii. Pozostałymi parametrami wywołania są:
rodzaj przycisku oraz napis wyświetlany w pasku tytułu.
Rysunek 5.31.
Program, którego
zastosowanie
prowadzi do
wyświetlenia
okna komunikatu
z napisami
w dwóch wierszach
i z przyciskiem OK
3. Uruchom program.
Rysunek 5.32.
Okno wyświetlane
po wykonaniu
programu
z rysunku 5.31
Przykład 83.
Zmodyfikuj program z przykładu 82. tak, aby dowiedzieć się, jaka wartość została
przypisana zmiennej x przed wyświetleniem okna z rysunku 5.32 oraz po kliknięciu
przycisku OK.
Sprawdź, jak w przykładzie 80. został zmodyfikowany program z przykładu 79.

Przykład 84.
Wyświetl okno komunikatu, które będzie zawierało przycisk OK. Na pasku tytułu będzie
widoczny napis Data i czas systemu. Nad przyciskiem będzie widoczny napis w dwóch
wierszach. W górnym wierszu będzie znajdowała się data systemowa. W dolnym wierszu
będzie znajdował się czas systemowy.
Datę i czas systemowy zwracają funkcje: Date$ oraz Time$.

2. Wpisz w nim program (rysunek 5.33). Będą tu używane zmienne: napis1,
napis2 oraz x. Po ich zadeklarowaniu zmiennym napis1 i napis2 zostaną
przypisane ciągi znaków. Są to data i czas systemowy. W kolejnej linii
znajduje się przypisanie zmiennej x okna komunikatu. Pomiędzy zmiennymi
napis1 i napis2 znajduje się znak przejścia do nowej linii. Pozostałymi
parametrami wywołania są rodzaj przycisku oraz napis wyświetlany
w pasku tytułu.
Rysunek 5.33. Program wyświetlający datę i czas systemu
3. Uruchom program.
4. W oknie Macros wybierz jedyny program, który można uruchomić — Przyklad84.
Rysunek 5.34.
Okno wyświetlone
po wykonaniu
programu
z rysunku 5.33

Przykład 85.
Napisz program, po wykonaniu którego będzie wyświetlane okno dialogowe. W pasku
tytułu powinno ono zawierać tekst: Cześć. Poniżej powinno wyświetlać pytanie: Jak
ci na imię?. W polu edycji powinien być wpisany tekst: Tu wpisz swoje imię. Po wpi-
saniu odpowiedzi i kliknięciu przycisku OK powinno zostać wyświetlone okno komu-
nikatu. Pasek tytułu powinien zawierać napis: Cześć. Nad przyciskiem OK powinien być
widoczny tekst wprowadzony w polu edycji.
2. Wpisz w nim program (rysunek 5.35). Będą tu używane zmienne: x oraz y.
Zmiennej x zostaje przypisane imię. Zmienna y odpowiada za wyświetlenie
imienia w oknie komunikatu.
Rysunek 5.35.
Program, po
którego wykonaniu
jest wyświetlany
tekst wpisany
w polu dialogowym
3. Uruchom program.
4. Na pierwszym planie jest widoczne okno umożliwiające wpisanie tekstu
(rysunek 5.36).
Rysunek 5.36.
Okno do
wprowadzania danych
5. Usuń napis widoczny w polu dialogowym.

6. Wpisz w polu dialogowym swoje imię (rysunek 5.37).
Rysunek 5.37.
Imię wpisane
w polu dialogowym
7. Naciśnij przycisk OK.

8. Zostało wyświetlone okno komunikatu (rysunek 5.38). Jest w nim widoczne

imię wpisane w polu dialogowym poprzedniego okna.
Rysunek 5.38.
Imię wpisane w oknie
InputBox zostało
wyświetlone
w oknie MsgBox
Poprawność wprowadzanych danych

Jeżeli program podczas pracy napotka błąd, przerwie swoje działanie. Jest to o tyle
kłopotliwe, że aplikacja może wykorzystywać dane wprowadzane na bieżąco lub wpi-
sane przez innego użytkownika (i trzeba go prosić o poprawienie wpisu).
Dane wczytywane z urządzenia czy pliku mogą być zweryfikowane w trakcie ich
przygotowywania. Dane wprowadzane z klawiatury są najbardziej narażone na błędy.
Warto zastosować w programie procedurę, która będzie kontrolowała poprawność
danych. Nie sprawdzi ona sensu informacji, ale pomoże stwierdzić, czy dane są zgodne
z zadeklarowanym typem zmiennej.
Zastosowanie tej zasady nie pozwoli na wykrycie błędów w zmiennych typu String.
Może ona zawierać dane różnego typu, a jedynym ograniczeniem, które można wyko-
rzystać do weryfikacji, jest długość ciągu.
Do wykrywania błędów można użyć funkcji On Error. Ma ona następującą składnię:

On Error GoTo line
lub:
On Error Resume Next
lub:
On Error GoTo 0.
Co oznaczają powyższe zapisy?

 On Error GoTo line — umożliwia utworzenie procedury obsługi błędów,
która po wystąpieniu błędu spowoduje skok do linii o etykiecie występującej
w miejscu zmiennej line.
 On Error Resume Next — po wystąpieniu błędu program będzie nadal
wykonywany. Z tej możliwości można skorzystać, gdy spodziewamy się,
że niektóre błędy mogą być mało istotne i jest dozwolone ich zignorowanie.
 On Error GoTo 0 — wyłącza zdefiniowane procedury obsługi błędów. Przywraca
standardowy typ obsługi błędów dla pozostałych instrukcji procedury.
Przykład 86.
Napisz program, który będzie umożliwiał wprowadzenie liczby całkowitej z klawiatu-
ry. Gdy liczba będzie poprawna, zostanie wyświetlona na ekranie. Gdy wprowadzony
ciąg nie będzie liczbą całkowitą, zostanie wyświetlona informacja o błędzie.
2. Wpisz w nim program (rysunek 5.39). Będzie w nim używana zmienna x. Jako
zmienna typu całkowitego została zadeklarowana jako Integer. W kolejnej
linii znajduje się instrukcja warunkowa skoku do procedury obsługi błędu
Error. Procedura obsługi błędu znajduje się na samym końcu programu. Skok
do niej powoduje wyświetlenie okna komunikatu z informacją o wpisaniu
błędnej liczby. Dane można wprowadzić w oknie dialogowym, które jest
wyświetlane po wykonaniu funkcji InputBox. Jeżeli dane są prawidłowe
— w przykładzie liczba całkowita — następuje wyświetlenie wprowadzonej
liczby (instrukcja MsgBox) i zakończenie działania programu.
Rysunek 5.39. Program, którego zastosowanie pozwala sprawdzić, czy wprowadzona liczba
jest typu całkowitego
3. Uruchom program.
4. Zostało wyświetlone okno umożliwiające wprowadzenie danych.
5. Wpisz liczbę 7.
6. Kliknij przycisk OK (rysunek 5.40).
Rysunek 5.40.
Okno, którego
wyświetlenie jest
wynikiem wykonania
funkcji InputBox
7. Liczba 7 spełnia warunki poprawności. Zostało wyświetlone okno

z wprowadzoną liczbą (rysunek 5.41).
Rysunek 5.41.
Okno, którego
wyświetlenie jest
wynikiem wykonania
pierwszej funkcji
MsgBox

9. Procedura zakończyła działanie. Ponownie wyświetl okno edytora z wpisanym
programem.
12. Wpisz znak &.
Rysunek 5.42.
Wprowadzono daną,
która jest innego
typu niż zmienna x
14. Został wyświetlony komunikat o błędzie (rysunek 5.43).
Rysunek 5.43.
Okno, którego
wyświetlenie jest
wynikiem wykonania
drugiej funkcji MsgBox

16. Procedura zakończyła działanie. Ponownie zostało wyświetlone okno edytora
z wpisanym programem.
Zadeklarowanie typu danych dokładnie dostosowanego do danych rzeczywiście

występujących umożliwia: oszczędne gospodarowanie pamięcią, skrócenie czasu
wykonywania programu oraz automatyczną kontrolę wprowadzanych informacji.
Przykład 87.
Napisz program, który będzie umożliwiał wprowadzenie daty z klawiatury. Gdy liczba
będzie poprawna, zostanie wyświetlona na ekranie. Gdy wprowadzony ciąg nie będzie
datą, zostanie wyświetlony numer błędu.
2. Wpisz w nim program (rysunek 5.44). Będzie tu używana zmienna x, która
została zadeklarowana jako zmienna typu Date. W kolejnej linii znajduje się
instrukcja warunkowa skoku do procedury obsługi błędu Error. Procedura
obsługi błędu znajduje się na samym końcu programu. Skok do niej powoduje
wyświetlenie okna komunikatu o błędzie. Dane można wprowadzić w oknie
dialogowym, które jest wyświetlane po wykonaniu funkcji InputBox. Jeżeli
dane są prawidłowe — w tym przykładzie są prawidłową datą — następuje
wyświetlenie wprowadzonej liczby (instrukcja MsgBox) i zakończenie
działania programu.
Rysunek 5.44. Program, którego zastosowanie pozwala sprawdzić, czy wprowadzona liczba jest datą,
i wyświetlić ją lub komunikat o błędzie
3. Uruchom program.
4. Zostało wyświetlone okno umożliwiające wprowadzenie danych (rysunek 5.45).
Rysunek 5.45.
Wpisany ciąg
ma format daty
5. Wpisz datę 2016-12-13.

7. Dane zostały przyjęte przez program, czego potwierdzeniem jest wyświetlenie

okna z wprowadzoną informacją (rysunek 5.46).
Rysunek 5.46.
Dane zostały
wprowadzone
w odpowiednim
formacie

9. Procedura zakończyła działanie. Ponownie zostało wyświetlone okno edytora
z wpisanym programem.
12. Wpisz numer telefonu.
Rysunek 5.47.
Zamiast daty wpisano
numer telefonu
14. Zostało wyświetlone okno z numerem i nazwą błędu.

Jeżeli chcesz, aby w oknie komunikatu (rysunek 5.48) były wyświetlane spacje pomię-
dzy członami komunikatu, możesz je wstawić w kodzie obsługi błędu (rysunek 5.44).
Rysunek 5.48.
Sprawdź, który z ciągów liczb: 13-12-2016, 12-13-2016 czy 13-13-2016 spowoduje

zasygnalizowanie błędu w programie z przykładu 87.
Przykład 88. — do samodzielnego wykonania

Napisz program, który będzie umożliwiał wprowadzenie daty z klawiatury. Gdy liczba
będzie poprawna, zostanie wyświetlona na ekranie. Gdy wprowadzony ciąg nie będzie
datą, zostanie wyświetlony numer błędu (patrz rysunek 5.44).
1. Sprawdź, czy program potraktuje jako datę ciąg 30-10-2016.
2. Sprawdź, czy program potraktuje jako datę ciąg 30 październik 2016.
3. Sprawdź, czy program potraktuje jako datę ciąg 30 X 2016.
Przykład 89.
Napisz program, który będzie umożliwiał wprowadzenie numeru błędu z klawiatury.
Program będzie wyświetlał opis błędu. Po uruchomieniu powinien działać tak długo,
jak długo użytkownik będzie wpisywał numery błędów.
2. Wpisz w nim program (rysunek 5.49). Będzie w nim używana zmienna Err,
której będzie przypisywany numer błędu. Numery błędów są liczbami
całkowitymi. Zmienna powinna być więc typu Integer. Aby można
było korzystać z programu wielokrotnie po jednorazowym uruchomieniu,
zastosowano w nim instrukcję GoTo. Po wyświetleniu okna dialogowego
i okna komunikatu powoduje ona skok do etykiety ErrorNumer.
Rysunek 5.49.
Program
do wyświetlania
objaśnień
komunikatów
o błędzie
3. Uruchom program.
4. W oknie dialogowym wpisz liczbę 1 (rysunek 5.50).
Rysunek 5.50.
Wartości zmiennej Err
można symulować,
wpisując je w oknie
dialogowym

6. Została wyświetlona informacja o błędzie (rysunek 5.51). Zapoznaj się
z opisem.
Rysunek 5.51.
Opis błędu
dla zmiennej Err=1

8. Zadziała pętla GoTo. Ponownie zostało wyświetlone okno dialogowe.
9. Wpisz liczbę 3.
11. Została wyświetlona informacja o błędzie (rysunek 5.52). Zapoznaj się
z opisem.
Rysunek 5.52.
Opis błędu
dla zmiennej Err=3

13. Zadziałała pętla GoTo. Ponownie zostało wyświetlone okno dialogowe.
14. Aby przerwać działanie programu, kliknij przycisk Cancel, a następnie OK.

Napisz program, który będzie umożliwiał wprowadzenie numeru błędu z klawiatury.
Program będzie wyświetlał opis błędu. Po uruchomieniu powinien działać tak długo,
jak długo użytkownik będzie wpisywał numery błędów (patrz rysunek 5.49).
1. Sprawdź, co oznacza kod 2.
Wycinanie tekstu
Opisane w tym rozdziale sposoby kontroli poprawności wprowadzanych danych nie
są idealne. Może się zdarzyć tak, że przyjdzie nam pracować z danymi otrzymanymi
od kogoś lub importowanymi z pliku. Może wówczas okazać się, że zawierają one błędy.
Gdy okaże się, że ich skorygowanie wymaga więcej niż kilku godzin pracy, warto
pokusić się o napisanie programu, który wyręczy człowieka.
Przykład 91.
Napisz program, który będzie zwracał określoną liczbę znaków wyciętych z prawej
strony tekstu. Tekst powinien być wpisany w komórce A2. Liczba znaków powinna
być wpisana w komórce B2. Tekst po obcięciu powinien być wpisany do komórki C2.
2. Wpisz w nim program (rysunek 5.53). Tekst jest wczytywany do zmiennej txt.
Liczba znaków jest przypisywana zmiennej n. Funkcja Right zwraca określoną
liczbę znaków wyciętych z prawej strony tekstu. Ma ona następującą składnię:
Right(tekst,liczba_znaków)
Rysunek 5.53.
Program wycinający
z tekstu zapisanego
w komórce (2, 1)
n znaków, licząc
od prawej. Liczba n
jest odczytywana
z komórki (2, 2)
3. Przygotuj zestaw danych testowych (rysunek 5.54).
Rysunek 5.54.
Z ciągu znaków zapisanych
w komórkach od A2 do C2
zostanie wpisanych tyle
znaków, ile wynosi wartość
zapisana w komórce B2
4. Uruchom program.
5. W oknie Macros zaznacz program przyklad91.
7. Wyświetl ponownie arkusz (rysunek 5.55).
Rysunek 5.55.
Znaki interpunkcyjne
są traktowane
tak jak litery
Przykład 92.
Napisz program, który będzie zwracał określoną liczbę znaków wyciętych z tekstu, licząc
od pierwszego zadeklarowanego znaku. Tekst powinien być wpisany w komórce A2.
Numer znaku odniesienia powinien być wpisany w komórce B2. Liczba znaków powinna
być wpisana w komórce C2. Tekst po obcięciu powinien być wpisany do komórki D2.
2. Wpisz w nim program (rysunek 5.56). Tekst jest wczytywany do zmiennej txt.
Numer znaku odniesienia jest przypisywany zmiennej m. Liczba znaków jest
przypisywana zmiennej n. Funkcja Mid zwraca określoną liczbę znaków
wyciętych z tekstu, licząc od pierwszego zadeklarowanego znaku.
Mid (tekst,indeks_początku,liczba_znaków)
Rysunek 5.56.
Program, którego
zastosowanie
pozwala wyciąć
z tekstu zapisanego
w komórce A2
n znaków, licząc
od znaku m
Rysunek 5.57. Z ciągu znaków zapisanych w komórkach od A2 do D2 zostanie wpisanych tyle znaków,
ile wynosi wartość zapisana w komórce C2. Numer znaku odniesienia zapisano w komórce B2
4. Uruchom program.
Rysunek 5.58. W komórce D2 zostało zapisanych dziewięć znaków z tekstu widocznego w komórce A2,
licząc od znaku trzeciego
Przykład 93.
Napisz program, którego zastosowanie pozwoli zwracać liczbę całkowitą odpowiadają-
cą długości tekstu wpisanego do komórki A2. Powinny być liczone wszystkie znaki
włącznie z niedrukowanymi (spacja, znacznik akapitu itp.). Wynik powinien zostać
wpisany do komórki B2.
2. Wpisz w nim program (rysunek 5.59). Tekst wpisany w komórce A2 jest
argumentem formuły Len. Zwracany przez nią wynik jest zapisywany
w komórce B2. Funkcja Len zwraca liczbę całkowitą odpowiadającą długości
tekstu. Są liczone wszystkie znaki kodowane łącznie z niedrukowanymi
(spacja, znacznik akapitu etc.). Ma ona następującą składnię:
Len(tekst)
Rysunek 5.59.
Program, którego
zastosowanie pozwala zliczyć
długość tekstu zapisanego
w komórce A2 i zapisać
wynik w B2
Rysunek 5.60.
Tekst w komórce A2
jest wyśrodkowany.
Czy efekt uzyskano
przy użyciu spacji?
4. Uruchom program.
Rysunek 5.61.
W komórce A2 są
wpisane 24 znaki!
Przykład 94.
Napisz program, który usunie wszystkie znaki białe (niedrukowalne) wpisane po lewej stro-
nie ciągu widocznego w komórce A2. Wynik powinien zostać wpisany do komórki B2.
argumentem formuły LTrim. Zwracany przez nią wynik jest zapisywany
w komórce B2. Funkcja LTrim zwraca tekst z pominięciem znaków białych
(niedrukowalnych) napotkanych z lewej strony tekstu. Ma ona następującą
składnię:
LTrim(tekst)
Rysunek 5.62.
Program, którego
zastosowanie pozwala
usunąć znaki
niedrukowalne z tekstu
zapisanego w komórce A2
i zapisać wynik w B2
Rysunek 5.63.
Tekst w komórce A2
prawdopodobnie jest
poprzedzony znakami
białymi
4. Uruchom program.
Rysunek 5.64.
W komórce A2 tekst
był poprzedzony
przez znaki białe
Funkcja RTrim zwraca tekst z pominięciem znaków białych (niedrukowalnych) na-

potkanych z prawej strony tekstu. Ma ona następującą składnię RTrim(tekst).
Przykład 95.
Napisz program, którego zastosowanie pozwoli usunąć wszystkie znaki białe (niedruko-
walne) wpisane po lewej i prawej stronie ciągu widocznego w komórce A2. Wynik powi-
nien zostać wpisany do komórki B2.
argumentem formuły Trim. Zwracany przez nią wynik jest zapisywany
w komórce B2. Funkcja Trim zwraca tekst z pominięciem znaków białych
(niedrukowalnych) napotkanych z lewej i prawej strony tekstu. Ma ona
następującą składnię:
Trim(tekst)
Rysunek 5.65.
Program, którego zastosowanie
pozwala usunąć znaki
niedrukowalne z tekstu zapisanego
w komórce A2 i zapisać
wynik w B2
Rysunek 5.66.
Tekst w komórce A2 jest
prawdopodobnie poprzedzony
i zakończony znakami białymi
4. Uruchom program.
8. Stosując wyrównanie komórki B2 do lewej i do prawej strony, sprawdź,
czy przed i za tekstem znajdują się znaki białe.
Rysunek 5.67.
W komórce A2 tekst
był poprzedzony
przez znaki białe
Podsumowanie
 Do wprowadzania danych służy funkcja InputBox. Umożliwia ona: wyświetlenie
okna dialogowego z polem do wpisania informacji, wstrzymanie wykonywania
programu do czasu wprowadzania przez użytkownika informacji i kliknięcia
przycisku, przypisanie wartości zmiennej.
 Do wyświetlania komunikatów służy funkcja MsgBox. Umożliwia ona:
wyświetlenie okna komunikatu, wstrzymanie wykonywania programu
do czasu kliknięcia przycisku, zwrócenie liczby całkowitej (zmienna
typu Integer) o wartości zależnej od klikniętego przycisku.
 Wpisanie danych do komórki arkusza umożliwia obiekt Range,
np. Range("Adres_komórki").value=wpisana_wartość.
 Funkcja MsgBox zwraca liczbę całkowitą (zmienną typu Integer) o wartości
zależnej od klikniętego przycisku.
 Do wykrywania błędów można użyć instrukcji On Error. Może ona zostać
wykorzystana przy wyświetlaniu kodu i opisu wykrytego błędu.
 Funkcja Len zwraca liczbę całkowitą odpowiadającą długości tekstu. Są liczone
wszystkie znaki kodowane łącznie z niedrukowanymi (spacja, enter etc.).
Ma ona następującą składnię: Len(tekst).
 Funkcja RTrim zwraca tekst z pominięciem znaków białych (niedrukowalnych)
napotkanych z prawej strony tekstu. Ma ona następującą składnię RTrim(tekst).
 Funkcja LTrim zwraca tekst z pominięciem znaków białych (niedrukowalnych)
napotkanych z lewej strony tekstu. Ma ona następującą składnię LTrim(tekst).
 Funkcja Trim zwraca tekst z pominięciem znaków białych (niedrukowalnych)
napotkanych z lewej i prawej strony tekstu. Ma ona następującą składnię
Trim(tekst).
Rozdział 6.
Korzystanie z obiektów
 Co to jest obiekt
 Co to jest właściwość
 Co to jest metoda
Obiekty
Obiektem jest element składowy aplikacji, np. komórka, zakres komórek, wykres
umieszczony na arkuszu, arkusz, skoroszyt, arkusz programu Excel.
Excel zawiera obiekty skoroszytów, skoroszyty zawierają arkusze, arkusze zawierają

zakresy, zakresy zawierają komórki. Powstaje więc struktura hierarchiczna.
Właściwości
Obiekty mają właściwości. Właściwość jest cechą obiektu. Właściwościami zakresu
komórek (obiektu Range) są: zawartość komórki, styl czcionki itp.
Przy odwoływaniu się do właściwości danego obiektu używa się składni:

Object.Property
gdzie:
 Object — nazwa obiektu,
 Property — nazwa właściwości.
Metody
Z obiektami są związane metody. Metoda jest operacją wykonaną na obiekcie — stanowi
ją np. wpisanie tekstu do komórki czy zaznaczenie zakresu komórek.
Metoda jest działaniem, które można wykonać na obiekcie. Jest sposobem postępowania,
który prowadzi do określonego rezultatu.
W celu posłużenia się metodą należy za nazwą obiektu wstawić kropkę, a następnie
nazwę wybranej metody.
Zaznaczanie komórki
Do zaznaczania komórek można wykorzystać metodę Select.
Przykład 96.
Napisz program, którego zastosowanie pozwoli zaznaczyć komórkę B2.
1. W arkuszu Excel zaznacz komórkę A1.
deklaracji wszystkich zmiennych. W linii drugiej znajduje się nazwa procedury.
W linii trzeciej zapisano obiekt (Range("B2")). W ten sposób oznaczono
pojedynczą komórkę B2. Następnie po kropce została zapisana metoda
(Select), która umożliwia zaznaczenie komórki.
Rysunek 6.1.
Program, którego
zastosowanie
pozwala zaznaczyć
komórkę B2
4. Uruchom program.
5. W oknie Macros zaznacz przyklad96.
6. Wyświetl arkusz Excela (rysunek 6.2).
Rysunek 6.2.
Zaznaczenie zostało
przeniesione
do komórki B2
Rozdział 6.  Korzystanie z obiektów 191
Elektroniczny sufler
Podczas pisania programu dużo problemów sprawiają:
 potrzeba dokładnej znajomości nazw obiektów i metod,
 literówki popełniane przy ich wpisywaniu.
Na szczęście edytor VBA został wyposażony w system podpowiedzi. Jak z niego

korzystać, dowiesz się z przykładu 97.
Przykład 97.
Napisz program, którego zastosowanie pozwoli zaznaczyć komórkę B2.
2. Utwórz szkielet programu. Linia kończąca procedurę pojawia się automatycznie
po wprowadzeniu jej nagłówka (rysunek 6.3).
Rysunek 6.3.
Szkielet programu
3. Umieść znak wstawiania między obiema liniami (rysunek 6.4).
Rysunek 6.4.
Znak wstawiania
został umieszczony
między liniami
ograniczającymi
procedurę
4. Podaj nazwę obiektu. W naszym przypadku będzie to zakres komórek.

Wpisz Range(. W oknie edytora pojawiła się podpowiedź (rysunek 6.5).
Rysunek 6.5.
Edytor podpowiada,
jak można zdefiniować
zakres
5. Zakresem będzie jedna komórka. Wpisz "B2")..

6. Po wpisaniu kropki w oknie edytora pojawiła się podpowiedź (rysunek 6.6).
Rysunek 6.6.
Lista metod
i właściwości
7. Metody i właściwości są uporządkowane alfabetycznie. Zaznaczenie obiektu

osiąga się poprzez zastosowanie metody Select. Nie musisz znać dokładnie jej
pisowni. Wystarczy, że wiesz, na jaką literę zaczyna się nazwa. Wpisz literę S.
8. Została wyświetlona lista metod i właściwości o nazwach rozpoczynających

się od litery S. Zaznacz metodę Select (rysunek 6.7).
Rysunek 6.7.
Lista metod
i właściwości
o nazwach
rozpoczynających
się od litery S
9. Potwierdź wybór naciśnięciem klawisza Enter.

10. Do programu została wstawiona metoda Select. Program jest gotowy
(rysunek 6.8).
Rysunek 6.8.
Program
po dodaniu metody
11. Teraz pora na sprawdzenie, czy program działa. Wyświetl okno arkusza Excel
(rysunek 6.9). Domyślnie jest wybrana komórka A1.
Rysunek 6.9.
Arkusz z wybraną
komórką A1
12. Wyświetl okno edytora.

13. Uruchom program kliknięciem ikony (rysunek 6.10).
Rysunek 6.10.
Kliknięcie ikony
spowoduje
uruchomienie
programu
14. Program został wykonany.
15. Wyświetl okno arkusza Excel (rysunek 6.11). Wybraną komórką jest B2.
Rysunek 6.11.
Arkusz z wybraną
komórką B2
Usuwanie zawartości i formatowania

Usunięcie zawartości i formatowania z komórek wymaga zaznaczenia zakresu komó-
rek i posłużenia się metodą Clear.
Przykład 98.
Napisz program, którego zastosowanie pozwoli czyścić i przywracać domyślne for-
matowanie komórek w zakresie od A1 do C3.
W linii trzeciej znajduje się komenda czyszczenia zawartości i przywracania
domyślnego formatowania komórek arkusza leżących w zakresie od A1 do C3.
Rysunek 6.12.
Program, ktorego
usunąć zawartość
i formatowanie
komórek w obszarze
od A1 do C3
3. Wyświetl okno arkusza Excel. Domyślnie wszystkie komórki są puste.

Wpisz dane do komórek (rysunek 6.13).
Rysunek 6.13.
Arkusz z danymi

Rysunek 6.14.
Kliknięcie ikony
spowoduje
uruchomienie
programu

7. Wyświetl okno arkusza Excel (rysunek 6.15). Komórki z zakresu od A1 do C3
zostały wyczyszczone.
Rysunek 6.15.
Z komórek w zakresie
od A1 do C3 zostały
usunięte zawartość
i formatowanie
Usuwanie zawartości
Usunięcie zawartości z komórek wymaga zaznaczenia zakresu komórek i posłużenia
się metodą ClearContents.
Przykład 99.
Napisz program, którego zastosowanie pozwoli usunąć zawartość komórek w zakresie
od A1 do C3.
deklaracji wszystkich zmiennych. W linii drugiej znajduje się nazwa
procedury. W linii trzeciej znajduje się komenda usuwania zawartości
komórek arkusza leżących w zakresie od A1 do C3.
Rysunek 6.16.
Program, którego
usunąć zawartość
komórek w obszarze
od A1 do C3

Rysunek 6.17.
Arkusz z danymi

Rysunek 6.18.
Kliknięcie ikony
spowoduje
uruchomienie
programu

7. Wyświetl okno arkusza Excel (rysunek 6.19). Z komórek z zakresu
od A1 do C3 została usunięta zawartość.
Rysunek 6.19.
Z komórek z zakresu
od A1 do C3 została
usunięta zawartość,
ale nie formatowanie
Usuwanie formatowania
Zastąpienie dotychczasowego formatowania przez domyślne formatowanie komórek
wymaga zaznaczenia zakresu komórek i posłużenia się metodą ClearFormats.
Przykład 100.
Napisz program, którego zastosowanie pozwoli przywrócić domyślne formatowanie
komórek w zakresie od A1 do C3.
W linii trzeciej znajduje się komenda usuwania formatowania komórek arkusza
leżących w zakresie od A1 do C3.
Rysunek 6.20.
Program, którego
zastosowanie pozwoli
usunąć formatowanie
komórek
w ograniczonym
obszarze

Rysunek 6.21.
Arkusz z danymi

6. Program został wykonany. Wyświetl okno arkusza Excel (rysunek 6.22).
Z komórek z zakresu od A1 do C3 zostało usunięte formatowanie.
Rysunek 6.22.
od A1 do C3 zostało
usunięte
formatowanie,
ale nie dane
Usuwanie wartości mniejszych od progowej

Do usunięcia zawartości komórek służy metoda ClearContents. Użycie jej tylko w sto-
sunku do komórek o wartości mniejszej od progowej wymaga sprawdzania wartości
komórek o zadanym zakresie.
Przykład 101.
Napisz program, którego zastosowanie pozwoli przeszukiwać Arkusz1 w zakresie od
A1 do E5. Zawartość komórek o wartościach mniejszych od 0 będzie usuwana.
deklaracji wszystkich zmiennych. W linii drugiej została zadeklarowana
zmienna komórka. Ponieważ nie wiadomo, jakie dane może zawierać arkusz,
został zadeklarowany typ Variant. W trzeciej linii znajduje się nazwa procedury.
Za pomocą pętli For Each… Next będzie przeszukiwany zakres komórek od
A1 do E5 arkusza Excela o nazwie Arkusz1. Przy użyciu metody ClearContents
zawartość komórek o wartościach mniejszych od 0 jest usuwana.
Rysunek 6.23.
Program, którego
usunąć komórki
o wartości mniejszej
od 0 Arkusza1
w zakresie od A1
do E5
3. Wyświetl okno arkusza Excel. W Arkusz1 wpisz dane (rysunek 6.24).
Rysunek 6.24.
Dane wpisane
do Arkusza1

Komórki z zakresu od A1 do E5 o wartościach mniejszych od zera zostały
pozbawione wartości. Ich formatowanie pozostało niezmienione.
Rysunek 6.25.
od A1 do E5 zostały
usunięte dane
o wartościach
mniejszych niż zero
Właściwości
Właściwością jest cecha obiektu. Może nią być np. liczba wpisana w komórkę, kolor
komórki itp.
Przypisanie wartości komórce

Właściwość, która jest przypisana komórce, zależy od wartości Value.
Przykład 102.
Napisz program, którego zastosowanie pozwoli wpisać liczbę 1 do komórki A1.

W linii trzeciej zakresowi komórek jest przypisywana wartość. Jako zakres
została podana jedna komórka, o adresie A1. Zostaje jej przypisana wartość 1.
Rysunek 6.26.
Do komórki A1
zostanie wpisana
wartość 1

4. Program został wykonany. Do komórki A1 została wstawiona liczba 1
(rysunek 6.27).
Rysunek 6.27.
Arkusz z liczbą
wpisaną przez
program
Przykład 90.
Napisz program, którego zastosowanie pozwoli wpisywać słowo misio do komórek
w zakresie od A1 do E5.
W linii trzeciej komórkom należącym do zakresu od A1 do E5 jest przypisywana
wartość. Wartością jest ciąg znaków — słowo misio.
Rysunek 6.28.
Komórki należące do
zakresu od A1 do E5
zostaną wypełnione
identycznym ciągiem
znaków

4. Program został wykonany. Do komórek od A1 do E5 został wstawiony ciąg
znaków misio (rysunek 6.29).
Rysunek 6.29.
Rezultatem wykonania
programu jest
błyskawiczne
„rozmnożenie”
słowa „misio”
Zmian w arkuszu wprowadzonych przez uruchomiony program nie można cofnąć

w prosty sposób, np. naciskając klawisze Ctrl+Z.
Przykład 104.
Napisz program, który będzie przeszukiwał Arkusz1 w zakresie od A1 do E5. W ko-
mórkach o wartościach równych zeru będzie wpisywane słowo zero.
deklaracji wszystkich zmiennych. W drugiej linii została zadeklarowana
został zadeklarowany typ Variant. W trzeciej linii znajduje się nazwa procedury.
Za pomocą pętli For Each… Next będzie przeszukiwany zakres komórek od A1
do E5 arkusza programu Excel o nazwie Arkusz1. Przy użyciu metody Value
do komórek o wartościach równych 0 będzie wpisywane słowo zero.
Rysunek 6.30.
Program, za pomocą
którego można
zastąpić wartość
liczbową jej słownym
odpowiednikiem

Rysunek 6.31.
Dane wpisane
do Arkusza1

W komórki z zakresu od A1do E5 o wartościach równych 0 został wpisany
wyraz zero.
Rysunek 6.32.
Oto dowód na to,
że wartość komórek
pustych wynosi 0

Napisz program, za pomocą którego można będzie przeszukiwać Arkusz1 w zakresie od
A1 do E5. W komórkach, w których znajduje się słowo zero, zostanie wpisana liczba 0.
Przykład 106.
Napisz program, za pomocą którego będzie można przeszukiwać Arkusz1 w zakresie od A1
do E5. W komórkach, w których znajduje się liczba, zostanie wpisana jej wartość słownie.
deklaracji wszystkich zmiennych. W drugiej linii została zadeklarowana
został zadeklarowany typ Variant. W trzeciej linii znajduje się nazwa
procedury. Za pomocą pętli For Each… Next będzie przeszukiwany zakres
komórek od A1 do E5 arkusza Excel o nazwie Arkusz1. Przy użyciu metody
Value do komórek o wartościach równych 0 będzie wpisywane słowo zero.
Analogiczny warunek jest sprawdzany dla liczb o wartościach do 9 włącznie.
Niespełnienie warunku powoduje, że będzie wykonywana kolejna linia
programu. Spełnienie warunku powoduje, że do komórki będzie wpisywany
ciąg znaków.
Rysunek 6.33.
Program, za pomocą
którego można
zastąpić wartość
liczbową z przedziału
od 0 do 9 jej słownym
odpowiednikiem

Rysunek 6.34.
Dane wpisane
do Arkusza1

W komórki z zakresu od A1do E5 zostały wpisane wartości liczbowe
wyrażone słownie.
Rysunek 6.35.
Wartości liczbowe
zostały wyrażone
słownie
Kopiowanie zawartości komórek

Kopiowanie zawartości komórek polega na przypisaniu komórkom należącym do jednego
zakresu wartości komórek znajdujących się w innym zakresie. Operacja kopiowania jest
możliwa dzięki nadaniu komórkom w obu zakresach identycznej właściwości Value.
Przykład 107.
Napisz program, za pomocą którego będzie można kopiować zawartość obszaru od
A1 do A3 do obszaru od B1 do B3.
deklaracji wszystkich zmiennych. W drugiej linii znajduje się nazwa
procedury. W trzeciej linii obiektowi, którym jest zakres komórek od B1
do B3, została przypisana zawartość komórek z zakresu od A1 do A3.
Rysunek 6.36.
Program, za pomocą
którego będzie można
zakresowi komórek
od B1 do B3 przypisać
wartość komórek
od A1 do A3
3. Wyświetl arkusz Excela.

4. W komórki od A1 do A3 wpisz odpowiednio: 1, 2, 3 (rysunek 6.37).
Rysunek 6.37.
Arkusz z zestawem
danych

7. Program został wykonany. Wyświetl arkusz Excela.
8. Do komórek od B1 do B3 została skopiowana zawartość komórek od A1 do A3
(rysunek 6.38).
Rysunek 6.38.
W komórkach od B1
do B3 została wpisana
zawartość komórek
od A1 do A3
Przykład 108.
Napisz program, za pomocą którego będzie można kopiować zawartość obszaru od
A1 do A3 z arkusza 1. do obszaru od A1 do A3 arkusza 2.
deklaracji wszystkich zmiennych. W linii drugiej znajduje się nazwa
procedury. W linii trzeciej obiektowi, którym jest zakres komórek od B1
do B3, została przypisana zawartość komórek z zakresu od A1 do A3.
Rysunek 6.39. Program, za pomocą którego będzie można pomiędzy arkuszami 1. i 2. skopiować
wartość komórek od A1 do A3

4. W komórki od A1 do A3 wpisz odpowiednio: 1, 2, 3 (rysunek 6.40).
Rysunek 6.40.
Arkusz 1. z zestawem
danych

7. Program został wykonany. Wyświetl arkusz Excela i arkusz 2.
8. Do komórek od A1 do A3 arkusza 2. została skopiowana zawartość komórek
od A1 do A3 arkusza 1. (rysunek 6.41).
Rysunek 6.41.
Arkusz 2. z zestawem
danych skopiowanych
z arkusza 1.
Nadawanie komórce koloru z użyciem nazwy koloru

Aby nadać komórce kolor, wykorzystując nazwę koloru, należy posłużyć się właściwością
Interior.Color.
Przykład 109.
Napisz program, za pomocą którego będzie można nadawać komórkom z obszaru
od A1 do A3 kolor żółty.
1. Uruchom arkusz kalkulacyjny Excel. Sprawdź, jaki kolor mają komórki.
Domyślnie nie mają one żadnego wypełnienia.
deklaracji wszystkich zmiennych. W drugiej linii znajduje się nazwa
procedury. W trzeciej linii obiektowi, którym jest zakres komórek od A1
do A3, zostaje przypisany kolor żółty.
Rysunek 6.42.
Komórki od A1 do A3
będą miały kolor żółty

5. Program został wykonany. Wyświetl arkusz kalkulacyjny Excel.
6. Kolor komórek od A1 do A3 został zmieniony (rysunek 6.43).
Rysunek 6.43.
Komórki, których
kolor został zmieniony
W tabeli 6.1 zebrano stałe, których przypisanie właściwości Interior powoduje wy-
świetlenie tła komórki w określonym kolorze.
Tabela 6.1. Stałe odpowiadające najczęściej używanym kolorom

Stała Kolor
vbBlack Czarny
vbRed Czerwony
vbGreen Zielony
vbYellow Żółty
vbBlue Niebieski
vbMagenta Fioletowy
vbCyan Zielononiebieski
vbWhite Biały
Nadawanie komórce koloru z użyciem kodu koloru

Szersze możliwości nadawania komórkom koloru stwarza posługiwanie się kodem kolo-
ru. Aby przypisać komórce kod koloru, należy posłużyć się właściwością ColorIndex.
Przykład 110.
Napisz program, którego zastosowanie pozwoli nadawać komórkom z obszaru od A1
do A56 kolory z palety barw dostępnej za pośrednictwem właściwości ColorIndex.
Option Explicit
Sub przykład110()
Range("A1").Interior.ColorIndex = 1
End Sub
4. Uruchom program.
5. Wyświetl okno arkusza Excel.
6. W komórkach od A1 do A56 zostały wyświetlone próbki kolorów
(rysunek 6.44).
Rysunek 6.44.
Numer wiersza
odpowiada wartości
parametru ColorIndex
Przykład 111.
Napisz program, którego zastosowanie pozwoli nadawać komórkom z obszaru od A1
do A56 kolory z palety barw dostępnej za pośrednictwem właściwości ColorIndex.
Wykorzystaj instrukcję pętli.
deklaracji wszystkich zmiennych. W drugiej linii nazwa procedury Dim wiersz
As Integer jest deklaracją zmiennej o nazwie wiersz typu Integer. Zmienna
będzie przechowywała wartości licznika pętli. W linii For wiersz=1 To 56
została zdefiniowana pętla. Przy pierwszym wykonaniu pętli wartość zmiennej
wiersz równa się 1. Ponieważ nie została określona wartość kroku pętli, jest
przyjmowana wartość domyślna, czyli 1. Wartość zmiennej wiersz jest
zwiększana o wartość 1 przy każdym wykonaniu pętli. Pętla jest wykonywana
ostatni raz, gdy wartość tej zmiennej osiągnie 56. Zmienna wiersz przybiera
wartości numeryczne od 1 do 56 i pełni funkcję licznika pętli. Po podstawieniu
do linii Cells(wiersz,1).Interior.ColorIndex=wiersz określa adres komórki
i przypisany jej kod koloru. W przykładzie stały numer ma kolumna. Numer
wiersza zaś jest określany przez zmienną wiersz i przy każdym wykonaniu
pętli jest zwiększany o jeden. Instrukcja Next wiersz powoduje zapętlenie.
W instrukcji Next nazwa licznika (wiersz) nie jest wymagana. Dzięki podaniu
nazwy licznika w instrukcji kończącej pętlę staje się ona bardziej czytelna.
Rysunek 6.45.
Zamiast definiowania
56 operacji
przypisania wartości,
jak w poprzednim
przykładzie,
można posłużyć się
instrukcją pętli
4. Uruchom program.
6. W komórkach od A1 do A56 zostały wyświetlone próbki kolorów
(rysunek 6.46).
Rysunek 6.46.
Rezultat identyczny
jak na rysunku 6.44
osiągnięto znacznie
mniejszym nakładem
pracy
Nadawanie koloru zawartości komórki

Kolorowanie tła komórek nie wyczerpuje wszystkich możliwości wyróżniania kolorem
obszarów arkusza. Ciekawy efekt można uzyskać, zmieniając kolor czcionki. Aby przypi-
sać czcionce kod koloru, należy posłużyć się właściwością Font.
Przykład 112.
Napisz program, którego zastosowanie pozwoli nadawać czcionkom z obszaru od A1
do A56 kolory z palety barw dostępnej za pośrednictwem właściwości ColorIndex. Wy-
korzystaj instrukcję pętli.
1. Uruchom arkusz kalkulacyjny Excel. Wpisz tekst do komórek od A1 do A56
(rysunek 6.47).
Rysunek 6.47.
Domyślnie tekst
ma kolor czarny

deklaracji wszystkich zmiennych. W drugiej linii nazwa procedury Dim wiersz
As Integer jest deklaracją zmiennej o nazwie wiersz typu Integer. Zmienna
będzie przechowywała wartości licznika pętli. W linii For wiersz=1 To 56
została zdefiniowana pętla. Przy pierwszym wykonaniu pętli wartość zmiennej
wiersz równa się 1. Ponieważ nie została określona wartość kroku pętli,
jest przyjmowana wartość domyślna, czyli 1. Wartość zmiennej wiersz jest
zwiększana o wartość 1 przy każdym wykonaniu pętli. Pętla jest wykonywana
ostatni raz, gdy wartość tej zmiennej osiągnie 56. Zmienna wiersz przybiera
wartości numeryczne od 1 do 56 i pełni funkcję licznika pętli. Po podstawieniu
do linii Cells(wiersz,1).Font.ColorIndex=wiersz określa adres komórki
i przypisany jej kod koloru. W przykładzie stały numer ma kolumna. Numer
wiersza zaś jest określany przez zmienną wiersz i przy każdym wykonaniu
pętli zwiększany o jeden. Instrukcja Next wiersz powoduje zapętlenie.
W instrukcji Next nazwa licznika (wiersz) nie jest wymagana. Dzięki podaniu
nazwy licznika w instrukcji kończącej pętlę staje się ona bardziej czytelna.
Rysunek 6.48.
Program, którego
zamienić napisy
czarne w wielobarwne
4. Uruchom program.
6. W komórkach od A1 do A56 zostały wyświetlone próbki kolorów (rysunek 6.49).
Rysunek 6.49.
Fragment arkusza
z rysunku 6.47
po zmianie kolorów
czcionki
Przesuwanie aktywnej komórki

W arkuszu kalkulacyjnym musi zostać wybrana przynajmniej jedna komórka. W niej
będą się np. pojawiały znaki wpisywane z klawiatury. Jest ona wyróżniona grubszą
obwódką.
Jest możliwe pozostawienie zaznaczenia jednej komórki i uczynienie aktywną innej.

Jest to wykonalne dzięki właściwości Offset. Ma ona następującą składnię:
Offset(x,y)
gdzie:
x — przesunięcie w poziomie,
y — przesunięcie w pionie.
Wartości ujemne pozwalają odpowiednio na przesunięcie w lewo lub w górę. Wartości

dodatnie pozwalają odpowiednio na przesunięcie w prawo lub w dół.
Oczywiście istnieje również możliwość sterowania z poziomu programu VBA zazna-

czeniem komórki. Umożliwia to właściwość obiektu Application — ActiveCell.
Przykład 113.
Napisz program, którego zastosowanie pozwoli przesuwać aktywną komórkę o jedną
komórkę w dół i trzy komórki w prawo, a następnie wstawić do niej tekst Zawartość.
deklaracji wszystkich zmiennych. W drugiej linii jest widoczna nazwa
procedury. W trzeciej linii znajduje się instrukcja zmiany aktywnej komórki.
Punktem odniesienia jest komórka A1. Właściwość Offset pozwala
na przesunięcie zaznaczenia o jedną komórkę w dół i trzy komórki w prawo.
Ciąg znaków widoczny po znaku równości zostanie wstawiony do zaznaczonej
komórki.
Rysunek 6.50.
Program, którego
na wstawienie napisu
do komórki, która nie
jest zaznaczona
3. Uruchom program.
5. W komórce D2 pojawił się napis (rysunek 6.51).
Rysunek 6.51.
Jest zaznaczona komórka
A1. Treść została wpisana
do komórki odległej
o zadane przesunięcie

Napisz program, którego zastosowanie pozwoli przesuwać aktywną komórkę o trzy
komórki w dół i jedną w prawo, a następnie wstawić do niej tekst Zawartość.
Przykład 100.
Napisz program, którego zastosowanie pozwoli przesuwać zaznaczenie komórki o jedną
komórkę w dół i trzy komórki w prawo.
deklaracji wszystkich zmiennych. W drugiej linii jest widoczna nazwa
procedury. W trzeciej linii znajduje się instrukcja wyboru zaznaczenia
komórki. Punktem odniesienia jest bieżąca komórka. Właściwość Offset(1, 3)
powoduje przesunięcie zaznaczenia względem aktualnego o jedną komórkę
w dół i trzy komórki w prawo. Metoda Offset pozwala na wybranie komórki
i oznaczenie jej pogrubioną ramką.
Rysunek 6.52.
Program, którego
przesuwać zaznaczenie
komórki o jedną
komórkę w dół i trzy
komórki w prawo
3. Wyświetl arkusz kalkulacyjny Excel. Sprawdź, czy komórka A1 jest zaznaczona.

Jeżeli nie — zaznacz ją (rysunek 6.53).
Rysunek 6.53.
Komórka zaznaczona
domyślnie

5. Wyświetl okno arkusza Excel (rysunek 6.54).
Rysunek 6.54.
Jest zaznaczona
komórka D2

Napisz program, który będzie „pytał” o współrzędne zaznaczonej komórki, a następnie
„przesuwał” zaznaczanie zgodnie z wprowadzonymi danymi.
Podsumowanie
 Obiektem jest element składowy aplikacji, np. komórka, zakres komórek,
wykres umieszczony na arkuszu, arkusz, skoroszyt.
 Obiekty mają właściwości. Właściwość jest cechą obiektu. Właściwościami
zakresu komórek są: zawartość komórki, styl czcionki itp.
 Metoda jest operacją wykonaną na obiekcie, umożliwia np. wpisanie tekstu
do komórki lub zaznaczenie zakresu komórek.
Rozdział 7.
Instrukcje warunkowe
 Do czego służy instrukcja skoku GoTo
 Do czego służy konstrukcja If … Then
 Jakiej instrukcji należy użyć, jeżeli w programie zachodzi konieczność
wyboru jednej z trzech opcji
 Jaką pętlę trzeba zastosować, jeżeli w programie zachodzi konieczność
powtórzenia grupy instrukcji określoną liczbę razy
 Jaką pętlę należy zastosować, gdy nie jest znana liczba powtórzeń pętli,
ale jest znany warunek, po spełnieniu którego pętla kończy działanie
 Czym różnią się pętle Do Until i Do While
Instrukcje warunkowe nie są tworem sztucznym. Na co dzień również z nimi się spoty-
kamy. Znanym przykładem jest „Być albo nie być” (ang. To be, or not to be) — fraza
pochodząca z utworu Hamlet, książę Danii autorstwa Williama Shakespeare'a. Skoro
program ma być modelem rzeczywistości, w nim również powinna być możliwość wy-
konania operacji w zależności od warunków.
W zaprezentowanych do tej pory przykładach instrukcje były wykonywane sekwencyjnie.

Takie rozwiązania są stosowane w najprostszych programach. Na kilku przykładach
pokazałem, jak można uprościć kod programu dzięki sprawdzaniu zadanego warunku.
W praktyce może zachodzić potrzeba wielokrotnego wykonania fragmentu programu.

Z takim przypadkiem możemy mieć do czynienia, gdy są wykonywane np. obliczenia
iteracyjne i są one powtarzane, gdy nowy wynik różni się od poprzedniego o więcej
niż zadaną wartość. Nie znamy więc na początku liczby powtórzeń operacji, a tylko
warunek, który musi być spełniony.
Innym przypadkiem jest pominięcie wykonania kilku instrukcji. Z taką sytuacją

możemy mieć do czynienia, gdy np. program wylicza podatek od dochodów osobistych.
W zależności od osiągniętych dochodów są wykonywane obliczenia z uwzględnieniem
stałych dla określonego przedziału dochodów. Program podaje wynik i kończy pracę.
Obliczenia z uwzględnieniem stałych dla innych przedziałów dochodów nie są wy-

konywane.
Dla użytkownika programu takie działanie komputera może sprawiać wrażenie, że

maszyna myśli. Musisz pamiętać, że komputer nie ma intuicji, nie myśli. Wykona do-
kładnie to, co zostało zaprogramowane, nawet jeżeli nie będzie to miało najmniejszego
sensu.
W wykonywaniu obliczeń aż do osiągnięcia wymaganej dokładności po wybraniu

podprogramu może wyręczyć człowieka program. Komputer świetnie nadaje się do
wykonywania czynności powtarzalnych. Nie myli się. Nie męczy się. Nie choruje. Nie
chodzi na urlop. Nie trzeba mu płacić za nadgodziny. Jest pracownikiem idealnym. Dla-
tego w firmach pracownicy są zastępowani przez komputery. To tylko kwestia innego
zorganizowania działań — zamiast kilku osób pracę wykonuje komputer i osoba, któ-
ra potrafi go obsłużyć. Dlatego warto być tą osobą.
Włożenie większego trudu w pisanie programu, przeanalizowanie obliczanych wartości,

sformułowanie warunków zaprocentuje w przyszłości. Napisanie programu, który sam
będzie „czuwał” nad wybraniem prawidłowego sposobu wykonywania obliczeń, zajmie
Ci kilka godzin. Poświęcisz je raz, a następnie będziesz już tylko korzystał z owoców
swej pracy. Jeżeli będziesz kierował się pozorną oszczędnością i napiszesz prosty
program, który sam będziesz uruchamiał tyle razy, ile potrzeba, aby uzyskać odpowied-
nią dokładność wyników, lub jeżeli będziesz analizował wysokość dochodów i wybierał
program dostosowany do odpowiedniej skali podatkowej, to za każdym razem będziesz
wykonywał te działania przez pół godziny. Po kilkukrotnym skorzystaniu z takiego
programu sumaryczny czas poświęcony na obliczenia będzie dłuższy niż czas po-
trzebny na napisanie dopracowanego programu. Z każdym uruchomieniem programu
różnica na korzyść dopracowanej aplikacji będzie się powiększała. Jeżeli przewidujesz,
że z programu będziesz korzystać wielokrotnie, nie żałuj czasu na jego dopracowanie.
Każda poświęcona na ten cel chwila będzie procentować. Twoja praca będzie coraz
łatwiejsza i efektywniejsza.
Dopracowanie programu jest warunkiem koniecznym, jeśli zamierzasz go sprzedawać.

Nikt nie będzie chciał kupić programu, który — zamiast oszczędzać czas i ułatwiać
pracę — będzie wymagał ręcznego sterowania.
Porównywanie
Do porównywania wartości są wykorzystywane:
 znak równości =,
 znak mniejszości <,
 znak większości >,
 znak: mniejsze lub równe <=,
 znak: większe lub równe >=,
 znak: różny od <>.
Rozdział 7.  Instrukcje warunkowe 215
Można porównywać nie tylko liczby, ale również teksty. Najczęściej do porównywania
tekstów są używane znaki: = oraz <>.
Wiele osób ma problemy z zapamiętaniem, po której stronie znaku > lub < powinna
znajdować się większa wartość. Problem ten miałem i ja. Był on szczególnie do-
kuczliwy, gdy wracałem do szkoły po wakacjach. Na szczęście nauczyciel matema-
tyki podpowiedział mi, jak zapamiętać, który znak co oznacza. < lub > przypomina
otwarty pysk psa. Pies jest sprytny i otwiera pysk w tę stronę, gdzie jest więcej kiełbasy.
Prawda, że proste?
Sterowanie wykonywaniem procedur

Do sterowania wykonywaniem procedur są wykorzystywane:
 instrukcja GoTo,
 konstrukcja If … Then,
 konstrukcja Select Case,
 pętla For ... Next,
 pętla Do While,
 pętla Do Until.
Skok do etykiety
Instrukcja GoTo etykieta umożliwia skok do oznaczonego etykietą miejsca w pro-
gramie. Skok jest wykonywany zawsze, niezależnie od wprowadzonych parametrów,
wyliczonych wartości itp. Jest on zwany skokiem bezwarunkowym.
Etykieta może być nazwą lub numerem linii.
Instrukcja GoTo może być wykorzystana do skoku tylko wewnątrz procedury, w której
została użyta.
Instrukcja GoTo służy tylko do przejścia do miejsca oznaczonego etykietą. Ewentualne

sprawdzenie warunku należy wykonać przy wykorzystaniu innej instrukcji.
Przykład 117.
Napisz program, którego zastosowanie umożliwi sprawdzenie, czy wpisana liczba jest
całkowita. Jeśli będzie ona typu Integer, zostanie wyświetlona informacja o popraw-
ności danej. Jeśli wprowadzony znak będzie innego typu, zostanie wyświetlony ko-
munikat o błędzie.

2. Wpisz z klawiatury kod (rysunek 7.1). W pierwszej linii znajduje się wymuszenie
deklaracji wszystkich zmiennych. W drugiej linii jest zapisana nazwa procedury.
Zmienna i została zadeklarowana jako przechowująca liczby całkowite. Jeżeli
zostanie jej przypisana wartość innego typu, np. litera, program potraktuje to
jako błąd. W linii On Error GoTo Komunikat jest zapisana instrukcja skoku do
etykiety Komunikat. Skok jest wykonywany wówczas, gdy zostanie wykryty
błąd. Po skoku do etykiety Komunikat jest wykonywana instrukcja MsgBox
("Wpisałeś liczbę niecałkowitą"). W wyniku jej zastosowania zostaje
wyświetlony komunikat, po którym program przechodzi do linii GoTo Koniec.
Zawiera ona instrukcję skoku bezwarunkowego do etykiety Koniec:. Po niej
znajduje się instrukcja kończąca procedurę.
Rysunek 7.1.
Program ze skokami
bezwarunkowymi

4. Po pojawieniu się okna z informacją Wpisz liczbę całkowitą wprowadź liczbę
całkowitą z klawiatury (rysunek 7.2).
Rysunek 7.2.
Okno do
wprowadzania
danych. Zostanie
wpisana liczba
całkowita

6. Został wyświetlony komunikat: Wpisałeś liczbę całkowitą (rysunek 7.3).
Rysunek 7.3.
Program „wykonał
skok” do etykiety OK
(patrz rysunek 7.1)

8. Program zakończył działanie. Zostało wyświetlone okno edytora VBA.
10. Po pojawieniu się okna z informacją Wpisz liczbę całkowitą wprowadź literę
z klawiatury (rysunek 7.4).
Rysunek 7.4.
Okno do wprowadzania
danych. Zostanie
wpisana litera

12. Wprowadzony znak nie jest liczbą całkowitą. Przypisanie go zmiennej
i spowoduje wygenerowanie błędu. Program „wykona skok” do etykiety
Komunikat.
13. Został wyświetlony komunikat Wpisałeś liczbę niecałkowitą (rysunek 7.5).
Rysunek 7.5.
Program „wykonał
skok” do etykiety
Komunikat
(patrz rysunek 7.1)

15. Program przechodzi do linii GoTo Koniec. Zawiera ona instrukcję skoku
bezwarunkowego do etykiety Koniec:. Po niej znajduje się instrukcja kończąca
procedurę.
16. Program zakończył działanie. Zostało wyświetlone okno edytora VBA.
Przykład 118.
Napisz program, którego zastosowanie pozwoli wykonywać dzielenie liczb wprowa-
dzonych do komórek A2 i B2 arkusza. Jeśli dane będą błędne, zostanie wyświetlony
komunikat o błędzie.
2. Wpisz z klawiatury kod (rysunek 7.6). W pierwszej linii znajduje się
wymuszenie deklaracji wszystkich zmiennych. W drugiej linii jest zapisana
nazwa procedury. W trzeciej linii umieszczono instrukcję obsługi błędów.
Gdy w programie zostanie stwierdzony błąd, np. jeśli użytkownik wprowadził
do określonych komórek wartości inne niż numeryczne lub jeśli dzielnik
ma wartość zero, program „przeskakuje” do etykiety Komunikat. Następuje
wyświetlenie okna komunikatu. Są w nim widoczne: opis błędu i tekst
sprawdź poprawność danych. W linii czwartej są deklarowane zmienne:
Dzielna, Dzielnik i Iloraz. W linii piątej zmiennej Dzielna jest przypisywana
zawartość komórki A2. W kolejnej linii zmiennej Dzielnik jest przypisywana
zawartość komórki B2. Wynik dzielenia jest wyświetlany w komórce C2.
Rysunek 7.6.
Program do
wyliczania ilorazu
zawartości komórek
A2 i B2 z prostą
obsługą błędów

4. Wpisz w nim zestaw danych (rysunek 7.7).
Rysunek 7.7.
Poprawny
zestaw danych

8. W arkuszu jest widoczny wynik obliczeń (rysunek 7.8).
Rysunek 7.8.
Poprawny zestaw
danych dał poprawny
wynik obliczeń
9. Wpisz w komórce B2 liczbę 0 (rysunek 7.9).
Rysunek 7.9.
Wynik obliczeń zostanie
zaktualizowany dopiero
po uruchomieniu programu
Wygląd arkusza, w którym komórki są wypełniane przez programy VBA, może być
nieco mylący (rysunek 7.9). Zawartość komórki wyliczanej przez formułę jest aktu-
alizowana po każdej zmianie danych. Aby w komórce wypełnianej przez program VBA
został zaktualizowany wynik, należy uruchomić program.
11. Uruchom program, naciskając klawisz F5.

12. Zamiast zaktualizowanego wyniku zostało wyświetlone okno komunikatu
(rysunek 7.10). Oznacza to, że program „wykonał skok” do etykiety Komunikat.
Informacja po lewej stronie łącznika została wyświetlona przez VBA. Tekst
po prawej stronie łącznika to ciąg znaków wpisany w instrukcji MsgBox.
Rysunek 7.10.
Komunikat
informujący o tym,
że dzielnik ma
wartość 0

15. W komórce B2 wpisz liczbę 1.
16. W komórce A2 wpisz literę a (rysunek 7.11).
Rysunek 7.11.
Jako dzielną
wpisano literę

18. Uruchom program.
19. Ponownie zamiast zaktualizowanego wyniku zostało wyświetlone okno
komunikatu (rysunek 7.12). Oznacza to, że program „wykonał skok”
do etykiety Komunikat. Informacja po lewej stronie łącznika została wyświetlona
przez VBA. Dlatego komunikaty różnią się w zależności od błędu. Tekst
po prawej stronie łącznika to ciąg znaków wpisany w instrukcji MsgBox.
Rysunek 7.12.
Informacja
o niepoprawnym
typie danej

Z programu pokazanego na rysunku 7.6 usuń instrukcję GoTo (rysunek 7.13). Sprawdź,
jak będzie działał program dla tego samego zestawu danych, jaki został użyty w przy-
kładzie 118.
Rysunek 7.13.
Program z przykładu
118. z usuniętym
modułem do obsługi
błędów
Przykład 120.
Napisz program, którego zastosowanie pozwoli wyświetlać kolejno okna dialogowe do
wpisania: imienia, nazwiska i symbolu działu. Wprowadzane dane będą umieszczane
w kolejnych komórkach tego samego wiersza arkusza Excela. Po wpisaniu danych
jednego pracownika program powinien „zapytać”, czy dane następnej osoby będą wpi-
sywane.

wymuszenie deklaracji wszystkich zmiennych. W linii drugiej jest zapisana
nazwa procedury. Zmienne Imię, Nazwisko i Dział zostały zadeklarowane jako
ciągi znaków. Zmienne i oraz koniec mogą przechowywać liczby całkowite.
Dane będą wpisywane w kolumnach. W pierwszym wierszu arkusza należy
umieścić opis. Zmienna i określa numer wiersza. Dlatego nadano jej wartość 2.
Dane będą wprowadzane od wiersza drugiego. Start to nic innego jak etykieta.
Etykieta jest miejscem w programie, do którego „jest wykonywany skok”.
Skok będzie wykonywany z trzeciej linii od końca (GoTo Start). Zastosowanie
instrukcji Cells(i, 1).Select prowadzi do wybrania komórki znajdującej się
w wierszu o numerze i oraz kolumnie o numerze 1. Zastosowanie instrukcji
Imię = InputBox("Wpisz imię", "Imię") prowadzi do wyświetlenia okna
dialogowego z prośbą o wpisanie imienia. Wprowadzony ciąg znaków jest
przypisywany zmiennej Imię. Zastosowanie instrukcji ActiveCell.Value = Imię
prowadzi do przypisania komórce aktywnej (czyli tej o adresie i, 1) wartości
zmiennej Imię. Zastosowanie instrukcji Cells(i, 2).Select prowadzi
do wybrania komórki znajdującej się w wierszu o numerze i oraz kolumnie
o numerze 2. Zastosowanie instrukcji Nazwisko = InputBox("Wpisz nazwisko",
"Nazwisko") prowadzi do wyświetlenia okna dialogowego z prośbą o wpisanie
nazwiska. Wprowadzony ciąg znaków jest przypisywany zmiennej Nazwisko.
Zastosowanie instrukcji ActiveCell.Value = Nazwisko prowadzi do przypisania
komórce aktywnej (czyli tej o adresie i, 2) wartości zmiennej Nazwisko.
Zastosowanie instrukcji Cells(i, 3).Select prowadzi do wybrania komórki
znajdującej się w wierszu o numerze i oraz kolumnie o numerze 3. Zastosowanie
instrukcji Dział = InputBox("Wpisz symbol działu", "Dział") daje w efekcie
wyświetlenie okna dialogowego z prośbą o wpisanie symbolu działu.
Wprowadzony ciąg znaków jest przypisywany zmiennej Dział. Zastosowanie
instrukcji ActiveCell.Value = Dział daje w efekcie przypisanie komórce
aktywnej (czyli tej o adresie i, 3) wartości zmiennej Dział. Po wprowadzeniu
danych do trzech okien z pytaniami został wypełniony jeden wiersz. Teraz
użytkownik musi zadecydować, czy chce wprowadzać informacje o kolejnym
pracowniku, czy przerwać działanie programu. To zadanie ułatwia mu
wyświetlenie okna z odpowiednim pytaniem. Odpowiedź zostaje przypisana
zmiennej koniec. Jeżeli zmienna jest różna od 1, następuje „skok” do etykiety
xxx i zakończenie działania programu. Jeżeli zmienna koniec ma wartość 1,
następuje przejście do instrukcji zwiększającej wartość zmiennej i o 1,
a następnie jest wykonywany „skok” do miejsca w programie oznaczonego
etykietą Start.
Śledzenie działania programu bardziej rozbudowanego ułatwiają etykiety o nazwach

kojarzących się z sytuacjami, w których wystąpią „skoki” do poszczególnych etykiet.
Przedstawiony powyżej kod można uprościć, eliminując zmienne łańcuchowe i używając

obiektu Range.
Rysunek 7.14.
Program, którego
zastosowanie ułatwia
wpisywanie danych
do arkusza
3. Wyświetl arkusz programu Excel. W pierwszym wierszu umieść opisy kolumn

(rysunek 7.15).
Rysunek 7.15.
Opisy kolumn

5. Uruchom program.
6. Zostało wyświetlone okno arkusza z zaznaczoną komórką, do której zostaną
wprowadzone dane. Na pierwszym planie jest widoczne okno dialogowe
(rysunek 7.16). Wpisz imię pracownika.
Rysunek 7.16.
Okno dialogowe pełni
funkcję formularza do
wprowadzania danych

(rysunek 7.17). Wpisz nazwisko pracownika.
Rysunek 7.17.
Imię zostało
wstawione do kolumny
przeznaczonej na
imiona. W oknie
dialogowym należy
wpisać nazwisko

(rysunek 7.18). Wpisz symbol działu pracownika.
Rysunek 7.18.
Jan Kowalski
pracuje w dziale
socjalno-bytowym,
w skrócie SB

12. Pierwszy rekord jest gotowy (rysunek 7.19). Zostało wyświetlone okno
z pytaniem o wypełnianie rekordów kolejnych.
Rysunek 7.19.
Program „dotarł”
do szóstej instrukcji
od końca (patrz
rysunek 7.14)

14. Została zaznaczona komórka w następnym wierszu. Zostało także wyświetlone
okno do wpisania imienia (rysunek 7.20).
Rysunek 7.20.
Program „wykonał
skok” na początek
pętli i wykonuje ją
z wartością zmiennej
zwiększoną o 1
15. Postępując w sposób analogiczny do pokazanego w punktach 6. – 13.,

wprowadź dane kolejnego pracownika.
16. Po wyświetleniu okna z pytaniem o kontynuowanie pracy (rysunek 7.21)
kliknij przycisk Anuluj.
Rysunek 7.21.
Dane pracowników
zostały wpisane.
Można zakończyć
pracę
Przed zamknięciem arkusza należy zapisać dane w pliku.
Rysunek 7.22.
Dane zostały
wprowadzone
do arkusza

Zmodyfikuj program z przykładu 120. tak, aby jego zastosowanie umożliwiało wpisanie:
nazwy miejscowości, adresu posesji i numeru wodomierza. Zwróć uwagę na zmianę opi-
sów okien, nazw zmiennych i deklaracje typów zmiennych.
Podejmowanie decyzji
Jeżeli w programie zachodzi konieczność sprawdzenia warunku i wykonania procedury,
gdy warunek jest spełniony, należy zastosować konstrukcję If … Then. Jej podstawowa
składnia jest następująca:
If warunek
Then
Instrukcje_wykonywane_jeśli_warunek_został_spełniony
Można ją również opcjonalnie rozszerzyć o instrukcję, która będzie wykonywana, jeśli

warunek nie jest spełniony. Ma ona wówczas składnię:
If warunek
Then
Instrukcje_wykonywane_jeśli_warunek_został_spełniony
Else
Instrukcjewykonywane_jeśli_warunek_nie_został_spełniony
Przykład 122.
Napisz program, który na podstawie wpisanej temperatury ciała będzie „nakazywał” pój-
ście do pracy lub do lekarza. Jako temperaturę maksymalną, dopuszczalną dla uznania
człowieka za zdrowego, przyjmij 37,5°C.
wymuszenie deklaracji wszystkich zmiennych. W drugiej linii typ zmiennej
i jest zadeklarowany jako String. Można również zadeklarować typ Long.
W drugim przypadku wpisanie litery spowoduje wyświetlenie komunikatu
o błędzie. W linii trzeciej jest zapisana nazwa procedury. Zastosowanie instrukcji
i = InputBox("Wpisz temperaturę") da w efekcie wyświetlenie okna,
w którym można wpisać wysokość temperatury ciała. Wpisana wartość
zostanie przypisana zmiennej i. W kolejnej linii jest sprawdzana wartość
zmiennej i. Jeżeli jest ona mniejsza niż 37,5 lub równa 37,5, jest wyświetlane
okno z komunikatem Do roboty!. W pozostałych przypadkach jest wyświetlane
okno z komunikatem Idź do lekarza!. Program trzeba skonstruować tak, aby
instrukcja warunkowa po wprowadzeniu niepoprawnej wartości generowała
prawidłowy komunikat, lub trzeba dodać procedurę obsługi błędów.
Nazwy zmiennych są zależne od programisty. Przyjęto, że zmienne i, j, k… są typu

iteracyjnego. Nic jednak nie stoi na przeszkodzie, aby przypisać zmiennej np. tem-
peraturę wpisaną z klawiatury.
3. Uruchom program.
4. Po wyświetleniu okna z prośbą o wpisanie temperatury wpisz liczbę –10.
6. Choć wartość jest bezsensowna, program „uznał”, że pacjent jest zdrów.
Rysunek 7.23. Komputerowy „Lekarz domowy”
7. W oknie komunikatu kliknij przycisk OK.

8. Zostało wyświetlone okno edytora Visual Basic.
9. Uruchom program.
10. Po wyświetleniu okna z prośbą o wpisanie temperatury wpisz liczbę 37,6.
12. Program „uznał”, że pacjent jest chory.
16. Po wyświetleniu okna z prośbą o wpisanie temperatury wpisz @.
18. Program „uznał”, że pacjent jest chory (rysunek 7.24).
Rysunek 7.24.
Wpisanie zamiast temperatury znaku @
również powoduje wygenerowanie
komunikatu o potrzebie konsultacji
z lekarzem. Słusznie! Może to bowiem
oznaczać, że pacjent jest tak chory,
że nie odróżnia liter od cyfr!

Zmodyfikuj program z przykładu 122. tak, aby po wpisaniu temperatury niższej niż
34°C sygnalizował błąd.
Instrukcją, która doskonale zastępuje zagnieżdżone instrukcje If… Then… Else,

gdy konieczne jest wybieranie pomiędzy wieloma dostępnymi opcjami, jest Select
Case.

Zmodyfikuj program z przykładu 123. tak, aby po wpisaniu temperatury wyższej niż
43°C sygnalizował błąd.

Zmodyfikuj program z przykładu 124. tak, aby po wpisaniu znaku innego niż liczba
rzeczywista sygnalizował błąd.

Zmodyfikuj program z przykładu 125. tak, aby po wyświetleniu wyniku „zadawał
pytanie”, czy ma zakończyć pracę, czy oczekiwać na podanie kolejnej wartości tem-
peratury.
Wybór jednej z trzech lub więcej opcji

Jeżeli w programie zachodzi konieczność dokonania wyboru jednej spośród trzech
lub więcej opcji, należy zastosować konstrukcję Select Case.
Podstawowa składnia konstrukcji Select Case jest następująca:

Select Case sprawdzane_wyrażenie
Case zestaw_1_wartości_wyrażenia
Instrukcje_wykonywane_gdy_sprawdzane_wyrażenie_zwraca_wartość_z_zestawu_1
…
Case zestaw_n_wartości_wyrażenia
Instrukcje_wykonywane_gdy_sprawdzane_wyrażenie_zwraca_wartość_z_zestawu_n
Przykład 112.
Przy ocenie otyłości jest istotny stosunek wagi do wzrostu człowieka. Te wartości wiąże
współczynnik BMI (ang. Body Mass Index — współczynnik masy ciała). Jest on wy-
liczany jako iloraz wagi wyrażonej w kilogramach do podniesionego do kwadratu
wzrostu wyrażonego w metrach. Na podstawie wartości współczynnika można określić,
czy waga człowieka jest prawidłowa (tabela 7.1).
Tabela 7.1. Ocena budowy ciała człowieka w zależności od wartości BMI

BMI Ocena budowy ciała
< 20 Niedowaga
Od 20 do 24,9 Waga prawidłowa
Od 25 do 29,9 Nadwaga
Od 30 do 39,9 Otyłość
> 40 Otyłość patologiczna
Napisz program, którego zastosowanie na podstawie wpisanych wartości: wagi ciała

i wzrostu, będzie pozwalało oceniać budowę ciała.
wymuszenie deklaracji wszystkich zmiennych. W linii drugiej typ zmiennych
waga, wynik, wzrost i bmi został zadeklarowany jako Long. Zastosowanie
programu da w efekcie wyświetlenie okna, w którym można wpisać wagę
ciała. W kolejnym oknie można wpisać wzrost wyrażony w metrach. Zmiennej
bmi jest przypisywana wartość wyliczona jako iloraz wagi przez podniesiony
do kwadratu wzrost. W zależności od wyliczonej wartości zmiennej wynik
jest przypisywany jeden z pięciu komunikatów. Jest on wyświetlany w efekcie
wykonania instrukcji MsgBox.
Rysunek 7.25.
Komputerowy
„Strażnik wagi”
3. Uruchom program.
4. Po wyświetleniu okna z prośbą o wpisanie wagi wpisz swoją wagę
w kilogramach (rysunek 7.26).
Rysunek 7.26.
Waga ciała

6. Po wyświetleniu okna z prośbą o wpisanie wzrostu wpisz swój wzrost
w metrach (rysunek 7.27).
Rysunek 7.27.
Wzrost należy wpisać,
używając przecinka
do oddzielenia
pełnych metrów
od centymetrów

8. Zastosowanie programu doprowadziło do wyświetlenia oceny Twojej budowy
ciała (rysunek 7.28).
Rysunek 7.28.
Program jest
bezlitosny
Pokazany w przykładzie 127. program jest wykonywany bardzo szybko nawet przez
komputery o niewielkich możliwościach obliczeniowych. W praktyce możesz spo-
tkać się z programami, których zastosowanie pozwala sprawdzić więcej warunków
lub działać w pętli. W takiej sytuacji warto przeanalizować prawdopodobieństwo
wystąpienia poszczególnych wyników. Zastosowanie programu będzie pozwalało
sprawdzić warunki zapisane w instrukcji Select Case aż do napotkania pierwszego,
który zostanie spełniony. Im będzie on bliżej początku programu, tym czas poświęcony
na wykonanie instrukcji będzie krótszy.

Napisz program, którego zastosowanie prowadzi do wyświetlenia okna z prośbą o podanie
wieku. W zależności od wprowadzonej wartości jest wyświetlany komunikat zgodny
z tabelą 7.2.
Tabela 7.2. Ocena wieku ciała człowieka w zależności od przeżytych lat

Wiek Komunikat
<0 Chyba się jeszcze nie urodziłeś
Od 0 do 10 Słodkie dzieciństwo
Od 11 do 18 Wczesna młodość
Od 19 do 25 Młodość
Od 26 do 40 Dorosłość
Od 41 do 100 Druga młodość
Od 101 do 120 Wiek godny pozazdroszczenia
> 120 Nie oszukujesz?
Przykład 129.
Napisz program, którego zastosowanie w zależności od godziny będzie prowadziło do
wyświetlenia powitania zgodnie z tabelą 7.3.
Tabela 7.3. Treść powitania w zależności od godziny

Godzina Powitanie
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 Good morning!
12, 13, 14, 15, 16, 17 Good afternoon!
18, 19, 20, 21, 22, 23 Good evening!

wymuszenie deklaracji wszystkich zmiennych. W drugiej linii jest widoczna
nazwa programu. Funkcja Hour zwraca bieżącą godzinę, którą określa parametr
Now. Wszystkie godziny, które określają poranek i popołudnie, zostały zawarte
w dwóch pierwszych warunkach. Gdy godzina będzie inna, zostanie wykonany
warunek Case Else, czyli pokaże się komunikat Good evening!.
Rysunek 7.29.
Program, którego
zastosowanie
prowadzi do
wyświetlania
powitania o treści
zależnej od pory dnia
3. Uruchom program.
4. Zostało wyświetlone powitanie (rysunek 7.30).
Rysunek 7.30.
Godzina 13.08, czyli…
Good afternoon!
Wszystko się zgadza
Wykonanie grupy instrukcji określoną liczbę razy

Jeżeli w programie zachodzi konieczność powtórzenia grupy instrukcji określoną liczbę
razy, należy zastosować pętlę For ... Next. Ma ona następującą składnię:
For licznik = start To stop [Step krok]
[instrukcje]
[Exit For]
[instrukcje]
Next [licznik]
gdzie:
licznik — wymagany. Zmienna liczbowa przechowująca informacje o liczbie
wykonanych pętli.
start — wymagany. Początkowa wartość licznika.
krok — opcjonalny. Wartość, o którą będzie zwiększany licznik przed każdym
wykonaniem pętli. Jeżeli ta wartość nie zostanie podana, domyślnie będzie
przyjmowana wartość jeden.
instrukcje — opcjonalne. Jedna instrukcja lub więcej instrukcji zawartych
pomiędzy liniami For oraz Next. Są one wykonywane określoną przez parametry
pętli liczbę razy.
Przykład 130.
Napisz program, którego zastosowanie pozwoli wypełniać obszar o wymiarach 100×100
komórek arkusza losowo wybranymi kolorami.
deklaracji wszystkich zmiennych. W drugiej linii zostały zadeklarowane typy
dwóch zmiennych: w oraz k. Zmienna w będzie przechowywać numer wiersza,
a zmienna k — numer kolumny. Wartości obu będą należeć do liczb całkowitych.
Rysunek 7.31.
Program do losowego
kolorowania
komórek arkusza
3. Instrukcja Randomize uruchamia generator liczb losowych. Pierwsza pętla służy do

generowania numerów wierszy. Druga pętla służy do generowania numerów kolumn.
Instrukcja Cells(w, k).Interior.ColorIndex = Int(Rnd * 57) określa położenie
komórki. Zastosowanie funkcji Rnd prowadzi do wygenerowania liczby losowej.
Liczby losowe należą do przedziału od 0 do 1. Wartość musi zostać pomnożona
przez 57, aby było możliwe wygenerowanie wszystkich dostępnych kolorów
wypełnień. Kolory mają kody od 0 do 57. Po wypełnieniu 100 kolumn w danym
wierszu następuje zwiększenie numeru wiersza i jest wypełniana kolejna
setka kolumn.
4. Uruchom program.
Rysunek 7.32. Okno arkusza z komórkami wypełnionymi losowo dobranymi kolorami

6. Uruchom ponownie program.

Rysunek 7.33. Każde uruchomienie programu prowadzi do wygenerowania innego układu kolorów

Napisz program, którego zastosowanie pozwoli wypełniać obszar o wymiarach 10×5
komórek arkusza losowo wybranymi kolorami należącymi do palety składającej się
z 4 kolorów.
Przykład 132.
Napisz program, którego zastosowanie pozwoli generować losowo 6 spośród 49 liczb.
Liczby muszą być całkowite i zawierać się w przedziale od 0 do 49. Po wygenerowaniu
mają być wpisywane w kolejnych komórkach wiersza pierwszego.
deklaracji wszystkich zmiennych. W linii drugiej został zadeklarowany typ
zmiennej l. Zmienna l będzie przechowywać kolejny numer wygenerowanej
liczby oraz numer komórki w wierszu. Wartości powinny należeć do liczb
naturalnych. Instrukcja Randomize uruchamia generator liczb losowych. Pętla służy
do sześciokrotnego generowania liczby. Instrukcja Cells(1, l) = Int(Rnd * 49
określa położenie komórki. Wykorzystanie funkcji Rnd prowadzi do wygenerowania
liczby losowej. Liczba losowa należy do przedziału od 0 do 1. Musi zostać
pomnożona przez 49, aby wynik należał do przedziału od 0 do 49. Po wypełnieniu
6 kolumn w danym wierszu następuje zakończenie programu.
3. Uruchom program.
Rysunek 7.34.
Program do losowania
sześciu liczb
z przedziału od 0 do 49
Rysunek 7.35.
Zestaw
wygenerowanych liczb
Przykład 133.
Napisz program, którego zastosowanie pozwoli generować losowo 6 spośród 49 liczb.
Liczby muszą być całkowite i zawierać się w przedziale od 1 do 49. Po wygenerowaniu
mają być wpisywane w komórkach kolejnych wierszy. Jednorazowe uruchomienie
programu ma spowodować wygenerowanie sześciu zestawów liczb.
deklaracji wszystkich zmiennych. W drugiej linii został zadeklarowany typ
zmiennej l oraz w. Zmienna l będzie przechowywać kolejny numer
wygenerowanej liczby oraz numer komórki w wierszu. Wartości powinny
należeć do liczb naturalnych. Zmienna w będzie przechowywać kolejny numer
wiersza. Wartości powinny należeć do liczb naturalnych. Instrukcja Randomize
uruchamia generator liczb losowych. Pętla służy do sześciokrotnego
generowania liczby. Instrukcja Cells(w, l) = Int(Rnd * 49)określa
położenie komórki. Wykorzystanie funkcji Rnd prowadzi do wygenerowania
liczby losowej. Liczba losowa należy do przedziału od 0 do 1. Aby nie uzyskać
liczby 0, do wyniku jest dodawana liczba 1. Liczba losowa powinna zostać
pomnożona przez 48, aby wynik należał do przedziału od 1 do 49.
Po wypełnieniu 6 kolumn w danym wierszu następuje wykonanie kolejnej
pętli programu. Wygenerowanie sześciu kolumn zawierających po sześć liczb
powoduje zakończenie działania programu.
Rysunek 7.36.
Program do losowania
sześciu zestawów
po sześć liczb
z przedziału od 1 do 49
3. Uruchom program.
Rysunek 7.37.
Zestawy
wygenerowanych liczb
Przykład 134.
Napisz program, którego zastosowanie pozwoli do komórki o losowym adresie z prze-
działu od A1 do E5 wpisywać liczbę 999. Wyświetl okno Code (rysunek 4.3).
wymuszenie deklaracji wszystkich zmiennych. W linii drugiej został
zadeklarowany typ zmiennej l oraz w. Będą one przechowywać numery
komórek. Wartości powinny należeć do liczb naturalnych. Instrukcja
Randomize uruchamia generator liczb losowych. W wyniku zastosowania
instrukcji Cells(w, l) = 999 komórce o losowym adresie zostaje przypisana
liczba 999. Liczba losowa należy do przedziału od 0 do 1. Aby rozciągnąć
przestrzeń adresową na pięć komórek, liczba losowa powinna zostać
pomnożona przez 5.
Rysunek 7.38.
W wyniku zastosowania
programu do losowo
wybranej komórki
z przedziału od A1
do E5 zostaje wpisana
liczba 999
2. Uruchom kilka razy program.

Rysunek 7.39.
Senny koszmar każdego
użytkownika Excela
to losowo wpisane
błędne dane

Zmodyfikuj program z przykładu 132. tak, aby jego zastosowanie pozwoliło generować
osiem losowych liczb należących do przedziału od 0 do 1 (rysunek 7.40).
Rysunek 7.40.
Ośmiowymiarowy wektor
binarny, czyli bajt
Przykład 136.
Napisz program, którego zastosowanie pozwoli sumować pierwsze n liczb naturalnych.
Liczbę n należy wpisać po uruchomieniu programu.
wymuszenie deklarowania zmiennych. W drugiej linii zapisano nazwę
procedury. Zmienna Suma będzie przechowywała wynik. Została ona
zadeklarowana jako liczba podwójnej precyzji z zapisem zmiennoprzecinkowym.
Zmienne Licznik i n będą przechowywały liczbę zsumowanych liczb oraz
liczbę liczb do zsumowania. Zostały one zadeklarowane jako liczby całkowite.
W wyniku zastosowania instrukcji n = InputBox("Ile liczb naturalnych
zsumować") zostaje wyświetlone okno dialogowe z prośbą o wpisanie, ile liczb
ma zostać zsumowanych. W pętli odbywa się sumowanie n liczb naturalnych.
Wynik jest wyświetlany dzięki instrukcji MsgBox "Suma wynosi: " & Suma.
Rysunek 7.41.
Program
z wykorzystaniem
pętli For… Next
3. Uruchom program.
4. Po wyświetleniu okna z prośbą o wpisanie, ile liczb ma być sumowanych,
wpisz 3.
6. Został wyświetlony wynik (rysunek 7.42).
Rysunek 7.42.
Wynik sumowania
liczb 1, 2 i 3

9. Uruchom program.
10. Po wyświetleniu okna z prośbą o wpisanie, ile liczb ma być sumowanych,
wpisz 100.
12. Został wyświetlony wynik (rysunek 7.43). Tę wartość już trudniej sprawdzić
w pamięci niż pokazaną na rysunku 8.8.
Rysunek 7.43.
Wynik sumowania
liczb od 1 do 100
Pętle zagnieżdżone
Instrukcją znajdującą się wewnątrz pętli może być inna pętla. W taki sposób powstają
pętle zagnieżdżone.
Przykład 137.
Napisz program, którego zastosowanie pozwoli w komórki trójwymiarowej tablicy o wy-
miarach 3×3×3 wpisywać liczbę 1. Po każdym wpisie na ekranie będzie wyświetlany
numer komórki.
2. Wpisz z klawiatury kod (rysunek 7.44). W programie zadeklarowano
trójwymiarową tablicę o nazwie Tablica. Ma ona wymiary 3×3×3.
Zadeklarowano również trzy zmienne typu: Integer: X, Y i Z. W kolejnych
liniach programu znajdują się pierwsze linie pętli operujących na zmiennych:
X, Y oraz Z. Gdy wartości zmiennych X, Y i Z zostaną ustalone, do komórki
o współrzędnych X, Y i Z będzie podstawiana liczba 1. W kolejnej instrukcji
następuje wyświetlenie komunikatu ze współrzędnymi komórki.
Tablica jest tworem zadeklarowanym i powstałym w pamięci komputera.
Rysunek 7.44.
Program, którego
generować tablicę
o 27 elementach
i wyświetlać zawartość
dowolnej komórki
Warto sprawdzić, co zawiera. Do tego celu służą instrukcje znajdujące się

po linii MsgBox ("Kontrola zawartości komórek tablicy"). W wyniku
zastosowania programu pojawia się prośba o wpisanie kolejno współrzędnych X,
Y i Z. Po wprowadzeniu wszystkich współrzędnych zostają one wyświetlone,
a następnie zostaje podana informacja o zawartości komórki
o wyspecyfikowanym adresie.
3. Uruchom program.
4. Po wpisaniu cyfry jeden do komórki o współrzędnych 111 został wyświetlony
komunikat (rysunek 7.45).
Rysunek 7.45.
Jako pierwsza została
odwiedzona komórka
o współrzędnych 111

6. Program wpisał cyfrę jeden do kolejnej komórki (rysunek 7.46).
Rysunek 7.46.
Jako druga została
odwiedzona komórka
Zapoznaj się ze sposobem, w jaki są adresowane kolejne komórki (rysunek 7.47).

Czy potrafisz podać współrzędne przedostatniej komórki?
Rysunek 7.47.
Współrzędne
ostatniej komórki
8. Tablica została wypełniona. Program przeszedł do części, w której można

sprawdzić zawartość komórki (rysunek 7.48). Kliknij przycisk OK.
Rysunek 7.48.
Rezultat wykonania
instrukcji MsgBox
("Kontrola zawartości
komórek tablicy")
9. Zostało wyświetlone okno dialogowe, w którym można wpisać pierwszą

współrzędną tablicy (rysunek 7.49). Wpisz ją.
Rysunek 7.49.
Współrzędna jest
liczbą 1, 2 lub 3

11. W analogiczny sposób jak w punkcie 9. i 10. wpisz pozostałe współrzędne.
12. Po wprowadzeniu wszystkich współrzędnych zostaną one wyświetlone
w jednym oknie (rysunek 7.50).
Rysunek 7.50.
Współrzędne komórki

14. Zostało wyświetlone okno z zawartością komórki (rysunek 7.51) o adresie
pokazanym na rysunku 7.50.
Rysunek 7.51.
Do komórki
została wpisana
liczba 1
Wykonaj program ponownie. Sprawdź, czy można wyświetlić zawartość komórki znaj-
dującej się na zewnątrz tablicy (np. o współrzędnych 4, 1, 1)?
Tym, co odróżnia tablice VBA od arkusza Excela, jest liczba wymiarów. Arkusz Excela
posiada zawsze dwa wymiary określone przez numer wiersza oraz numer kolumny.
Aby przeanalizować np. wysokość sprzedaży oraz kosztów poniesionych w każdym
z dwunastu miesięcy roku, można użyć 24 zmiennych: 12 do opisania sprzedaży
(jedna zmienna na każdy miesiąc) oraz 12 zmiennych opisujących koszty (również
jedna na każdy miesiąc). Problem byłby poważniejszy, gdyby obliczenia wymagały
danych z kilku lat, a dodatkowo w ujęciu dziennym. Oczywiście byłoby to praktycz-
nie niewykonalne, a nawet jeśli ktoś uporałby się z zadeklarowaniem wszystkich
tych zmiennych, to praca z kodem, w którym znajdowałoby się tysiące niemal iden-
tycznych zmiennych, byłaby koszmarem, a niepopełnienie żadnego błędu graniczy-
łoby z cudem.
Właśnie w takich sytuacjach należy sięgnąć po tablice. Zamiast wszystkich zmien-
nych liczbowych można byłoby zadeklarować dwie zmienne tablicowe: przychody
oraz koszty. Każda zawierałaby 12 wierszy i 1 kolumnę (lub odwrotnie). W sytuacji,
gdyby dane miały obejmować kilka lat, wystarczyłoby po prostu dodać nową kolumnę
dla każdego nowego roku.
Deklaracja tablicy ma postać:
Dim tablica (x1 To y1, ..., xn To yn) As typ_danych
Tablica ma tyle wymiarów, ile wyrażeń xn To yn jest zawartych w nawiasie po nazwie
tablicy.

Zmodyfikuj program z przykładu 137. tak, aby po jednorazowym uruchomieniu apli-
kacji można było wyświetlać zawartość dowolnej liczby komórek.
Wykonywanie pętli, gdy warunek jest spełniony

Pętla For ... Next jest wykonywana bezwarunkowo. Pętlą, która działa identycznie jak
For ... Next, ale jest wykonywana po spełnieniu warunku, jest pętla Do While.
Pętlę Do While można stosować wówczas, gdy nie jest znana liczba powtórzeń pętli,
ale jest znany warunek, po spełnieniu którego pętla kończy działanie.

Do [While warunek]
[Instrukcje]
[Exit Do]
[instrukcje]
Loop
lub:
Do
[Instrukcje]
[Exit Do]
[instrukcje]
Loop [While warunek]
Różnica między pierwszą a drugą składnią zależy od momentu sprawdzania warunku.

W pierwszym przypadku warunek jest sprawdzany przed rozpoczęciem pętli. Jeśli nie
jest on spełniony, pętla nie zostanie wykonana ani razu. W drugim przypadku instrukcje
umieszczone w pętli są wykonywane raz, a następnie jest sprawdzany warunek. Jeżeli
jest on spełniony, pętla jest wykonywana ponownie.
Przykład 139.
Napisz program, którego zastosowanie polega na oczekiwaniu na wpisanie liczby, a na-
stępnie ― wyświetlaniu jej pierwiastka kwadratowego. Obliczenia nie zostaną wyko-
nane, gdy liczba nie zostanie wprowadzona. Warunek jest sprawdzany na końcu pętli.
Pierwiastek kwadratowy nie jest w szczególny sposób predystynowany do oblicza-

nia go w pętli. Został użyty w charakterze wypełniacza pętli.

2. Wpisz z klawiatury kod (rysunek 7.52). W pętli jest umieszczona instrukcja
wyświetlania okna z prośbą o wpisanie liczby. W kolejnej linii jest obliczany
pierwiastek z niej. Obliczona wartość jest wyświetlana w oknie komunikatu.
Następnie program sprawdza, czy została wprowadzona wartość. Jeśli nie
została wprowadzona, program kończy pracę. Minusem tego rozwiązania
jest wykonywanie obliczeń i wyświetlanie wyniku, mimo że dane nie zostały
wprowadzone.
Rysunek 7.52.
Program, który
najpierw liczy,
a potem sprawdza
3. Uruchom program.
4. Po wyświetleniu okna z prośbą o podanie liczby wpisz 3 (rysunek 7.53).
Rysunek 7.53.
Okno do wprowadzania
danej

6. Program wyświetlił wynik (rysunek 7.54).
Rysunek 7.54.
Wynik obliczeń

8. Po wyświetleniu okna z prośbą o podanie liczby kliknij przycisk OK.
9. Program wyświetlił komunikat o błędzie i zakończył działanie (rysunek 7.55).
Rysunek 7.55.

Zmodyfikuj program z przykładu 139. tak, aby kliknięcie przycisku OK lub Cancel
bez wprowadzenia danych nie spowodowało przerwania pracy programu. Powinna zostać
wyświetlona informacja o niepoprawnych danych i okno do wprowadzenia danych.

Zmodyfikuj program z przykładu 141. tak, aby zastosować w nim pętlę Do Until.
Podsumowanie
 Instrukcja GoTo etykieta umożliwia skok do oznaczonego etykietą miejsca
w programie. Skok jest wykonywany zawsze, niezależnie od wprowadzonych
parametrów, wyliczonych wartości itp. Jest on zwany skokiem bezwarunkowym.
Sprawdzanie warunków musi odbywać się przy wykorzystaniu innej
instrukcji. Instrukcja GoTo jest używana głównie do obsługi błędów
i rozgałęziania programów.
 Jeżeli w programie zachodzi konieczność sprawdzenia warunku i wykonania
procedury, gdy warunek jest spełniony, należy zastosować konstrukcję If … Then.
 Jeżeli w programie zachodzi konieczność dokonania wyboru jednej spośród
trzech lub więcej opcji, należy zastosować konstrukcję Select Case.
 Jeżeli w programie zachodzi konieczność powtórzenia grupy instrukcji
określoną liczbę razy, należy zastosować pętlę For ... Next.
 Pętlę Do While można stosować wówczas, gdy nie jest znana liczba powtórzeń
pętli, ale znany jest warunek, po spełnieniu którego pętla kończy działanie.
Rozdział 8.
Elementy sterujące
arkusza
 Jak utworzyć formularz
 Jak na formularzu umieszczać obiekty
 Jak przypisywać właściwości obiektom
Jeżeli wprowadzanie danych odbywa się z klawiatury, może być źródłem błędów. Naj-
częściej ich przyczyny są dwie.
Pierwszą z nich są literówki. Człowiek może domyślić się, co miał oznaczać dany wy-
raz. Komputer tego nie zrobi.
Drugą przyczyną błędów są różnice w nazwach tych samych przedmiotów nabywa-

nych w różnych firmach. Jeżeli człowiek nie sprawdzi, że istnieje już Układ scalony
UL6400 i utworzy w arkuszu pozycję UL6400, ten sam fizycznie element będzie ist-
niał pod dwiema nazwami.
Aby uniknąć takich sytuacji, autor programu nie powinien dawać każdemu użytkow-
nikowi możliwości dopisywania nowych nazw. Powinien jedynie zezwolić na wybie-
ranie nazw spośród dostępnych.
Powyższe rozwiązanie ma dodatkową zaletę. Wybieranie pozycji z listy zajmuje

mniej czasu niż wpisywanie ich z klawiatury.
Pole listy
Pole listy zawiera listę pozycji, które użytkownik może wybrać. Jest ono symbolizo-
wane przez ikonę pokazaną na rysunku 8.1.
Rysunek 8.1.
Ikona pola listy
Aby z pola listy wybrać pojedynczy element, wystarczy go kliknąć.
Aby z pola listy wybrać więcej niż jeden element:

 należy wcisnąć i przytrzymać klawisz Ctrl,
 kliknięciami zaznaczyć obiekty,
 zwolnić klawisz Ctrl.
Pozycje widoczne w polu listy można wstawić na dwa sposoby: określając zakres za-
wierający pozycje lub posługując się instrukcjami języka VBA.
Przykład 142.
Wstaw do projektu pole listy.
2. Wybierz polecenie Insert/UserForm (rysunek 8.2).
Rysunek 8.2.
Menu Insert umożliwia
wstawienie do
projektu formularza
3. W pasku Toolbox odszukaj ikonę ListBox (rysunek 8.3).
Rysunek 8.3.
Ikona umożliwiająca
wstawienie pola listy
4. Przeciągnij ikonę na formularz (rysunek 8.4).

Rozdział 8.  Elementy sterujące arkusza 247
Rysunek 8.4.
Położenie pola listy
jest wskazywane przez
przerywaną linię

6. Na formatce pojawił się nowy obiekt (rysunek 8.5).
Rysunek 8.5.
Wyróżniony obszar
wskazuje, gdzie
będzie się znajdowało
pole listy
Jeżeli pasek Toolbox jest ukryty, kliknij ikonę Toolbox (rysunek 8.6).
Rysunek 8.6.
Ikona Toolbox
Przykład 143.
Wyświetl kod pola listy.
1. Umieść w projekcie pole listy (patrz przykład 127.).
2. Kliknij prawym przyciskiem myszy pole listy.
Rysunek 8.7.
Menu podręczne
pola listy
4. Zostało wyświetlone okno z kodem odpowiadającym za wyświetlenie pola

listy (rysunek 8.8).
Rysunek 8.8.
Kod, którego
na wyświetlenie
pola listy
Aby ukryć okno kodu, kliknij przycisk Close Window (rysunek 8.9).
Rysunek 8.9.
Przycisk, którego
kliknięcie powoduje
zakmnięcie okna
Przykład 144.
Napisz program, którego zastosowanie doprowadzi do wyświetlenia formularza na
ekranie.
2. Wpisz z klawiatury kod (rysunek 8.10).
Rysunek 8.10.
Program, którego
zastosowanie prowadzi
do wyświetlenia na
ekranie formularza
UserForm
3. Uruchom program.
4. Na ekranie została wyświetlona formatka arkusza (rysunek 8.11).
Rysunek 8.11.
Okno arkusza
z formatką
Do zamknięcia formularza należy użyć instrukcji Unload nazwa_formularza, np.

Unload UserForm1.
Przykład 145.
Napisz program, którego zastosowanie doprowadzi do wyświetlenia w oknie listy

dwóch pozycji: Sekretariat i Sklep. Pozycje powinny być wpisane w: kodzie programu
i arkuszu kalkulacyjnym.
1. Uruchom arkusz kalkulacyjny Excel.

3. Wybierz polecenie Insert/UserForm (rysunek 8.12).
Rysunek 8.12.
Aby wstawić do
programu okno
formularza, należy
wybrać polecenie
Insert/UserForm
4. Wstaw do projektu pole listy (rysunek 8.13).
Rysunek 8.13.
Pole listy można
wstawić
po kliknięciu
ikony ListBox
5. Umieść kursor w miejscu, w którym ma się znaleźć narożnik pola listy.

6. Przeciągnij kursor do miejsca, w którym ma się znaleźć przeciwległy narożnik
pola listy (rysunek 8.14).
7. Na formularzu pojawiło się pole listy (rysunek 8.15).
Rysunek 8.14.
Położenie pola listy
wskazuje linia
przerywana
Rysunek 8.15.
Położenie i rozmiar
pola listy można
zmienić,
przeciągając
prostokąty
znajdujące się
w narożnikach
i na środkach
krawędzi
9. W komórce A1 wpisz Sekretariat (rysunek 8.16).
Rysunek 8.16.
Arkusz z wypełnionymi
komórkami A1 i A2
10. W komórce A2 wpisz Sklep.

12. Sprawdź, czy jest wybrane pole listy (rysunek 8.17). Jeśli nie — kliknij je.
Rysunek 8.17.
Pole listy musi być
wybrane, aby można
było modyfikować
jego właściwości
13. W oknie Properties - ListBox1 odszukaj pozycję RowSource (rysunek 8.18).

Rysunek 8.18.
Pole, w którym można
wpisać adres obszaru
zawierającego dane
do wyświetlenia
w polu listy
14. Kliknij pole znajdujące się na prawo od etykiety RowSource.

15. Wpisz adres obszaru, w którym znajdują się dane przeznaczone
do wyświetlenia w polu listy (patrz rysunek 8.19).
Rysunek 8.19.
Tekst wpisany
w arkuszu
kalkulacyjnym
w polu listy
16. Uruchom program. Na ekranie został wyświetlony formularz z polem listy

(rysunek 8.20).
Rysunek 8.20.
Formularz
użytkownika
z polem listy
18. Zamknij okno formularza.

Pole kombi (listy rozwijanej)

Pole kombi zawiera listę pozycji rozwijaną do dołu. Gdy jest ona zwinięta, jest wi-
doczna tylko jedna pozycja. Na prawo od niej znajduje się czarna strzałka skierowana
ku dołowi. Kliknięcie strzałki powoduje rozwinięcie listy, z której użytkownik może
wybrać element.
Pole kombi jest symbolizowane przez ikonę pokazaną na rysunku 8.21.
Rysunek 8.21.
Ikona pola kombi
Aby z pola kombi wybrać pojedynczy element, wystarczy go kliknąć.
Pozycje widoczne w polu kombi można wstawiać na dwa sposoby: określając zakres
zawierający pozycje lub posługując się instrukcjami języka VBA.
Przykład 146.
Napisz program, którego zastosowanie doprowadzi do wyświetlenia w polu kombi dwóch
pozycji: Sekretariat i Sklep. Pozycje powinny być wpisane w arkuszu kalkulacyjnym.
2. W komórkach od A1 do A2 wpisz Sekretariat, Sklep (rysunek 8.22).
Rysunek 8.22.
Dane do utworzenia
pola kombi
3. Załaduj edytor VBA.

4. Wybierz polecenie Insert/UserForm.
5. W pasku Toolbox odszukaj ikonę pola kombi.
6. Przeciągnij ikonę pola kombi na formatkę (rysunek 8.23).
Rysunek 8.23.
Pole kombi
umieszczone
na formatce
7. W ikonie Properties wybierz pozycję ComboBox (rysunek 8.24).
Rysunek 8.24.
W dolnej części okna będą
wyświetlane właściwości
pola kombi
8. Kliknij kartę Alphabetic. Właściwości zostały uporządkowane w kolejności

alfabetycznej.
9. W komórce znajdującej się na prawo od komórki oznaczonej jako RowSource
wpisz zakres komórek arkusza, w których znajdują się dane do umieszczenia
w polu kombi (rysunek 8.25).
Rysunek 8.25.
Parametr RowSource
określa zakres
komórek arkusza
wyświetlanych
w polu kombi
10. W formularzu zostały wyświetlone pozycje pola kombi (rysunek 8.26).
Rysunek 8.26.
Pole kombi
z pozycjami
wczytanymi
ze wskazanego
zakresu arkusza
11. Naciśnij klawisz F7. Zostało wyświetlone okno kodu.

12. Wpisz z klawiatury kod procedury przykład130() (rysunek 8.27).
13. Uruchom program, naciskając klawisz F5.
14. Zostało wyświetlone okno formularza z polem kombi (rysunek 8.28).
Rysunek 8.27.
Nad kreską pierwszą
od góry jest widoczny
kod procedury, której
zastosowanie
prowadzi
do wyświetlenia
formularza
Rysunek 8.28.
Formularz
z polem kombi
Pasek Toolbox
i elementy sterujące arkusza
Z przykładów opisanych w tym rozdziale wynika, że sposób postępowania w celu
umieszczenia elementu na formatce jest podobny w wielu przypadkach. Nie zależy on
w znacznym stopniu od typu elementu. Największą trudność może sprawić początkują-
cemu programiście odszukanie odpowiedniej ikony na pasku Toolbox. W pokonaniu
tej trudności może okazać się pomocna tabela 8.1. Pokazano w niej, jaki element
pojawi się na formatce po przeciągnięciu na nią ikony z paska Toolbox.
Tabela 8.1. Ikony paska Toolbox i odpowiadające im elementy

Ikona Element Uwagi
Ikona Label — wstawianie etykiet
Ikona TextBox — wstawianie pól tekstowych
Ikona ComboBox — wstawianie pól kombi

Tabela 8.1. Ikony paska Toolbox i odpowiadające im elementy (ciąg dalszy)

Ikona Element Uwagi
Ikona ListBox — wstawianie pól listy
Ikona CheckBox — wstawianie pola wyboru
Ikona OptionButton — wstawianie przycisku opcji
Ikona Toggle Button — wstawianie przycisku

przełącznika
Ikona Frame — wstawianie pola grupy
Ikona CommandButton — wstawianie przycisku

polecenia
Ikona TabStrip — wstawianie elementu okna

z kartami
Ikona MultiPage — wstawianie zakładkowego

elementu okna dialogowego
Ikona ScrollBar — wstawianie paska przewijania
Ikona SpinButton — wstawianie przycisków

umożliwiających wybieranie wartości poprzez
klikanie strzałek
Ikona Image — wstawianie obrazu
Ikona RefEdit — wybieranie zakresu arkusza

Właściwości
Umieszczenie na formatce elementu sterującego to dopiero początek pracy związanej
z umożliwieniem komunikowania się z programem. Elementowi sterującemu należy
przypisać wartości, które będzie można wybierać za jego pośrednictwem, określić
czcionkę używaną do opisów, kolory tła i obramowania, domyślną wartość itd. Wła-
ściwości elementu można zdefiniować za pośrednictwem okna Properties. Okno jest
wyświetlane po lewej stronie okna edytora VBA. Pola widoczne w oknie Properties
są zależne od elementu (rysunek 8.29 i 8.30).
Rysunek 8.29. Rysunek 8.30.

Niektóre właściwości przycisku opcji Niektóre właściwości przycisku polecenia
Aby zmienić właściwość, wystarczy kliknąć pozycję w oknie Properties i wpisać lub
wybrać nową. Niektóre właściwości mogą przyjmować tylko skończoną liczbę wartości.
Po kliknięciu takiej właściwości jest wyświetlana lista, z której można wybierać wła-
ściwości (rysunek 8.31).
Rysunek 8.31.
Lista dostępnych
właściwości
Inne właściwości pozwalają np. na wybranie elementu graficznego (rysunek 8.32) lub
wpisywanie dowolnych wartości (rysunek 8.33).
Rysunek 8.32. Kliknięcie pola z trzema kropkami spowodowało wyświetlenie okna umożliwiającego
załadowanie obrazka
Rysunek 8.33.
Właściwość Height
może mieć dowolną
wartość
Z paska Toolbox można wybrać piętnaście kontrolek. Każda z nich ma ponad trzy-
dzieści właściwości. Aby dowiedzieć się, jakie znaczenie ma właściwość, należy sko-
rzystać z okna pomocy.
Przykład 147.
Wyświetl informację o właściwości AutoSize kontrolki CommandButton.
3. Wstaw do projektu formularz.

4. Umieść na formularzu kontrolkę CommandButton (rysunek 8.34).
Rysunek 8.34.
Formularz z kontrolką
CommandButton
5. Rozwiń listę obiektów znajdującą się w górnej części okna Properties.

Wybierz z niej obiekt CommandButton1 (rysunek 8.35).
Rysunek 8.35.
W oknie Properties są
wyświetlane właściwości
kontrolki CommandButton
6. Zaznacz właściwość AutoSize (rysunek 8.36).
Rysunek 8.36.
Fragment
okna Properties
z zaznaczoną
właściwością AutoSize

8. Zostało wyświetlone okno z informacją o właściwości AutoSize (rysunek 8.37).
W tabeli 8.2 zebrano podstawowe właściwości kontrolek umieszczanych w formularzach.

Rysunek 8.37. Okno z informacją o właściwości AutoSize
Tabela 8.2. Podstawowe właściwości kontrolek

Kontrolka Znaczenie
(Name) Nazwa kontrolki
BackColor Kolor tła
Caption Opis widoczny na kontrolce
ColumnCount Liczba kolumn
Default Wartość domyślna
Height Wysokość kontrolki
Left Odległość lewej krawędzi kontrolki od lewego marginesu formatki
MaxLenght Maksymalna długość wpisywanego ciągu znaków
MousePointer Wygląd kursora po naprowadzeniu na kontrolkę
Picture Obrazek wyświetlany jako tło kontrolki
RowSource Zakres komórek arkusza, z których mają być skopiowane dane do kontrolki
ScrollBars Paski przewijania
TextAlign Wyrównanie tekstu
Top Odległość górnej krawędzi kontrolki od górnego marginesu formatki
Width Szerokość kontrolki
WordWrap Zawijanie opisów umieszczonych na kontrolce
Podsumowanie
 Aby na arkuszu utworzyć formularz, należy w oknie edytora VBA wybrać
polecenie Insert/UserForm.
 Aby na formatce pojawił się obiekt, należy przeciągnąć go z okna Toolbox.
 Aby przypisać obiektowi właściwości, trzeba kliknąć go prawym przyciskiem
myszy i z menu podręcznego wybrać polecenie Properties, a następnie
zastąpić ustawienia domyślne własnymi.
Rozdział 9.
Zdarzenia
 Jak nazywa się zdarzenie, które zachodzi po raz pierwszy
 Jak nazywa się zdarzenie polegające na wprowadzeniu w arkuszu zmiany
przez użytkownika
 Jak nazywa się właściwość określająca treść opisu widocznego na przycisku
Użytkownik może sterować programem za pomocą wywoływania zdarzeń. Nie denerwuj

się, nie musisz mieć zdolności nadprzyrodzonych! Nie będziesz musiał wywoływać
gradobicia.
Wybranie pozycji z listy czy kliknięcie przycisku są zdarzeniami inicjowanymi przez

użytkownika. Aby program zareagował na zdarzenia, konieczne jest opracowanie pro-
cedur obsługi zdarzeń. Innymi słowy — trzeba określić, jak program ma zareagować
na Twoje zaczepki.
Bez procedury obsługi zdarzenia informacje sterujące nie są przekazywane do programu.

Z taką sytuacją zetknęliśmy się w rozdziale poprzednim. Informacja o tym, która wartość
została wybrana, nie była przekazywana do programu. Zabrakło ogniwa łączącego ele-
menty sterujące arkusza i resztę programu.
Przykład 148.
W edytorze VBA wprowadź kod procedury obsługi zdarzenia polegającego na otwieraniu
skoroszytu.
2. Wyświetl okno edytora Visual Basic.
3. W polu eksploratora projektu widocznego w oknie Microsoft Visual Basic
for Applications kliknij pozycję Ten_skoroszyt (rysunek 9.1).
Rysunek 9.1.
Okno VBA
z zaznaczoną pozycją
Ten_skoroszyt
4. W oknie Ten_skoroszyt (Code) rozwiń znajdującą się po lewej stronie listę

obiektów.
5. Zaznacz na niej Workbook (rysunek 9.2).
Rysunek 9.2.
Workbook znajduje się
na liście obiektów
6. W oknie Ten skoroszyt (Code) rozwiń znajdującą się po prawej stronie listę procedur.
7. Zaznacz na niej Open (rysunek 9.3).
Rysunek 9.3.
Lista procedur
z zaznaczoną
pozycją Open
8. W oknie Ten skoroszyt (Code) pojawił się szkielet kodu obsługi procedury
(rysunek 9.4). Pierwsza linia stanowi początek procedury, która jest uruchamiana
podczas otwierania skoroszytu. Ostatnia linia informuje program, że za nią nie
ma już instrukcji do wykonywania. Instrukcje wskazujące, co komputer ma
zrobić podczas otwierania skoroszytu, należy wpisać pomiędzy liniami:
rozpoczynającą i kończącą procedurę.
Rysunek 9.4. Linie kodu procedury powinny znajdować się pomiędzy linią z nazwą procedury a linią
kończącą procedurę End Sub
Rozdział 9.  Zdarzenia 263
Lista zdarzeń dla skoroszytu

W przykładzie 148. pokazano procedurę, która zostanie uruchomiona podczas otwierania
skoroszytu. Lista zdarzeń, które mogą spowodować uaktywnienie procedury, jest o wiele
bogatsza. Po kliknięciu czarnej strzałki znajdującej się w prawym rogu pola Procedure
jest ona wyświetlana w całości (rysunek 9.5).
Rysunek 9.5.
Okno z rozwiniętą
listą procedur
obsługi zdarzeń
W tabeli 9.1 zestawiono znaczenie zdarzeń.
Tabela 9.1. Wybrane zdarzenia związane z skoroszytem

Zdarzenie Opis
Activate Uaktywnienie skoroszytu
AddinInstall Zainstalowanie skoroszytu jako dodatku
AddinUninstall Odinstalowanie skoroszytu jako dodatku
AfterSave Zapisanie skoroszytu
AfterXmlExport Wyeksportowanie pliku XML
AfterXmlImport Zaimportowanie pliku XML
BeforeClose Próba zamknięcia skoroszytu
BeforePrint Próba wydrukowania skoroszytu lub jego fragmentu,
lub wyświetlenia w oknie podglądu wydruku
BeforeSave Próba zapisania skoroszytu
BeforeXmlExport Próba wyeksportowania pliku XML lub aktualizacji połączenia
z danymi XML
Tabela 9.1. Wybrane zdarzenia związane z skoroszytem — ciąg dalszy

Zdarzenie Opis
BeforeXmlImport Próba zaimportowania pliku XML
Deactivate Dezaktywacja skoroszytu
NewChart Utworzenie nowego wykresu
NewSheet Utworzenie nowego arkusza w skoroszycie
Open Otworzenie skoroszytu
PivotTableCloseConnection Zamknięcie połączenia z zewnętrznym źródłem danych dla tabeli
przestawnej
PivotTableOpenConnection Otwarcie połączenia z zewnętrznym źródłem danych dla tabeli
przestawnej
SheetActivate Uaktywnienie dowolnego arkusza
SheetBeforeDoubleClick Próba dwukrotnego kliknięcia dowolnego arkusza
SheetBeforeRightClick Próba kliknięcia prawym przyciskiem myszy dowolnego arkusza
SheetCalculate Wykonanie obliczeń zapisanych w dowolnym arkuszu
SheetChange Modyfikacja dowolnego arkusza przez użytkownika lub łącze
zewnętrzne
SheetDeactivate Dezaktywacja arkusza
SheetFollowHyperlink Kliknięcie hiperłącza znajdującego się w arkuszu
SheetPivotTableUpdate Wprowadzenie nowych danych do tabeli przestawnej
SheetSelectionChange Zmiana zaznaczenia w arkuszu
Sync Synchronizacja skoroszytu, który należy do przestrzeni roboczej
dokumentów, z kopią z serwera
WindowActivate Uaktywnienie okna skoroszytu
WindowResize Zmiana rozmiaru okna skoroszytu
Pięć zdarzeń wymienionych w tabeli 9.1 nosi nazwy rozpoczynające się od słowa
Before. Są to zdarzenia, do których jeszcze nie doszło. Do tej grupy należy np.
BeforeClose. Dotyczy ono sytuacji, gdy arkusz nie był jeszcze zapisywany. Po klik-
nięciu ikony oznaczonej dyskietką zostanie wyświetlone okno, w którym można po-
dać zarówno lokalizację, jak i nazwę pliku.
Przykład 149.
Napisz program, którego zastosowanie pozwoli przed zakończeniem pracy ze skoro-
szytem wyświetlać komunikat Dziękuję za skorzystanie z programu XXX.
3. W oknie Project - VBA Project dwukrotnie kliknij pozycję Ten_skoroszyt
(rysunek 9.6).
Rysunek 9.6.
Procedura
będzie związana
ze skoroszytem
(obiekt Ten_skoroszyt)
4. Zostało wyświetlone okno Ten_skoroszyt (Code). Rozwiń w nim znajdującą

się po lewej stronie listę Object i wybierz pozycję Workbook (rysunek 9.7).
Rysunek 9.7.
Należy wybrać z listy
obiekt Workbook
5. W oknie Ten_skoroszyt (Code) został automatycznie wstawiony kod

wykonywany podczas otwierania skoroszytu. Rozwiń listę procedur.
Wybierz z niej procedurę Deactivate (rysunek 9.8).
Rysunek 9.8.
Procedurę Deactivate
należy wybrać z listy
znajdującej się po
prawej stronie okna
6. W oknie pojawiły się kody dwóch procedur: Deactivate i Open.

Zaznacz procedurę Open (rysunek 9.9).
Rysunek 9.9.
Procedura
przeznaczona
do usunięcia
7. Usuń zaznaczoną procedurę.

8. Umieść znak wstawiania nad linią End Sub.
9. Wpisz kod, którego zastosowanie doprowadzi do wyświetlenia komunikatu
(rysunek 9.10).
Rysunek 9.10.
W cudzysłowie
wpisano tekst
wyświetlany
w oknie komunikatu
10. Wyświetl okno arkusza Excela.

11. Zamknij skoroszyt kliknięciem przycisku oznaczonego krzyżykiem.
12. Zostało wyświetlone okno komunikatu (rysunek 9.11).
Rysunek 9.11.
Okno komunikatu

14. Okno komunikatu i okno skoroszytu zostało zamknięte.

Napisz program, którego zastosowanie pozwoli ― po uruchomieniu arkusza ― wy-
świetlać komunikat Życzę miłej pracy z programem XXX.
Przykład 151.
Napisz program, którego zastosowanie doprowadzi do wyświetlenia adresu zmodyfi-
kowanego zakresu komórek skoroszytu.
3. W oknie Project - VBA Project dwukrotnie kliknij pozycję Ten_skoroszyt
(rysunek 9.12).
Rysunek 9.12.
Jak w poprzednich
przykładach
— rozpocznij
od wskazania
skoroszytu, którego
będzie dotyczył
program
4. Zostało wyświetlone okno Ten_skoroszyt (Code). Rozwiń w nim widoczną

po lewej stronie listę Object i wybierz pozycję Workbook (rysunek 9.13).
Rysunek 9.13.
Lista Object
5. W oknie Ten_skoroszyt (Code) został automatycznie wstawiony kod

wykonywany podczas otwierania skoroszytu. Rozwiń listę procedur.
Wybierz z niej procedurę SheetChange (rysunek 9.14).
Rysunek 9.14.
Z listy procedur
należy wybrać tę,
która uaktywni
się po zmianie
zawartości arkusza
— SheetChange
6. W oknie pojawiły się kody dwóch procedur: Open i SheetChange.

Zaznacz procedurę Open (rysunek 9.15).
Rysunek 9.15. Procedura przeznaczona do usunięcia została zaznaczona
7. Usuń zaznaczoną procedurę.

8. Umieść znak wstawiania nad linią End Sub (rysunek 9.16).
Rysunek 9.16. W kodzie programu pozostała jedna procedura
9. Procedura Workbook_SheetChange pobiera obiekt typu Range, traktując go jako

argument Target. Reprezentuje on zmodyfikowany obszar, który odpowiada
za wystąpienie zdarzenia. Procedura zostanie wykonana, jeżeli zmieni się
zawartość arkusza. Wpisz kod obsługi procedury (rysunek 9.17).
Rysunek 9.17. Wykonanie procedury doprowadzi do wyświetlenia okna z informacją o modyfikacji zakresu

11. Wpisz do komórki A1 słowo Miś.
13. Został wyświetlony adres zmodyfikowanej komórki (rysunek 9.18).
Rysunek 9.18.
W oknie komunikatu
adres zmodyfikowanej
komórki

15. Skopiuj zawartość komórki A1 do schowka.
16. Zaznacz obszar od A1 do B3.
17. Wklej do niego zawartość schowka.
18. Zostało wyświetlone okno komunikatu z informacją o zakresie zmodyfikowanych
komórek (rysunek 9.19).
Rysunek 9.19.
Okno komunikatu
z informacją
o zakresie
zmodyfikowanych
komórek

Napisz program, którego zastosowanie pozwoli zapisywać adresy zmodyfikowanych
komórek Arkusza 1 w Arkuszu 2.
Lista zdarzeń dla arkusza

Lista zdarzeń mających zastosowanie do arkusza liczy czternaście pozycji (rysunek 9.20).
Rysunek 9.20.
Fragment listy
procedur obsługi
zdarzeń mających
zastosowanie
do arkusza
Działanie zdarzeń mających zastosowanie do arkusza opisano w tabeli 9.2.
Tabela 9.2. Zdarzenia związane z arkuszem

Zdarzenie Opis
Activate Uaktywnienie skoroszytu
BeforeDoubleClick Dwukrotne kliknięcie arkusza
BeforeRightClick Kliknięcie arkusza prawym przyciskiem myszy
Calculate Zaktualizowanie obliczeń dla arkusza
Change Zmiana zawartości komórki wykonana przez użytkownika lub łącze
zewnętrzne. Zdarzenie nie wystąpi, jeśli w wyniku obliczeń zmieni
się zawartość formuły lub do arkusza zostanie dodany obiekt
Deactivate Dezaktywacja arkusza
FollowHyperlink Kliknięcie hiperłącza na arkuszu
PivotTableAfterValueChange Zmiana wartości w tabeli przestawnej
PivotTableBeforeAllocateChanges Próba zmiany alokacji tabeli przestawnej
PivotTableBeforeCommitChanges Próba zatwierdzenia zmian w tabeli przestawnej
PivotTableBeforeDiscardChanges Próba odrzucenia zmian w tabeli przestawnej
PivotTableChangeSync Synchronizacja tabeli przestawnej
PivotTableUpdate Aktualizacja tabeli przestawnej
SelectionChange Modyfikacja zaznaczenia w arkuszu
Działanie zdarzeń mających zastosowanie do arkusza jest analogiczne do zdarzeń ma-

jących odniesienie do skoroszytu (tabela 9.1). W opisie słowo „skoroszyt” należy za-
stąpić słowem „arkusz”.
Przykład 153.
Napisz program, którego zastosowanie pozwoli wyświetlić adres zmodyfikowanego
zakresu komórek arkusza.
2. Pracę rozpocznij od przygotowania danych, które będą monitorowane przez
procedurę. W komórce A1 wpisz 1.
3. W komórce A2 wpisz 2.
4. W komórce A3 wpisz =suma(A1;A2) (rysunek 9.21).
Rysunek 9.21.
Arkusz
z przygotowanym
zestawem danych

6. W oknie Project - VBAProject dwukrotnie kliknij pozycję Arkusz1 (Arkusz1)
(rysunek 9.22).
Rysunek 9.22.
Obiekt Arkusz1
7. Zostało wyświetlone okno Arkusz1 (Code). Rozwiń w nim listę procedur

obsługi zdarzeń Object i wybierz pozycję Worksheet (rysunek 9.23).
Rysunek 9.23. Okno Arkusz1 (Code) z rozwiniętą listą Object
8. Wpisz w oknie edytora kod. Procedura WorkSheet_Change pobiera obiekt typu

Range, traktując go jako argument Target. Reprezentuje on zmodyfikowany
obszar, który odpowiada za wystąpienie zdarzenia. Procedura zostanie
wykonana, jeżeli zmieni się zawartość arkusza. Wpisz kod obsługi procedury
(rysunek 9.24).
Rysunek 9.24. Zastosowanie procedury doprowadzi do wyświetlenia okna z adresem zakresu Target

10. Wpisz do komórki A1 liczbę 2.
12. Został wyświetlony adres zmodyfikowanej komórki (rysunek 9.25).
Rysunek 9.25.
Choć zostały
zmienione komórki
A1 i A3, jest
wyświetlana
tylko informacja
o komórce A1

Sprawdź, czy zastosowanie programu pozwala wykrywać zmiany wprowadzone w arku-
szach 2. i 3.
Lista zdarzeń dla aplikacji

Zdarzenia związane z arkuszem lub skoroszytem są przypisane dokumentowi. Istnieją
również zdarzenia niezależne od dokumentów. Są one przypisane aplikacjom. W ta-
beli 9.3 podano ich działanie.
Na szczęście, aby sprawnie napisać program w Visual Basicu, nie trzeba się uczyć na
pamięć nazw obiektów oraz ich właściwości i metod.
Tabela 9.3. Zdarzenia związane z aplikacją

Zdarzenie Opis
NewWorkbook Utworzenie nowego skoroszytu
SheetActivate Uaktywnienie dowolnego arkusza
SheetBeforeDoubleClick Próba dwukrotnego kliknięcia dowolnego arkusza
SheetBeforeRightClick Próba kliknięcia prawym przyciskiem myszy dowolnego arkusza
SheetCalculate Wykonanie obliczeń zapisanych w dowolnym arkuszu
SheetChange Modyfikacja dowolnego arkusza przez użytkownika lub łącze
zewnętrzne
SheetDeactivate Dezaktywacja arkusza
SheetFollowHyperlink Kliknięcie hiperłącza znajdującego się w arkuszu
SheetPivotTableUpdate Wprowadzenie nowych danych do tabeli przestawnej
SheetSelectionChange Zmiana zaznaczenia w arkuszu z wyjątkiem arkusza,
który jest wykresem
WindowActivate Uaktywnienie okna skoroszytu
WindowResize Zmiana rozmiaru okna skoroszytu
WorkbookActivate Uaktywnienie skoroszytu
WorkbookAddinInstall Zainstalowanie skoroszytu jako dodatku
WorkbookAddinUninstall Odinstalowanie skoroszytu będącego dodatkiem
WorkbookAfterXMLExport Wyeksportowanie pliku XML
WorkbookAfterXMLImport Zaimportowanie pliku XML lub aktualizacja połączenia z danymi XML
WorkbookBeforeClose Próba zamknięcia skoroszytu
WorkbookBeforePrint Próba wydrukowania otwartego skoroszytu
WorkbookBeforeSave Próba zapisania otwartego skoroszytu
WorkbookBeforeXMLExport Próba wyeksportowania pliku XML lub aktualizacja połączenia
z danymi XML
WorkbookBeforeXMLImport Próba zaimportowania pliku XML
WorkbookDeactivate Dezaktywacja otwartego skoroszytu
WorkbookNewSheet Utworzenie nowego arkusza w otwartym skoroszycie
WorkbookOpen Otwarcie skoroszytu
Przykład 155.
Znajdź obiekty obsługujące w arkuszu Excel zdarzenie DoubleClick.
3. Naciśnij klawisz F2. Została wyświetlona przeglądarka obiektów.
4. Z listy aplikacji (w lewym górnym rogu okna) wybierz Excel.
5. W polu Search Text (pod listą aplikacji) wpisz doubleclick (rysunek 9.26).
Rysunek 9.26.
Kryteria wyszukiwania
6. Kliknij przycisk wyszukiwania oznaczony lornetką.

7. Została wyświetlona lista obiektów (rysunek 9.27). W oknie Search Results
(wyniki wyszukiwania) są widoczne trzy kolumny: Library (biblioteka),
Classes (klasy) oraz Members (składniki).
Rysunek 9.27.
Lista obiektów Excela
reagujących na
podwójne kliknięcie
Nazwy zdarzenia, obiektu lub składnika należące do różnych bibliotek mogą być
identyczne. Różnią się one spełnianą funkcją.

Znajdź obiekty obsługujące w arkuszu programu Excel zdarzenia:
 OnKey — skojarzenie procedury z określonym klawiszem,
 OnTime — wykonanie procedury w określonym momencie lub po określonym
czasie,
 GoTo — zaznaczenie wskazanego zakresu w dowolnym skoroszycie,
 Quit — zakończenie pracy aplikacji.
Komunikacja z programem
Pisząc program, musisz z jednej strony wyobrażać sobie, co ma lub może pojawić się na
ekranie. Z drugiej strony musisz się zastanowić, jakie informacje zdarzenia przekazują
do programu.
Przykład 157.
Napisz program, którego zastosowanie pozwoli wyświetlić formularz z dwoma przyci-
skami: Ziemniaki i Kasza. Po kliknięciu przycisku zostanie wyświetlona nazwa wy-
branej potrawy, a formularz zostanie zamknięty.
3. Wstaw do projektu formularz użytkownika. Wybierz polecenie Insert/UserForm.
4. Przeciągnij z paska Toolbox na formularz (formatkę) dwa przyciski
CommandButton (rysunek 9.28).
Rysunek 9.28.
Formularz z dwoma
przyciskami
5. Kliknij CommandButton1 lewym przyciskiem myszy. Z menu podręcznego

wybierz Properties (rysunek 9.29).
Rysunek 9.29.
Na liście będą
wyświetlane
właściwości
klawisza
CommandButton1
6. Właściwość Caption odpowiada za opis widoczny na przycisku. Zaznacz

tekst CommandButton1. Wpisz tekst Ziemniaki (rysunek 9.30).
Rysunek 9.30.
Na przycisku będzie
widoczny napis
Ziemniaki
7. Kliknij CommandButton2 lewym przyciskiem myszy. Z menu podręcznego

wybierz Properties.
8. W linii Caption zaznacz tekst CommandButton2. Wpisz tekst Kasza (rysunek 9.31).
Rysunek 9.31.
Na przycisku
będzie widoczny
napis Kasza
9. Kliknij puste miejsce na formularzu prawym przyciskiem myszy.

Rysunek 9.32.
Z menu podręcznego
można wybrać
polecenie,
pozwalające
wyświetlić
kod programu
11. Został wyświetlony szkielet procedur odpowiedzialnych za obsługę zdarzenia

kliknięcia (rysunek 9.33).
Rysunek 9.33.
Procedury
odpowiedzialne
za obsługę
zdarzenia kliknięcia
12. Uzupełnij szkielet kodu procedury dwiema liniami kodu (rysunek 9.34).
Pierwsza linia odpowiada za wyświetlenie komunikatu znajdującego się
w cudzysłowie. Druga linia odpowiada za usunięcie programu z pamięci.
Rysunek 9.34.
Do każdej procedury
zostały dopisane
dwie linie kodu
13. Naciśnij klawisz F5. Program został uruchomiony. Formularz został

wyświetlony (rysunek 9.35).
Rysunek 9.35.
Okno formularza
14. Kliknij przycisk Ziemniaki.

15. Został wyświetlony komunikat. Jest on reakcją programu na dokonany
wybór (rysunek 9.36).
Rysunek 9.36.
Efekt naciśnięcia
górnego przycisku
w formularzu

17. Zostało wyświetlone okno edytora VBA.
18. Naciśnij klawisz F5. Program został uruchomiony. Formularz został
wyświetlony.
19. Kliknij przycisk Kasza.
20. Został wyświetlony komunikat. Jest on reakcją programu na dokonany
wybór (rysunek 9.37).
Rysunek 9.37.
Efekt naciśnięcia
dolnego przycisku
w formularzu

Zmodyfikuj program z przykładu 157. tak, aby odpowiedzi nie wyświetlały się w oknie,
ale były wpisywane do komórki A1 arkusza.
Lista zdarzeń dla formularzy

Formularze różnią się na tyle od innych obiektów, że są z nimi związane oddzielne
zdarzenia (tabela 9.4).
Tabela 9.4. Zdarzenia związane z formularzami

Zdarzenie Opis
Activate Uaktywnienie formularza
AddControl Dodanie kontrolki w fazie wykonywania programu
BeforeDragOver Próba operacji przeciągania i upuszczania w czasie, kiedy wskaźnik myszy
znajdował się nad formularzem
BeforeDropOrPaste Próba upuszczenia lub wklejenia danych (użytkownik zwolnił przycisk myszy)
Click Kliknięcie przycisku myszy, gdy jej wskaźnik znajdował się nad formularzem
DblClick Dwukrotne kliknięcie przycisku myszy, gdy jej wskaźnik znajdował się nad
formularzem
Deactivate Dezaktywacja formularza UserForm
Error Błąd spowodowany przez kontrolkę. Brak możliwości zwrócenia informacji
o błędzie do programu wywołującego
Initialize Próba wyświetlenia formularza UserForm
KeyDown Wciśnięcie klawisza
KeyPress Wciśnięcie klawisza (kod ANSI wciśniętego klawisza)
KeyUp Zwolnienie klawisza
Layout Zmiana rozmiarów formularza UserForm
MouseDown Wciśnięcie przycisku myszy
MouseMove Przemieszczenie wskaźnika myszy
MouseUp Zwolnienie przycisku myszy
QueryClose Próba zamknięcia formularza UserForm
RemoveControl Usunięcie kontrolki z formularza UserForm w fazie wykonywania programu
Resize Zmiana rozmiaru formularza UserForm
Scroll Przewijanie formularza UserForm
Terminate Usunięcie formularza UserForm
Zoom Zmiana wielkości formularza UserForm
Przykład 159.
Napisz program, którego zastosowanie pozwoli wyświetlić formularz z prośbą o kliknię-
cie myszą. Po kliknięciu zostanie wyświetlone okno z podziękowaniem.
3. Wstaw do projektu formularz użytkownika. Wybierz polecenie

Insert/UserForm.
4. Przeciągnij z paska Toolbox na formatkę obiekt Label (rysunek 9.38).
Rysunek 9.38.
Z paska Toolbox
można przeciągnąć
obiekt umożliwiający
wstawienie etykiety
5. W oknie Properties rozwiń listę Label. Zostały wyświetlone właściwości

etykiety.
6. W polu oznaczonym Caption znajduje się napis wyświetlany na etykiecie.
Usuń domyślnie wprowadzony napis i wpisz Kliknij mnie myszą!
(rysunek 9.39).
Rysunek 9.39. W polu Caption jest widoczny tekst wyświetlany na etykiecie
7. Dwukrotnie kliknij myszą puste pole na formularzu.

8. Został wyświetlony kod programu.
9. Uzupełnij go o procedurę wyświetlania okna z podziękowaniem za kliknięcie:
Option Explicit
Private Sub UserForm_MouseDown(ByVal Button As Integer, ByVal Shift As

Integer, ByVal X As Single, ByVal Y As Single)
MsgBox ("Dziękuję za współpracę!")
End Sub
10. Uruchom program. Został wyświetlony formularz z etykietą (rysunek 9.40).

Rysunek 9.40.
Wynik uruchomienia
programu z punktu 10.
11. Kliknij formularz myszą.

12. Zostało wyświetlone okno z komunikatem (rysunek 9.41).
Rysunek 9.41.
Rezultat wykonania
procedury obsługi
zdarzenia
polegającego
na kliknięciu myszą
formularza

Zmodyfikuj program z przykładu 159. tak, aby po kliknięciu przycisku OK okno formula-
rza UseForm2 było zamykane.
Podsumowanie
 Zdarzenia, których nazwy rozpoczynają się od słowa Before, to zdarzenia,
do których jeszcze nie doszło. Do tej grupy należy np. zdarzenie BeforeClose.
Dotyczy ono sytuacji, gdy arkusz nie był jeszcze zapisywany. Po kliknięciu
ikony oznaczonej dyskietką zostanie wyświetlone okno, w którym można
podać zarówno lokalizację, jak i nazwę pliku.
 Zdarzenie polegające na wprowadzeniu przez użytkownika zmiany
w wybranym zakresie komórek nosi nazwę SheetChange.
 Właściwość określająca nazwę widoczną na przycisku nosi nazwę Caption.
Rozdział 10.
Metody i właściwości
dla zakresu
 Jaka metoda służy do kopiowania zakresu komórek
 Jakiej metody trzeba użyć do sortowania komórek należących do zakresu
 Czy istnieje metoda pozwalająca na filtrowanie komórek znajdujących się
w określonym zakresie
 Dzięki jakiej metodzie można przeszukiwać komórki należące do zakresu
Podczas pracy z arkuszem kalkulacyjnym Excel rzadko posługujemy się pojedynczymi

komórkami. Częściej są to wypełnione danymi zakresy komórek.
Kopiowanie zakresu komórek

Do kopiowania zakresu komórek służy metoda Range.Copy. Ma ona następującą składnię:
Zakres_źródłowy.Copy Zakres_przeznaczenia
gdzie:
Zakres_źródłowy — lokalizacja komórek, które zostaną skopiowane.
Jest to zmienna typu Range.
Copy — metoda.
Zakres_przeznaczenia — lokalizacja komórek, do których dane zostaną
skopiowane.
Zakres_przeznaczenia jest parametrem opcjonalnym. Jeżeli nie zostanie podany,

polecenie zostanie wykonane, a dane zostaną skopiowane do schowka.
Przykład 161.
Napisz program, którego zastosowanie doprowadzi do skopiowania zawartości bieżą-
cego zakresu ciągłego komórek od A1 do A3 do schowka.
2. Pracę rozpoczniemy od przygotowania danych. W komórkach od A1 do A3
wpisz kolejno 1, 2, 3 (rysunek 10.1).
Rysunek 10.1.
Zakres źródłowy został
wypełniony danymi

4. Dwukrotnie kliknij obiekt Ten_skoroszyt (rysunek 10.2).
Rysunek 10.2.
Obiekt Ten_skoroszyt
w oknie
Project - VBAProject
5. Zostało wyświetlone okno umożliwiające edytowanie kodu. Wpisz w nim kod

pokazany na rysunku 10.3. Zmienna Kom jest typu Range. Kopiowanie zostaje
wykonane z zakresu źródłowego. Zakres docelowy nie został wskazany.
Rysunek 10.3.
Kod programu
6. Uruchom program.
7. Wyświetl okno arkusza Excela. Jest na nim widoczne zaznaczenie informujące,
że zawartość komórek zakresu od A1 do A3 została skopiowana do schowka
(rysunek 10.4).
Rysunek 10.4.
Zawartość komórek
od A1 do A3 została
skopiowana
do schowka
Rozdział 10.  Metody i właściwości dla zakresu 283
8. Sprawdzimy, co znajduje się w schowku.

9. Kliknij komórkę B1.
10. Kliknij ikonę Wklej (rysunek 10.5).
Rysunek 10.5.
Zawartość schowka
zostanie wklejona
do zakresu
rozpoczynającego
się od komórki B1
11. Zawartość schowka została skopiowana do komórek od B1 do B3 (rysunek 10.6).
Rysunek 10.6.
Dane z komórek od A1 do
A3 zostały za pośrednictwem
schowka skopiowane do
komórek od B1 do B3
Przykład 162.
Napisz program, którego zastosowanie spowoduje skopiowanie bieżącego zakresu
ciągłego komórek od A1 do A3 do zakresu komórek od B1 do B3.
wpisz kolejno 1, 2, 3 (rysunek 10.1).
4. Dwukrotnie kliknij obiekt Ten_skoroszyt.
5. Zostało wyświetlone okno umożliwiające edytowanie kodu. Wpisz w nim
kod pokazany na rysunku 10.7. Zmienna Kom jest typu Range. Kopiowanie
zostaje wykonane z obszaru źródłowego. Obszar docelowy rozpoczyna się
od komórki B1.
Rysunek 10.7.
Kod programu
6. Uruchom program.
7. Wyświetl okno arkusza Excela. Dane zostały skopiowane z komórek obszaru
od A1 do A3 do komórek obszaru od B1 do B3 (rysunek 10.8).
Rysunek 10.8.
Zawartość komórek
od A1 do A3 została
skopiowana do
komórek od B1 do B3
Przykład 163.
Napisz program, który „zada pytanie” o początek zakresu komórek do skopiowania
i początek zakresu docelowego. Następnie skopiuje zakresy.
wpisz kolejno 1, 2, 3. W komórkach od A5 do A7 wpisz kolejno 5, 6, 7
(rysunek 10.9).
Rysunek 10.9.
Dane testowe

4. Dwukrotnie kliknij obiekt Ten_skoroszyt.
5. Zostało wyświetlone okno umożliwiające edytowanie kodu. Wpisz w nim kod

pokazany na rysunku 10.10. Zmienna Kom jest typu Range. Zmienne źródło
oraz przeznaczenie będą przechowywały adres pierwszej komórki zakresu.
Są one typu String. Kopiowanie zostaje wykonane z obszaru źródłowego
do obszaru docelowego.
Rysunek 10.10.
Kod programu
6. Uruchom program.
7. Wyświetl okno arkusza Excela. Jako adres należący do obszaru źródłowego
wpisz a1 (rysunek 10.11).
Rysunek 10.11.
Komórka A1 należy
do obszaru
zawierającego dane

9. Zostało wyświetlone okno z prośbą o wpisanie adresu docelowego
(rysunek 10.12). Wpisz c3.
Rysunek 10.12.
Jako adres obszaru
docelowego została
podana komórka C3

11. Dane zostały skopiowane (rysunek 10.13). Pusta komórka jest granicą obszaru.
Dlatego zawartość komórek A5, A6 i A7 nie została skopiowana. Adres
wprowadzony na rysunku 10.12 jest adresem lewego górnego rogu obszaru
docelowego.
Rysunek 10.13.
Obszar danych został
skopiowany
Przykład 164.
Wykorzystując program z przykładu 163., sprawdź, jak można opisać obszar.
1. Do arkusza wpisz dane zgodnie z rysunkiem 10.14.
Rysunek 10.14.
Obszar źródłowy
został wskazany
przez podanie
adresu jednej
z komórek leżących
w jego wnętrzu
2. Uruchom program.
3. Jako adres obszaru źródłowego wpisz adres komórki leżącej w jego środku.
5. Jako adres docelowy wpisz C7 (rysunek 10.15).
Rysunek 10.15.
Obszar docelowy
został wyróżniony
przez podanie
adresu komórki C7

7. Dane zostały skopiowane (rysunek 10.16). Wszystkie niepuste komórki
sąsiadujące z komórką B2 zostały skopiowane do schowka. Adres podany
na rysunku 10.15 jest adresem lewego górnego rogu obszaru docelowego.
Rysunek 10.16.
Dane źródłowe
zostały skopiowane
do obszaru
docelowego

Wpisz dane tak, jak pokazano na rysunku 10.17. Wykorzystując program z przykładu
147., dobierz takie wartości komórek obszaru źródłowego i docelowego, aby po sko-
piowaniu uzyskać arkusz przedstawiony na rysunku 10.18.
Rysunek 10.17.
Dane źródłowe
Rysunek 10.18.
Dane źródłowe
i skopiowane
Sortowanie zakresu komórek

Do sortowania komórek należących do zakresu należy wykorzystać metodę Range.Sort.

expression.Sort(Key1, Order1, Key2, Type, Order2, Key3, Order3, Header, OrderCustom,
MatchCase, Orientation, SortMethod, DataOption1, DataOption2, DataOption3)
gdzie expression jest zmienną reprezentującą zakres Range.
Opis parametrów występujących w wywołaniu metody znajduje się w tabeli 10.1.

Wszystkie one są opcjonalne.
Tabela 10.1. Parametry wywołania metody Sort

Nazwa Format Opis
Key1 Variant Pierwsze pole, względem którego jest wykonywane
sortowanie. Najczęściej parametr ma postać zakresu komórek
Order1 XlSortOrder Porządek sortowania według pola Key1
Key2 Variant Drugie pole, względem którego jest wykonywane sortowanie.
Parametr nie może wystąpić, jeśli są sortowane tabele przestawne
Type Variant Wyspecyfikowanie elementów, które mają być sortowane
Key3 Variant Trzecie pole, wzgledem którego jest wykonywane sortowanie.
Parametr nie może wystąpić, jeśli są sortowane tabele przestawne
Header XlYesNoGuess Zadeklarowanie, czy pierwszy wiersz zawiera informacje
nagłówka. Wartością domyślną jest xlNo
OrderCustom Variant Określenie przesunięcia na liście elementów sortowanych
MatchCase Variant Nadanie parametrowi wartości True powoduje, że przy
sortowaniu jest uwzględniana wielkość liter. Parametr
nie może być używany przy sortowaniu tabel przestawnych
Orientation XlSortOrientation Wybranie pomiędzy sortowaniem według kolejności rosnącej
a sortowaniem według kolejności malejącej
SortMethod XlSortMethod Wybranie metody sortowania
DataOption1 XlSortDataOption Wybranie sposobu sortowania tekstu w zakresie określonym
za pomocą klucza Key1. Parametr nie może być stosowany
przy sortowaniu tabel przestawnych
Przykład 166.
Napisz program, którego zastosowanie pozwoli generować dane w arkuszu, a następnie
sortować jego zawartość według zadanych kryteriów.
3. Wpisz kod programu:

Option Explicit
Sub Przykład_166()
MsgBox "Rozpoczynam generowanie danych!", vbInformation
'Generowanie danych do sortowania.

Range("A1").Value = "Nazwisko"
Range("A2").Value = "Ebacki"
Range("A3").Value = "Dabacki"
Range("A4").Value = "Cabacki"
Range("A5").Value = "Babacki"
Range("A6").Value = "Abacki"
MsgBox "Dane zostały wygenerowane!", vbInformation
'Zaznaczenie komórki.
Range("A1").Select
'Sortowanie.
MsgBox "Rozpoczynam sortowanie!", vbInformation
With ActiveWorkbook.Worksheets(ActiveSheet.Name).Sort
.SortFields.Clear
.SortFields.Add Key:=Range("A1:A6"), _
SortOn:=xlSortOnValues, Order:=xlAscending,
DataOption:=xlSortNormal
.SetRange Range("A1:A6")
.Header = xlYes
.MatchCase = False
.Orientation = xlTopToBottom
.SortMethod = xlPinYin
.Apply
End With
MsgBox "Sortowanie zakończone!", vbInformation
End Sub
4. Uruchom program.
5. W rezultacie wykonania drugiej linii programu zostało wyświetlone okno
(rysunek 10.19).
Rysunek 10.19.
Komunikat
informujący
o rozpoczęciu
pracy programu

7. Komórki od A1 do A6 zostały wypełnione danymi. Dalsze wykonywanie
programu zostało wstrzymane przez wyświetlenie okna komunikatu
(rysunek 10.20).
Rysunek 10.20.
W wyniku wykonania
procedury arkusz
został wypełniony
danymi

9. Został wyświetlony komunikat informujący, że program znajduje się przed
poleceniem sortowania (rysunek 10.21).
Rysunek 10.21.
Kolejność danych
nie została jeszcze
zmieniona

11. Dane zostały posortowane w kolejności rosnącej (rysunek 10.22). Odpowiada
za to parametr Order:=xlAscending. Dane w komórce A1 zostały potraktowane
jak nagłówek. Odpowiada za to parametr Header = xlYes.
Rysunek 10.22.
Nazwiska zostały
uporządkowane
w kolejności
alfabetycznej

Zmodyfikuj program z przykładu 166. tak, aby dane zostały posortowane w porządku
malejącym.

Po wykonaniu programu arkusz wygląda tak, jak pokazano na rysunku 10.23.
Rysunek 10.23.
Został również
posortowany
nagłówek kolumny
Znajdź błąd w programie, który doprowadził do potraktowania nagłówka na równi

z danymi:
Option Explicit
Sub Przykład_168()
MsgBox "Rozpoczynam generowanie danych!", vbInformation

'Generowanie danych do sortowania.
Range("A1").Value = "Nazwisko"
Range("A2").Value = "Ebacki"
Range("A3").Value = "Dabacki"
Range("A4").Value = "Cabacki"
Range("A5").Value = "Babacki"
Range("A6").Value = "Abacki"
MsgBox "Dane zostały wygenerowane!", vbInformation
'Zaznaczenie komórki.
Range("A1").Select
'Sortowanie.
MsgBox "Rozpoczynam sortowanie!", vbInformation
With ActiveWorkbook.Worksheets(ActiveSheet.Name).Sort
.SortFields.Clear
.SortFields.Add Key:=Range("A1:A6"), _
SortOn:=xlSortOnValues, Order:=xlAscending, DataOption:=xlSortNormal
.SetRange Range("A1:A6")
.Header = xlNo
.MatchCase = False
.Orientation = xlTopToBottom
.SortMethod = xlPinYin
.Apply
End With
MsgBox "Sortowanie zakończone!", vbInformation
End Sub

Wczytaj arkusz Przyklad_169.xlsm (rysunek 10.24). Przeanalizuj program, który fil-
truje rekordy zawierające tylko lokale o metrażu 85. Napisz program, którego zasto-
sowanie pozwoli sortować zawarte w nim dane kolejno według: liczby zameldowanych
osób, zużycia ciepłej wody, zużycia zimnej wody.

Wczytaj arkusz Przyklad_169.xlsm. Napisz program, którego zastosowanie pozwoli sor-
tować zawarte w nim dane kolejno według: liczby zameldowanych osób, zużycia ciepłej
wody, zużycia zimnej wody.
Rysunek 10.24.
Fragment arkusza
z danymi
Filtrowanie zakresu komórek

Do filtrowania komórek należących do zakresu należy wykorzystać metodę Range.Auto
Filter.

expression.AutoFilter(Field, Criteria1, Operator, Criteria2, VisibleDropDown)
gdzie expression jest zmienną reprezentującą zakres Range.

Wszystkie one są opcjonalne.
Tabela 10.2. Parametry wywołania metody AutoFilter

Nazwa Format Opis
Field Variant Przesunięcie pola, względem którego ma zostać
wykonane filtrowanie. Pola są liczone od lewej
strony. Pole położone najbardziej po lewej stronie
ma numer jeden
Tabela 10.2. Parametry wywołania metody AutoFilter (ciag dalszy)

Nazwa Format Opis
Criteria1 Variant Kryterium filtrowania. Zapis w postaci ciągu.
Użycie parametru "=" spowoduje wyszukiwanie
pustych pól. Użycie parametru "<>" spowoduje
wyszukanie niepustych pól. Jeżeli parametr zostanie
pominięty, jest domyślnie przyjmowana wartość All.
Jeżeli parametr Operator ma wartość xlTop10Items,
parametr Criteria1 określa liczbę elementów
Operator XlAutoFilterOperator Jedna ze stałych XlAutoFilterOperator określa typ filtru
Criteria2 Variant Drugie kryterium filtrowania (ciąg znaków). Używane
z Criteria1 i Operator umożliwia definiowanie
kryteriów złożonych
VisibleDropDown Variant Nadanie parametrowi wartości True powoduje
wyświetlenie strzałki umożliwiającej rozwijanie
filtru. Nadanie parametrowi wartości False powoduje
ukrycie strzałki umożliwiającej rozwijanie filtru.
Domyślną wartością jest True
Przykład 172.
Wczytaj arkusz Przyklad_169.xlsm (rysunek 10.25). Napisz program, którego zastosowa-
nie spowoduje włączenie filtru i wyświetlenie odczytów liczników tylko z tych lokali,
które w kolumnie Metraż mają wpisaną liczbę 85. Czarna strzałka umożliwiająca rozwija-
nie filtru ma być widoczna.
Rysunek 10.25.
Arkusz z danymi

2. Wpisz kod programu (rysunek 10.26).
Rysunek 10.26.
Kod programu
3. Uruchom program.
4. Wyświetl arkusz z danymi.
5. W tabeli są widoczne skutki zastosowania filtru. Kryterium pokazania lub
ukrycia wiersza są dane wpisane w kolumnie B (rysunek 10.27). Są wyświetlone
tylko te komórki w filtrowanym zakresie, które zawierają ciąg przypisany
parametrowi Criteria1 (rysunek 10.27).
Rysunek 10.27.
W arkuszu zostały
ukryte wiersze,
które w kolumnie B
zawierają inne
wartości niż 85

Roztargniony programista chciał napisać program, który będzie realizował polecenia
z przykładu 171. Po wykonaniu programu arkusz wygląda tak, jak pokazano na ry-
sunku 10.28.
Rysunek 10.28.
Został posortowany
również nagłówek
kolumny
Znajdź błąd w programie (rysunek 10.29).
Rysunek 10.29.
Gdzie tkwi błąd?
Przykład 174.
Napisz program, którego zastosowanie spowoduje włączenie filtru i wyświetlenie tylko
wierszy zawierających słowo cukier. Przefiltrowane dane powinny zostać skopiowane
z kolumny A do kolumny B.
2. Wpisz dane (rysunek 10.30).
Rysunek 10.30.
Zestaw danych

4. Wpisz kod programu (rysunek 10.31). Jest on połączeniem programów:
filtrującego i kopiującego obszar z przykładów opisanych w tym rozdziale.
Rysunek 10.31.
Kod programu
5. Uruchom program.
Przykład 174. ilustruje popularną technikę pisania programów. Jeżeli masz już pro-
gram, który wykonuje część tego, co ma wykonać nowy program, nie pisz wszystkiego
od początku. Wykorzystaj to, co masz. Dodaj tylko nowe elementy.
Rysunek 10.32.
Dane w kolumnie A
zostały odfiltrowane
i skopiowane
do kolumny B
Wyszukiwanie informacji
Do wyszukiwania zawartości komórek należących do zakresu należy wykorzystać
metodę Range.Find.

expression.Find(What, After, LookIn, LookAt, SearchOrder, SearchDirection,
MatchCase, MatchByte, SearchFormat)
gdzie expression jest zmienną reprezentującą zakres Range. Metoda zwraca adres
pierwszej komórki, w której odnaleziono szukany ciąg znaków.

Jedynie parametr What jest niezbędny.
Tabela 10.3. Parametry wywołania metody Find

Nazwa Format Opis
What Variant Szukany ciąg
After Variant Komórka, od której zostanie rozpoczęte wyszukiwanie.
Odpowiada ona położeniu aktywnej komórki, gdy
wyszukiwanie jest wykonywane za pośrednictwem interfejsu
użytkownika. Jeżeli parametr nie zostanie wyspecyfikowany,
wyszukiwanie rozpoczyna się od komórki A1
LookIn Variant Nadanie parametrowi wartości xlFormulas powoduje, że
są wyszukiwane formuły. Nadanie parametrowi wartości
xlValues powoduje, że są wyszukiwane wartości
LookAt Variant Nadanie parametrowi wartości xlWhole powoduje,
że wyszukiwanie jest prowadzone tylko wśród całych słów.
Nadanie parametrowi wartości xl Part powoduje,
że wyszukiwanie jest prowadzone wśród ciągów znaków
Tabela 10.3. Parametry wywołania metody Find (ciąg dalszy)

Nazwa Format Opis
SearchOrder Variant Nadanie parametrowi wartości xlByRows powoduje,
że wyszukiwanie jest prowadzone wierszami.
Nadanie parametrowi wartości xlByColumns powoduje,
że wyszukiwanie jest prowadzone kolumnami
SearchDirection XlSearchDirection Kierunek wyszukiwania: xlNext — szukanie wśród komórek
następnych, xlPrevious — szukanie wśród komórek
poprzednich. Domyślnie jest przyjmowana wartość xlNext
MatchCase Variant Nadanie parametrowi wartości True powoduje,
że wyszukiwanie jest prowadzone z uwzględnieniem
wielkości liter. Domyślnie jest przyjmowana wartość False
MatchByte Variant Używany tylko wtedy, gdy został wybrany lub
zainstalowany double-byte language support. Nadanie
parametrowi wartości True powoduje, że znakom typu
double-byte odpowiadają tylko znaki double-byte.
Nadanie parametrowi wartości False powoduje, że jako
identyczne ze znakami double-byte będą traktowane
ich odpowiedniki typu single-byte
SearchFormat Variant Format szukanych danych
Zastosowanie metod FindNext i FindPrevious umożliwia powtórzenie wyszukiwania.
Przykład 175.
Napisz program, którego zastosowanie doprowadzi do zamiany w komórkach należą-
cych do zakresu od A1 do H18 wszystkich wystąpień cyfr 1 na 2.
2. Wpisz dane (rysunek 10.33).
Rysunek 10.33. Arkusz z danymi


Rysunek 10.34.
Kod programu.
Zastosowanie
programu
doprowadza
do zmiany nie tylko
komórek z wartością 1,
ale też np. 111
5. Uruchom program.
6. Po wyświetleniu okna z komunikatem Zmiana została wykonana kliknij
przycisk OK (rysunek 10.35).
Rysunek 10.35. Dane w komórkach należących do zakresu od A1 do H18 zostały zmienione

W programie z przykładu 175. wprowadź zmianę, która spowoduje, że będzie mody-
fikowana zawartość komórek od A1 do F6. Liczba 1 zostać zamieniona na liczbę 0.
W zakresie od A7 do D14 liczba 1 zostać zamieniona na liczbę 9.
Podsumowanie
 Do kopiowania zakresu komórek służy metoda Range.Copy.
 Do sortowania komórek należących do zakresu należy wykorzystać metodę
Range.Sort.
 Do filtrowania komórek należących do zakresu należy wykorzystać metodę
Range.AutoFilter.
 Do wyszukiwania zawartości komórek należących do zakresu należy
wykorzystać metodę Range.Find.
Rozdział 11.
Podprogramy
 Co trzeba zrobić, aby dane były przekazywane pomiędzy podprogramami
 Jakie zmienne nazywamy globalnymi
 Jak można przerwać działanie programu zapętlonego
Napisanie dużego programu, który będzie bezbłędnie działał, nie jest łatwe. Prost-
szym zadaniem jest podzielenie jednego wyzwania na odpowiednią liczbę mniej-
szych, czyli rozbicie programu na podprogramy. Przy podziale możesz sobie pomóc
rysunkiem. Narysuj podprogramy w postaci prostokątów. Każdy z nich powinien wy-
konywać elementarną czynność. Elementarność jest pojęciem względnym — zależy
od Twojego doświadczenia programistycznego. Poszczególne prostokąty połącz strzał-
kami, które będą wskazywały kierunek przepływu danych. Nad każdą strzałką napisz,
jakie dane mają być przesyłane pomiędzy prostokątami — programami. W każdym
prostokącie napisz w jednym zdaniu, co program ma robić. Jeżeli czas Cię nie goni...
zostaw diagram na dzień lub dwa. Wróć do niego i zastanów się, czy wszystko jest jasne,
czy czegoś nie brakuje. Wprowadź niezbędne poprawki.
Następnym etapem pracy jest napisanie programów, które będą realizowały to, co jest
wpisane w prostokątach. Opisy na strzałkach łączących prostokąty informują, jakie
dane powinny zostać przekazane programowi i jakie powinny zostać zwrócone.
Rysując prostokąty, dzieliliśmy problem na części. Teraz czeka nas zadanie odwrotne.
Programy realizujące elementarne zadania należy połączyć w jeden program. Nie
zawsze udaje się to za pierwszym razem. Jeżeli program nie działa poprawnie lub wy-
świetla komunikaty o błędach, trzeba dopisać do niego polecenia, które pozwolą zo-
rientować się, jak wyglądają cząstkowe wyniki przetwarzania danych. Rolę podglądu
danych cząstkowych mogą odgrywać okna komunikatów. Są one generowane dzięki
wykorzystaniu funkcji MsgBox. Można rozpocząć od wstawienia ich pomiędzy wywo-
łaniami poszczególnych podprogramów. Powinny wyświetlać wartości wymieniane
pomiędzy podprogramami. Na tym etapie testowania może okazać się, że błąd został
popełniony podczas rysowania schematu blokowego. Niestety, bywa i tak. Rysowanie
schematu blokowego nie jest stratą czasu. Pozwoli Ci na przeanalizowanie problemu.
Gdy będziesz miał gotowy schemat, będziesz mógł zająć się tylko programowaniem.
Schemat blokowy pozwoli również na weryfikację założeń. Pamiętaj, aby nanosić na
schemat wszystkie zmiany. Dzięki temu będzie on aktualny i użyteczny.
Gdy programy składowe działają pojedynczo, są nazywane programami. Programy

wchodzące w skład innego programu są zwane podprogramami.
Program można przyrównać do szefa. Podprogramy przypominają pracowników.

Działanie programu polega na kolejnym wywoływaniu programów i przydzielaniu im
zadań.
W praktyce program uruchamia podprogram. Po jego wykonaniu następuje powrót do

miejsca wywołania. Aby to, co wyliczy jeden podprogram, mógł wykorzystać inny pod-
program, jest konieczne poprawne przekazywanie danych.
Najprostszym rodzajem programu jest makropolecenie. Nie wymaga ono podawania pa-
rametrów. Może działać samodzielnie lub być uruchamiane z wnętrza innego polecenia.
Przykład 177.
Napisz program składający się z dwóch procedur. Zastosowanie pierwszej procedury
pozwala wczytać dane. Zastosowanie drugiej umożliwia wyświetlenie ich na ekranie.
1. Narysuj odręcznie schemat blokowy programu (rysunek 11.1).
Rysunek 11.1.
Schemat blokowy
programu

4. Z rozdziału piątego wiemy, jak napisać program mający postać jednej
procedury, za pomocą którego można wczytać i wyświetlić dane. Wpisz
kod programu (rysunek 11.2). Zastosowanie drugiej instrukcji umożliwia
wyświetlenie okna z prośbą o wpisanie danych. Po wpisaniu ich i kliknięciu
przycisku OK są one przypisywane zmiennej x. Zastosowanie trzeciej instrukcji
umożliwia wyświetlenie okna z wprowadzoną daną. Zaproponowane rozwiązanie
nie spełnia wymagań stawianych programowi w tym przykładzie (jest jedną
procedurą). Pozwoli jednak na sprawdzenie, czy instrukcje są poprawne.
Rysunek 11.2.
Kod programu
Rozdział 11.  Podprogramy 303
5. Uruchom program.
6. Po wyświetleniu okna (rysunek 11.3) wpisz dane i kliknij przycisk OK.
Rysunek 11.3.
Ciąg znaków zawiera
wielkie i małe litery,
liczby oraz znak
wpisany za pomocą
kombinacji
z klawiszem Shift
7. Zostało wyświetlone okno z danymi, które zostały przekazane do programu

(rysunek 11.4). Kliknij przycisk OK.
Rysunek 11.4.
Wpisanie
i wyświetlenie
danych nie
spowodowało
błędów
8. Kolejnym etapem jest rozdzielenie instrukcji na procedury i umieszczenie

w głównej części programu wywołania procedur. Wyświetl okno do wpisywania
kodu. Wpisz kod programu (rysunek 11.5). Program składa się z procedur
procedura1 i procedura2. W pierwszej umieszczono polecenie wyświetlenia
okna do wprowadzania danych. W drugiej umieszczono polecenie wyświetlania
okna z danymi, które zostały przypisane zmiennej x. W górnej części okna
jest widoczna główna część programu. Składa się ona z wywołań procedur
o numerach 1 i 2.
Rysunek 11.5.
Program podzielony
na procedury
9. Uruchom program.
Rysunek 11.6.
Okno dialogowe
wygląda identycznie
jak na rysunku 11.3
11. Zostało wyświetlone okno, lecz nie ma w nim danych, które zostały
przekazane do programu (rysunek 11.7). Kliknij przycisk OK.
Rysunek 11.7.
Zniknęły gdzieś
dane wprowadzone
do programu
12. Za zniknięcie danych jest odpowiedzialna zmienna x, która jest używana

w obu procedurach. Ma ona zasięg lokalny i nie została zadeklarowana na
początku programu. Przed wywołaniem procedur dodaj linię Dim x As String
(rysunek 11.8). Zadeklarowanie zmiennej na początku programu powoduje,
że zostaje jej przydzielona „funkcja transportowa”. Jeżeli w pierwszej
procedurze przypisze się jej wartość, to będzie ona dostępna także w procedurze
drugiej. Zmienne deklarowane w procedurach są nazywane lokalnymi. Są one
dostępne tylko wewnątrz procedury. Zmienne deklarowane na początku
programu są zwane globalnymi. Pozwalają na wewnętrzne komunikowanie
się procedur. W ostatniej sekcji kodu jest inicjowana zmienna. Odbywa się
to przy każdym otworzeniu pliku.
Rysunek 11.8.
Zadeklarowanie
zmiennej x na
początku programu
Rysunek 11.9.
Rezultat wykonania
podprogramu
procedura1
15. Zostało wyświetlone okno z danymi, które zostały przekazane do programu.

Kliknij przycisk OK (rysunek 11.10).
Zmienne globalne są widoczne w każdej procedurze. Przestają pełnić funkcję komu-

nikacyjną między procedurami, gdy zostaną zadeklarowane wewnątrz procedury.
Rysunek 11.10.
Rezultat wykonania
procedury procedura2

W programie z przykładu 177. w procedurze pierwszej zadeklaruj zmienną x. Sprawdź,
jaki ma to wpływ na działanie programu.
Rysunek 11.11.
W procedurze
pierwszej
zadeklarowano
zmienną, która
powinna być
stosowana jako
zmienna globalna
4. Uruchom program.
5. Sprawdź, czy dane są przekazywane między procedurami.

W programie z przykładu 177. w procedurze drugiej zadeklaruj zmienną x. Sprawdź,
jaki ma to wpływ na działanie programu.
4. Uruchom program.
5. Sprawdź, czy dane są przekazywane między procedurami.
Rysunek 11.12.
W procedurze drugiej
zadeklarowano
zmienną, która ma
identyczną nazwę jak
zmienna globalna

W programie z przykładu 177. przenieś deklarację zmiennej X do linii drugiej (rysu-
nek 11.13). Sprawdź, jaki ma to wpływ na działanie programu.
Rysunek 11.13.
Deklaracja zmiennej
została wstawiona
w drugiej linii

W programie z przykładu 177. usuń podprogram inicjalizacji zmiennej X z końca pro-
gramu (rysunek 11.14). Sprawdź, jaki ma to wpływ na działanie programu.
Rysunek 11.14.
Czy program po
usunięciu ostatniej
procedury będzie
działał?
Śledzenie pracy programu

Aby zorientować się, do którego miejsca kodu program „doszedł”, można wstawić
instrukcje, które będą wyświetlane podczas jego pracy. Mogą one zarówno wyświe-
tlać komunikaty, jak i pokazywać wartości zmiennych.
Przykład 182.
Napisz program składający się z dwóch podprogramów i programu głównego zawiera-
jącego wywołania podprogramów. Umieść w nim polecenia, których wykonanie umożli-
wia wyświetlanie komunikatów informujących o aktualnie wykonywanej instrukcji.
Rysunek 11.15.
Program, którego
zobaczyć, jak kolejno
są wykonywane
procedury
4. Uruchom program.
5. Zostały wyświetlone okna z numerami kolejno: 01, 04, 02, 05, 03. Oznacza
to, że program po uruchomieniu „zadeklarował” zmienną x. Następnie została
wywołana procedura o numerze 1. Po jej wykonaniu program powrócił do
programu głównego. Następnie została wywołana procedura o numerze 2.
Po jej wykonaniu program powrócił do programu głównego i został zakończony.

Wprowadź zmiany w programie z przykładu 182. tak, aby kolejno zostały wyświetlone
okna z numerami: 01, 02, 03, 04, 05.
Przykład 184.
Napisz program składający się z dwóch podprogramów i programu głównego zawiera-
jącego wywołania podprogramów. Umieść w nim polecenia, których wykonanie umoż-
liwia wyświetlanie komunikatów informujących o aktualnie realizowanej instrukcji
i wartości zmiennej.
Rysunek 11.16.
Program, którego
zobaczyć, jak
procedury są kolejno
wykonywane
4. Uruchom program.
5. Zostały wyświetlone okna z numerami kolejno: 01, 04, 02, 05, 03. Komunikat
o numerze 0n jest wyświetlany, gdy jest wykonywana instrukcja MsgBox ("0n.
Zmienna x:" & x), gdzie n=1, 2 … 5. Zmienna x cały czas miała wartość zero.

Zmień program z przykładu 165. tak, aby w kolejno wyświetlanych oknach były wi-
doczne numery: 05, 04, 03, 02, 01.

Wpisz i uruchom program z rysunku 11.17. Wprowadź w nim taką zmianę, aby w oknach
komunikatów kolejno były wyświetlane liczby od 1 do 4.
Rysunek 11.17.
Co należy zmienić
w programie, aby
po uruchomieniu
wyświetlał liczby
od 1 do 4?
Procedury zagnieżdżone
W dotychczas omawianych przykładach z programu głównego była wywoływana jed-
na procedura. Po jej zakończeniu następował powrót do programu głównego.
Procedura, która jest wywoływana z programu głównego, również może zawierać

wywołania procedur.
Przykład 187.
Napisz program składający się z programu głównego zawierającego wywołanie podpro-
gramu procedura1. Podprogram powinien zawierać wywołanie podprogramu procedura2.
Podprogram procedura2 powinien zawierać wywołanie podprogramu procedura3. Po
wykonaniu procedury procedura3 powinien nastąpić powrót do podprogramu proce-
dura2. Po wykonaniu procedury procedura2 powinien nastąpić powrót do podprogra-
mu procedura1. Po wykonaniu procedury procedura1 powinien nastąpić powrót do
programu głównego.
Rysunek 11.18.
Program
z procedurami
zagnieżdżonymi
4. Umieść punkt wstawiania na początku pierwszej linii kodu.

5. Uruchom program.
6. Został wyświetlony komunikat informujący o wykonaniu drugiej linii programu
(rysunek 11.19). Kliknij przycisk OK.
Rysunek 11.19.
Komunikat
informujący
o wykonaniu
drugiej linii
programu
7. Został wyświetlony komunikat informujący o wywołaniu podprogramu

procedura1 (rysunek 11.20). Kliknij przycisk OK.
Rysunek 11.20.
Komunikat
informujący
o wywołaniu
podprogramu
procedura1

Rysunek 11.21.
Komunikat
informujący
o wywołaniu
podprogramu
procedura2

Rysunek 11.22.
Komunikat
informujący
o wywołaniu
podprogramu
procedura3
10. Został wyświetlony komunikat informujący o zakończeniu wykonywania

podprogramu procedura1 (rysunek 11.23). Kliknij przycisk OK.
Rysunek 11.23.
Komunikat
informujący
o wykonaniu
czwartej linii
programu

Zmień program z przykładu 187. tak, aby efektem jego wykonania było wyświetlenie
na ekranie napisów procedura3, procedura2, procedura1, Koniec programu głównego.
Po wykonaniu procedur powinien nastąpić powrót do programu głównego.
Procedury zapętlone
Od procedur zagnieżdżonych niedaleka droga do procedur zapętlonych. Z sytuacją tego
typu mamy do czynienia, gdy z procedury n jest wywoływana procedura n+1, a z pro-
cedury n+1 — ponownie procedura n. Procedury będą się wzajemnie wywoływać. Takie
zjawisko powstaje najczęściej na skutek błędu programisty.
Przykład 189.
Napisz program zawierający zapętlone wywołanie procedur.
3. Wpisz kod programu (rysunek 11.24). Po wywołaniu podprogramu procedura1
jest wywoływany podprogram procedura2. Podprogram procedura2 zawiera
wywołanie podprogramu procedura1 itd. W efekcie komunikat informujący
o zakończeniu programu głównego nie zostanie wyświetlony.
Rysunek 11.24.
Program
z procedurami
zapętlonymi
4. Umieść punkt wstawiania na początku pierwszej linii kodu.

5. Uruchom program.
6. Po wyświetleniu komunikatu Początek programu głównego kliknij przycisk OK.
7. Po wyświetleniu komunikatu Procedura 1 kliknij przycisk OK.
11. Aby przerwać działanie programu, naciśnij klawisze Ctrl+Alt+Del.
12. Następnie wybierz opcję Uruchom Menedżera zadań.
13. W oknie Menedżer zadań (rysunek 11.25) kliknij kartę Aplikacje.
Rysunek 11.25.
Jedyny sposób na
zakończenie działania
zapętlonej procedury
14. Zaznacz edytor.

15. Kliknij przycisk Zakończ zadanie.
16. Zaznacz arkusz kalkulacyjny.
17. Kliknij przycisk Zakończ zadanie.
18. Zanim arkusz zostanie zamknięty, zostanie wyświetlone ostrzeżenie o utracie
danych (rysunek 11.26). Kliknij przycisk Zakończ teraz.
Rysunek 11.26.
W przykładzie
żadne dane nie były
zapisywane w arkuszu
19. Po chwili również i arkusz zostanie zamknięty (rysunek 11.27).
Rysunek 11.27.
Zapętlony program
zakończył działanie

Program z przykładu 189. zatrzymywał się po każdym przeskoku między procedurami.
W praktyce zdarza się, że program nie zatrzymuje się nawet na chwilę. Uruchom program
zapętlony. Zaobserwuj, jaki komunikat został wyświetlony na ekranie. W ćwiczeniu wy-
korzystaj program pokazany na rysunku 11.28.
Rysunek 11.28.
Program, który
po zapętleniu się
pracuje bez chwili
wytchnienia, aż…
Podsumowanie
 Zadeklarowanie zmiennej na początku programu powoduje, że zostaje jej
przydzielona „funkcja transportowa”. Jeżeli pierwsza procedura przypisze jej
wartość, to ta wartość będzie dostępna także w procedurze drugiej. Zmienne
deklarowane w procedurach są nazywane lokalnymi. Są one dostępne tylko
wewnątrz procedury, w której zostały zadeklarowane. Zmienne deklarowane
na początku programu są nazywane globalnymi. Pozwalają na wewnętrzne
komunikowanie się procedur.
 Zmienne globalne są widoczne w każdej procedurze. Gdy zmienne są
deklarowane wewnątrz procedury, przestają mieć charakter globalny
i nie mogą spełniać funkcji komunikacyjnej.
 Aby przerwać działanie programu, naciśnij klawisze Ctrl+Alt+Del.
Następnie wybierz opcję Uruchom Menedżera zadań. W oknie Menedżer
zadań kliknij kartę Aplikacje. Zaznacz program, którego działanie chcesz
przerwać. Kliknij przycisk Zakończ zadanie.
Rozdział 12.
Ściągawka z VBA
 Jak uzyskać dodatkowe informacje na temat instrukcji języka VBA
Analizowanie przykładów nie wymaga znajomości wielu metod i właściwości. Program

jest opisany. Gotowy kod można uruchomić. Inaczej sprawa przedstawia się, gdy trzeba
napisać program samodzielnie. W przykładach została użyta zaledwie niewielka część
metod, funkcji, operatorów i właściwości dostępnych w języku VBA. Szczegółowe
opisanie ich wszystkich przekroczyłoby objętość tej książki.
W pisaniu własnych programów może być pomocna ściągawka (tabele od 12.1 do 12.9).
Można się z niej dowiedzieć, w jaki sposób uzyskać w programie oczekiwany efekt.
Metody
Tabela 12.1. Wybrane metody
Nazwa Opis
Activate Uaktywnienie pojedynczej komórki
AddComment Dodanie komentarza do zakresu
AdvancedFilter Odfiltrowanie lub skopiowanie danych z listy utworzonej na podstawie kryteriów
ApplyNames Nadanie nazw komórkom w wyspecyfikowanym zakresie
ApplyOutlineStyles Wyróżnienie wyspecyfikowanego zakresu przez dodanie obwódki
AutoFill Automatyczne wypełnienie komórek w wyspecyfikowanym zakresie
AutoFilter Odfiltrowanie listy przy wykorzystaniu filtru
AutoFit Dopasowanie szerokości kolumny lub wysokości wiersza w celu wyświetlenia
pełnej zawartości
AutoOutline Otoczenie obwódką komórek w wyspecyfikowanym zakresie (zaznaczenie).
Stara obwódka zostaje zastąpiona nową
Tabela 12.1. Wybrane metody (ciag dalszy)

Nazwa Opis
BorderAround Wyróżnienie zakresu obwódką, kolorem, stylem oraz szerokością linii
Calculate Przeliczenie wszystkich otwartych zeszytów, wyspecyfikowanych skoroszytów
lub wyspecyfikowanego zakresu komórek
CheckSpelling Sprawdzenie pisowni obiektu
Clear Wyczyszczenie obiektu
ClearComments Wyczyszczenie wszystkich komentarzy w wyspecyfikowanym zakresie
ClearContents Wyczyszczenie wszystkich formuł w wyspecyfikowanym zakresie
ClearFormats Wyczyszczenie formatów obiektów
ClearNotes Wyczyszczenie notatek pisemnych i dźwiękowych komórek
w wyspecyfikowanym zakresie
ClearOutline Usunięcie obwódki komórek w wyspecyfikowanym zakresie
ColumnDifferences Wyznaczenie zakresu obiektu reprezentującego wszystkie komórki, których
zawartość jest różna od komórki wzorcowej w każdej kolumnie
Consolidate Scalenie danych z wielu zakresów różnych arkuszy w jeden zakres na jednym
arkuszu
Copy Skopiowanie zawartości komórek znajdujących się w wyspecyfikowanym
zakresie do innego zakresu do schowka
CopyFromRecordset Skopiowanie zawartości zestawu rekordów ADO (ang. ActiveX Data Objects)
lub DAO (ang. Data Access Object) do jednego arkusza. Rozpoczyna się
od lewego górnego rogu zakresu. Jeżeli zestaw rekordów zawiera pola
z obiektami typu OLE, ta metoda nie działa
CopyPicture Skopiowanie zaznaczonego obiektu w postaci obrazu do schowka
CreateNames Utworzenie nazw na podstawie etykiet tekstowych w wyspecyfikowanym
zakresie
Cut Wycięcie obiektów i wstawienie ich do schowka lub wstawienie do wskazanej
lokalizacji
DataSeries Utworzenie w wyspecyfikowanym zakresie serii danych
Delete Usunięcie obiektu
DialogBox Wyświetlenie okna dialogowego zdefiniowanego przy wykorzystaniu
makropoleceń arkusza Microsoft Excel 4.0
Dirty Wyznaczenie zakresu, który zostanie ponownie przeliczony przy następnej
aktualizacji arkusza
EditionOptions Zażądanie wyświetlenia pomocy na temat słowa kluczowego Visual Basic,
stosowane tylko na komputerach Macintosh
ExportAsFixed Wyeksportowanie danych w wyspecyfikowanym formacie
Format
FillDown Wypełnienie komórek znajdujących się poniżej wskazanej komórki, aż do
dolnego końca zakresu. Zawartość i formatowanie komórki lub komórek
w najwyższym wierszu zakresu zostają skopiowane do pozostałych wierszy
w zakresie
Rozdział 12.  Ściągawka z VBA 319

Nazwa Opis
FillLeft Wypełnienie komórek znajdujących się na lewo od wskazanej komórki lub
komórek w wyspecyfikowanym zakresie. Zawartość i formatowanie komórki
lub komórek w znajdującej się najbardziej na prawo kolumnie zakresu zostają
skopiowane do pozostałych kolumn w zakresie
FillRight Wypełnienie komórek znajdujących się na prawo od wskazanej komórki lub
komórek w wyspecyfikowanym zakresie. Zawartość i formatowanie komórki
lub komórek w znajdującej się najbardziej na lewo kolumnie zakresu zostają
skopiowane do pozostałych kolumn w zakresie
FillUp Wypełnienie komórek znajdujących się powyżej wskazanej komórki, aż do
górnego końca zakresu. Zawartość i formatowanie komórki lub komórek
w dolnym wierszu zakresu zostają skopiowane do pozostałych wierszy
w zakresie
Find Wyszukiwanie wyspecyfikowanej informacji w zakresie komórek
FindNext Kontynuowanie wyszukiwania, które zostało zapoczątkowane przy
wykorzystaniu metody Find. Jego rezultatem jest znalezienie kolejnej komórki,
która spełnia stawiane wymagania. Wynikiem jest obiekt Range, który
reprezentuje komórkę. Metoda nie ma wpływu na zaznaczenia i komórkę
aktywną
FindPrevious Kontynuowanie wyszukiwania, które zostało zapoczątkowane przy
wykorzystaniu metody Find. Jego rezultatem jest znalezienie poprzedniej
komórki, która spełnia stawiane wymagania. Wynikiem jest obiekt Range, który
reprezentuje komórkę. Metoda nie ma wpływu na zaznaczenia i komórkę
aktywną
FunctionWizard Uruchomienie kreatora Function Wizard w lewym górnym rogu zakresu
Group Gdy obiekt Range reprezentuje pojedynczą komórkę w zakresie pól danych tabeli
przestawnej, zastosowanie metody powoduje liczbowe lub bazujące na danych
pogrupowanie danych w polu
Insert Wstawienie komórki lub zakresu komórek do arkusza. Pozostałe komórki
są przesuwane, aby zrobić miejsce dla nowych
InsertIndent Wstawienie wycięcia do wyspecyfikowanego obszaru
Justify Rozsunięcie tekstu w wyspecyfikowanym zakresie tak, aby wypełnił zakres
w równomierny sposób
ListNames Wstawienie do arkusza listy wszystkich nieukrytych nazw, począwszy
od pierwszej komórki w zakresie
Merge Scalenie komórek w wyspecyfikowanym zakresie
Parse Rozdzielenie zakresu danych i wstawienie ich do wielu komórek. Dzieli
zawartość zakresu, aby wypełnić kilka przyległych kolumn. Zakres nie może
być szerszy niż jedna kolumna
PasteSpecial Wstawienie obiektu Range ze schowka do wyspecyfikowanego zakresu
PrintOut Wydrukowanie obiektu
PrintPreview Wyświetlenie obiektu w trybie podglądu wydruku
RemoveDuplicates Usunięcie zdublowanych obiektów

Nazwa Opis
RowDifferences Zwrócenie obiektu Range, który reprezentuje wszystkie komórki mające zawartość
różną od wzorca
Run Uruchomienie makropolecenia arkusza Microsoft Excel w wyspecyfikowanej
lokalizacji
Select Zaznaczenie (np. obiektu, zakresu komórek)
SetPhonetic Utworzenie obiektów Phonetic dla wszystkich komórek w wyspecyfikowanym
zakresie
Show Przewinięcie zawartości aktywnego okna w celu wyświetlenia zaznaczonego
zakresu. Zakres musi zawierać pojedynczą komórkę w aktywnym dokumencie
ShowDependents Narysowanie strzałek obrazujących zależność zakresu
ShowErrors Wyświetlenie strzałek do komórek, które są źródłem błędów. Jako wynik jest
zwracany zakres zawierający komórkę
Sort Sortowanie danych według zadanych kryteriów
Speak Odczytanie zawartości komórek należących do wyspecyfikowanego zakresu
(czytanie może odbywać się wierszami lub kolumnami)
SpecialCells Zwrócenie zakresu obiektu, który reprezentuje wszystkie komórki mające
określony typ i wartość
SubscribeTo Zażądanie wyświetlenia pomocy na temat słowa kluczowego używanego tylko
na komputerach Macintosh
Table Utworzenie tabeli danych opartej na wartościach wejściowych i formułach,
które zdefiniowałeś w arkuszu
TextToColumns Rozdzielenie kolumny lub komórek zawierających tekst na kilka kolumn
Ungroup Zmniejszenie stopnia obwiedni. Wyspecyfikowany zakres musi być wierszem,
kolumną, zakresem wierszy lub kolumn. Jeżeli zakresem jest raport tabeli
przestawnej, metoda rozgrupowuje elementy zawarte w zakresie
UnMerge Dzielenie scalonego obszaru na poszczególne komórki
Przykład 172.
Uzyskaj informacje na temat metody BorderAround, które to informacje pozwolą na
wykorzystanie jej w programie.
1. Uruchom przeglądarkę internetową.
2. W wyszukiwarce Google wpisz hasło Range.BorderAround Method.
3. W wynikach wyszukiwania (rysunek 12.1) kliknij odsyłacz do artykułu
ff197210 opublikowanego w msdn.microsoft.com.
Rysunek 12.1.
Okno umożliwia
wyszukiwanie
terminów
i przeglądanie
tematów
4. Zostało wyświetlone okno z podstawowymi informacjami o szukanym haśle

(rysunek 12.2). W sekcji Syntax została opisana składnia metody. W sekcji
Parameters zostało wyjaśnione znaczenie poszczególnych parametrów
wywołania metody. W sekcji Return Value jest widoczna informacja
o formacie zwracanych przez metodę wyników. W sekcji Remarks znajdują
się uwagi dodatkowe i wyjaśnienia. W sekcji Example znajduje się przykład
zastosowania metody.
Rysunek 12.2. Podstawowe informacje o metodzie
Przykład 191.
Napisz program, którego zastosowanie pozwoli otoczyć grubą obwódką w kolorze
czerwonym komórki w obszarze od A1 do H1.
1. Odszukaj w lewej kolumnie tabeli 12.1 hasło Wyróżnienie zakresu obwódką,
kolorem, stylem oraz szerokością linii.
2. W prawej kolumnie tabeli 12.1 znajdź odpowiadającą mu metodę.
5. W pomocy dotyczącej metody (rysunek 12.2) odszukaj przykład
(rysunek 12.3).
Rysunek 12.3.
Przykład zastosowania
polecenia, którego
wykonanie pozwala
wyróżnić obszar
obwódką
6. Zaznacz i skopiuj do schowka przykład zastosowania metody.

7. Wyświetl okno do wpisywania kodu. W tym celu naciśnij klawisz F7.
8. Wpisz szkielet kodu programu (rysunek 12.4).
Rysunek 12.4.
Szkielet kodu
programu
9. Wklej zawartość schowka (rysunek 12.5).
Rysunek 12.5.
metody został
skopiowany
do programu
10. Zmień nazwę arkusza z Sheet1 na taką, jaka jest widoczna w oknie
Project - VBAProject, czyli na Arkusz1. Kliknij przycisk, za pomocą którego
uruchomisz program (rysunek 12.6).
Rysunek 12.6.
Po usunięciu
niezgodności nazw
można spróbować
uruchomić program
11. Wyświetl okno arkusza Excela. Komórki w zakresie od A1 do D4 zostały

otoczone grubą obwódką w kolorze czerwonym (rysunek 12.7).
Rysunek 12.7.
Rezultat wykonania
programu
z rysunku 12.6
12. Dzięki skopiowaniu przykładu do programu mamy pewność, że nie

popełniliśmy literówki. Program został sprawdzony. Teraz należy wprowadzać
zmiany pojedynczo. Po każdej poprawce trzeba sprawdzić, czy program działa.
W razie niepowodzenia będziemy wiedzieć, która zmiana jest przyczyną błędu.
Zmień zakres komórek z A1 – D4 na A1 – H1 (rysunek 12.8).
Rysunek 12.8.
Zakres zaznaczanych
komórek został
zmieniony
13. Kliknij przycisk, za pomocą którego uruchomisz program (rysunek 12.6).

14. Wyświetl okno arkusza Excela. Komórki w zakresie od A1 do H1 zostały
otoczone grubą obwódką w kolorze czerwonym (rysunek 12.9).
Rysunek 12.9.
Zakres jest zgodny
z docelowym

Wartość parametru ColorIndex (patrz rysunek 12.6) określa kolor ramki. Przetestuj
działanie programu w zależności od wartości parametru. Sprawdź kolejno wartości od
0 do 8 (rysunek 12.10). Dla ColorIndex=5 komórki w zakresie od A1 do H1 zostały oto-
czone grubą obwódką w kolorze niebieskim (rysunek 12.11).
Rysunek 12.10.
Została zmieniona
wartość parametru
odpowiadającego
za kolor linii
Rysunek 12.11.
Obwódka spełnia
wszystkie wymagania
Funkcje
Pisząc program w VBA, możemy korzystać zarówno z metod i instrukcji języka VBA, jak
i funkcji arkusza Microsoft Excel. W szybkim wybraniu odpowiedniej funkcji może
okazać się pomocna tabela 12.2.
Tabela 12.2. Wybrane funkcje

Nazwa Opis
Abs Zwraca wartość bezwzględną
Arccos Zwraca wartość arcus cosinus
Arccosec Zwraca wartość arcus cosecans
Arccotan Zwraca wartość arcus cotangens
Arcsec Zwraca wartość arcus secans
Arcsin Zwraca wartość arcus sinus
Asc Zwraca kod ASCII pierwszego znaku w ciągu
Atn Zwraca wartość arcus tangens
CallByName Wykonuje metodę albo ustawia lub zwraca wartość właściwości
CBool Przekształca wyrażenie na typ danych Boolean
CByte Przekształca wyrażenie na typ danych Byte
CCur Przekształca wyrażenie na typ danych Currency
CDate Przekształca wyrażenie na typ danych Date
CDbl Przekształca wyrażenie na typ danych Double
CDec Przekształca wyrażenie na typ danych Decimal
Choose Wybiera wartość z listy argumentów i zwraca ją
Chr Przekształca kod znaku na znak
CInt Przekształca wyrażenie na typ danych Integer
CLng Przekształca wyrażenie na typ danych Long
Command Zwraca wydaną z linii poleceń komendę użytą do uruchomienia programu
Microsoft Visual Basic
Cos Zwraca wartość cosinusa liczby
Cosec Zwraca wartość 1/Sin(X)
Cotan Zwraca wartość 1/Tan(X)
CreateObject Tworzy obiekt OLE
CSng Przekształca wyrażenie na typ danych Single
CStr Przekształca wyrażenie na typ danych String
CurDir Zwraca ścieżkę bieżącego katalogu
CVar Przekształca wyrażenie na typ danych Variant
CVErr Zwraca błąd zdefiniowany przez użytkownika odpowiadający podanemu kodowi
Date Zwraca datę systemową
DateAdd Dodaje przedział czasu do danej typu Date
DateDiff Zwraca przedział czasu pomiędzy dwiema datami
DatePart Zwraca część daty
DateSerial Zamienia datę na liczbę
DateValue Zamienia ciąg znaków na datę
Tabela 12.2. Wybrane funkcje (ciąg dalszy)

Nazwa Opis
Day Zwraca dzień miesiąca na podstawie danej typu date
DDB Zwraca spadek wartości środka trwałego
Dir Zwraca nazwę pliku lub katalogu
DoEvents Zezwala systemowi operacyjnemu na obsługę zdarzeń
Environ Zwraca zmienne środowiskowe systemu operacyjnego
EOF Zwraca wartość True po osiągnięciu końca pliku tekstowego
Error Zwraca komunikat o błędzie odpowiadający danemu kodowi
Exp Zwraca wartość funkcji wykładniczej
FileAttr Zwraca atrybuty pliku
FileDateTime Zwraca datę i godzinę modyfikacji pliku tekstowego
FileLen Zwraca długość pliku mierzoną w bajtach
Filter Zwraca podzbiór tablicy łańcuchów znaków z uwzględnieniem filtru
Format Wyświetla wyrażenie w określonym formacie
FormatCurrency Zwraca wyrażenie sformatowane z systemowym znakiem waluty przy wykorzystaniu
symbolu waluty ustawionego w Panelu sterowania
FormatDateTime Zwraca wyrażenie sformatowane jako data i godzina
FormatNumber Zwraca wyrażenie sformatowane jako liczba
FormatPercent Zwraca wyrażenie sformatowane jako procent
FreeFile Zwraca kolejny dostępny numer pliku
FV Zwraca przyszłą wartość rocznej spłaty
GetAllSettings Zwraca listę zasadniczych ustawień i ich wartości (oryginalnie tworzonych
za pomocą funkcji SaveSetting) odczytanych z wejścia aplikacji w rejestrze
Windows (a w komputerach Macintosh z pliku inicjalizującego aplikacje)
GetAttr Zwraca liczbę całkowitą reprezentującą atrybuty pliku, katalogu lub folderu
GetObject Pobiera obiekt OLE z pliku
GetSetting Zwraca wartość odczytaną z ustawień klucza wejścia aplikacji w rejestrze Windows
HArccos Zwraca wartość odwrotny cosinus hiperboliczny
HArccosec Zwraca wartość odwrotny cosecans hiperboliczny
HArccotan Zwraca wartość odwrotny cotangens hiperboliczny
HArcsec Zwraca wartość odwrotny secans hiperboliczny
HArcsin Zwraca wartość odwrotny sinus hiperboliczny
HArctan Zwraca wartość odwrotny tangens hiperboliczny
HCos Zwraca wartość cosinus hiperboliczny
HCosec Zwraca wartość cosecans hiperboliczny
HCotan Zwraca wartość cotangens hiperboliczny
Hex Przekształca liczbę decymalną na heksadecymalną
Hour Zwraca liczbę całkowitą z przedziału od 0 do 23 włącznie, reprezentującą godzinę

Nazwa Opis
HSec Zwraca wartość secans hiperboliczny
HSin Zwraca wartość sinus hiperboliczny
HTan Zwraca wartość tangens hiperboliczny
IIf Wylicza wyrażenie i zwraca jedną z dwóch części wyniku zależnie od wartości
wyrażenia
Input Zwraca ciąg zawierający znaki z pliku otworzonego w trybie Input lub Binary
InputBox Wyświetla okno dialogowe, którego pojawienie się wstrzymuje działanie
programu aż do wpisania danych przez użytkownika i kliknięcia przycisku OK.
Zwraca ciąg zawierający dane wpisane w polu tekstowym
InStr Zwraca pozycję, na której w ciągu znaków po raz pierwszy wystąpił inny ciąg znaków
InStrRev Zwraca pozycję, na której w ciągu znaków po raz pierwszy wystąpił inny ciąg
znaków. Sprawdzanie jest wykonywane od końca
Int, Fix Zwraca część całkowitą liczby
IPmt Zwraca kwotę odsetek dla określonego okresu spłaty
IRR Zwraca wewnętrzną stopę zwrotu dla ciągu przepływów gotówkowych
IsArray Zwraca wartość True, jeśli zmienna jest tablicą
IsDate Zwraca wartość True, jeśli zmienna jest typu Date
IsEmpty Zwraca wartość True, jeśli zmienna nie została zainicjalizowana
IsError Zwraca wartość True, jeśli wyrażenie jest daną typu Error
IsMissing Zwraca wartość True, jeśli do procedury nie przekazano opcjonalnego parametru
IsNull Zwraca wartość True, jeśli wyrażenie zawiera wartość Null
IsNumeric Zwraca wartość True, jeśli wyrażenie może być przedstawione jako liczba
IsObject Zwraca wartość True, jeśli w wyrażeniu występuje odwołanie do obiektu OLE
Join Zwraca ciąg utworzony przez połączenie łańcuchów zapisanych w tablicy
LBound Zwraca najmniejszy indeks tablicy
LCase Zwraca łańcuch znaków zapisany małymi literami
Left Zwraca określoną liczbę znaków, licząc od lewej strony analizowanego ciągu
Len Zwraca liczbę znaków w łańcuchu znaków
Loc Zwraca bieżące położenie pozycji odczytu/zapisu w otwartym pliku
LOF Zwraca liczbę bajtów otwartego pliku tekstowego
Log Zwraca logarytm naturalny z liczby
LTrim Zwraca ciąg zawierający kopię wyspecyfikowanego ciągu bez początkowych spacji
MacID Konwertuje 4-znakową stałą na wartość, która może być użyta przez Dir, Kill,
Shell i AppActivate. Funkcję można zastosować tylko na komputerach Macintosh
MacScript Wykonuje skrypt AppleScript i zwraca wartość zwróconą przez skrypt
Mid Zwraca określoną liczbę znaków z łańcucha
Minute Zwraca liczbę formatu Variant (Integer) z przedziału od 0 do 59, równą liczbie
minut danej godziny

Nazwa Opis
MIRR Zwraca zmodyfikowaną wewnętrzną stopę zwrotu dla ciągu okresowych
przepływów gotówkowych
Month Zwraca liczbę formatu Variant (Integer) z przedziału od 1 do 12, równą
numerowi kolejnego miesiąca w roku
MonthName Zwraca nazwę miesiąca
MsgBox Wyświetla okno komunikatu, którego pojawienie się powoduje wstrzymanie
wykonywania programu aż do kliknięcia przycisku widocznego w oknie
Now Zwraca bieżącą datę i godzinę systemową
NPer Zwraca liczbę okresów spłaty
NPV Zwraca obecną wartość inwestycji netto
Oct Przekształca liczbę decymalną na oktalną
Partition Zwraca łańcuch znaków reprezentujący zakres, do którego należy wartość
Pmt Zwraca kwotę spłaty pożyczki
PPmt Zwraca wartość kapitału dla raty pożyczki
PV Zwraca obecną wartość inwestycji
QBColor Zwraca wartość typu Long określającą kod RGB koloru o podanym numerze
Rate Zwraca oprocentowanie dla okresu spłaty pożyczki
Replace Zwraca łańcuch znaków, w którym określony łańcuch jest zastępowany innym
łańcuchem znaków
RGB Zwraca wartość typu Long określającą kod RGB koloru
Right Zwraca określoną liczbę znaków, licząc od prawej strony analizowanego ciągu
Rnd Zwraca liczbę losową z zakresu od 0 do 1
Round Zwraca liczbę zaokrągloną do zadanej liczby miejsc dziesiętnych
RTrim Zwraca ciąg zawierający kopię wyspecyfikowanego ciągu bez końcowych spacji
Sec Zwraca wartość 1/Cos(X)
Second Zwraca liczbę formatu Variant (Integer) z przedziału od 0 do 59, równą liczbie
sekund danej godziny
Seek Zwraca bieżącą pozycję w pliku
Sgn Zwraca liczbę całkowitą reprezentującą znak liczby
Shell Uruchamia program wykonywalny i, jeśli program został wykonany,
zwraca wartość typu Variant (Double) reprezentującą ID zadania programu.
W przeciwnym razie zwraca zero
Sin Zwraca sinus liczby
SLN Zwraca amortyzację środka trwałego za dany okres
Space Zwraca łańcuch znaków zawierający określoną liczbę spacji
Spc Wraz z poleceniami Print # lub Print ustawia pozycję wydruku
Split Zwraca jednowymiarową tablicę zawierającą łańcuchy znaków powstałe wskutek
podzielenia wejściowego łańcucha znaków na mniejsze części (na podstawie
określonego znaku rozdzielającego)

Nazwa Opis
Sqr Zwraca pierwiastek kwadratowy z liczby
Str Zamienia liczbę na znaki i zwraca ją ujętą w cudzysłów
StrComp Zwraca wartość reprezentującą wynik porównania łańcuchów znaków
StrConv Zwraca łańcuch znaków po konwersji
String Zwraca łańcuch znaków składający się z powtarzających się znaków
StrReverse Zwraca odwrócony łańcuch znaków
Switch Ocenia wartość ciągu wyrażeń typu Boolean i zwraca wartość związaną
z pierwszym wyrażeniem, które ma wartość True
SYD Zwraca amortyzację środka trwałego za dany okres metodą sumy cyfr wszystkich
lat amortyzacji
Tab Ustawia pozycję wydruku podczas drukowania do pliku
Tan Zwraca tangens liczby
Time Zwraca bieżącą datę i godzinę systemową
Timer Zwraca liczbę sekund, jaka upłynęła od północy
TimeSerial Zwraca liczbę całkowitą reprezentującą czas dla podanej godziny, minuty
i sekundy
TimeValue Przekształca łańcuch znaków na liczbę reprezentującą czas
Trim s Zwraca ciąg zawierający kopię wyspecyfikowanego ciągu zarówno bez
początkowych, jak i końcowych spacji
TypeName Zwraca łańcuch znaków opisujący typ danych zmiennej
UBound Zwraca największy indeks tablicy
UCase Przekształca łańcuch znaków na wielkie litery
Val Zwraca pierwszą liczbę napotkaną w łańcuchu znaków
VarType Zwraca wartość reprezentującą podtyp zmiennej
Weekday Zwraca liczbę reprezentującą dzień tygodnia
WeekdayName Zwraca łańcuch znaków reprezentujący dzień tygodnia
Year Zwraca rok na podstawie danej typu Date
Przykład 193.
Napisz program, którego zastosowanie pozwoli przeliczać liczby decymalne na hek-
sadecymalne.
1. W tabeli 12.2 odszukaj funkcję konwertującą liczbę decymalną na heksadecymalną.
3. W wyszukiwarce Google wpisz hasło HEX VBA EXCEL 2016.
4. W wynikach wyszukiwania (rysunek 12.12) kliknij odsyłacz do artykułu
963zt96e(v=vs.90).aspx opublikowanego w msdn.microsoft.com.
Rysunek 12.12.
Wybieramy wynik
dotyczący Office 2016
5. W pomocy dotyczącej funkcji odszukaj przykład (rysunek 12.13).
Rysunek 12.13.
metody
6. Zaznacz i skopiuj do schowka przykład zastosowania metody.

7. Wyświetl okno do wpisywania kodu. W tym celu naciśnij klawisz F7.
8. Korzystając z zawartości schowka, wpisz kod programu (rysunek 12.14).
W drugiej linii zostały zadeklarowane dwie zmienne: H i O. Pierwsza służy
do przechowywania wyniku konwersji. Druga służy do wczytania liczby
dziesiętnej. W trzeciej linii znajduje się instrukcja, której zastosowanie
powoduje wyświetlenie okna z prośbą o wpisanie liczby przeznaczonej
do konwersji. W kolejnej linii zastosowanie funkcji Hex doprowadza
do zamiany liczby dziesiętnej na szesnastkową. W przedostatniej linii
programu jest wyświetlane okno z informacją o wpisanej liczbie i wyniku
konwersji. Uruchom program.
Rysunek 12.14. Kod programu
9. Zostało wyświetlone okno z prośbą o wpisanie liczby przeznaczonej

do konwersji (rysunek 12.15). Wpisz liczbę 16.
Rysunek 12.15.
Okno do
wprowadzania
danych

11. Program wyliczył wartość liczby heksadecymalnej i wynik konwersji został
wyświetlony w oknie (rysunek 12.16).
Rysunek 12.16.
Wynik konwersji
W tabeli 12.3 znajduje się siedemnaście liczb dziesiętnych oraz ich szesnastko-
wych odpowiedników.
Tabela 12.3. Liczby dziesiętne D i szesnastkowe H

D 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
H 0 1 2 3 4 5 6 7 8 9 A B C D E F 10
Przykład 194.
Napisz program, którego zastosowanie pozwoli wyświetlić datę i czas systemowy.
1. W tabeli 12.2 odszukaj funkcję, której zastosowanie umożliwia pobranie
z systemu daty i czasu.
3. W polu wyszukiwania wpisz Now.
4. Kliknij odsyłacz do artykułu https://msdn.microsoft.com/en-
us/library/ee634891.aspx (rysunek 12.17).
Rysunek 12.17.
Fragment spisu treści
artykułu z informacjami
na temat funkcji

(rysunek 12.18). W sekcji Syntax znajduje się przykład zastosowania funkcji.
Rysunek 12.18.
Podstawowe
informacje o funkcji

8. Wpisz kod programu (rysunek 12.19). Po wykonaniu linii programu
zawierającej między innymi słowo Jest zostanie wyświetlone okno z datą
i czasem systemowym. Uruchom program.
Rysunek 12.19.
Kod programu
9. Zostało wyświetlone okno z aktualną datą i czasem systemowym

(rysunek 12.20).
Rysunek 12.20.
Data i czas zegara
systemowego
Instrukcje
W tabeli 12.4 znajdziesz informacje o wbudowanych instrukcjach VBA. Korzystali-
śmy z nich najczęściej w poprzednich rozdziałach książki. Pominę więc szczegółowe
wyjaśnienia.
Tabela 12.4. Wybrane instrukcje

Nazwa Opis
AppActivate Uaktywnienie okna aplikacji
Beep Wygenerowanie dźwięku
Call Wywołanie procedury
ChDir Zmiana bieżącego katalogu
ChDrive Zmiana bieżącego napędu
Close Zamknięcie pliku
Const Deklaracja stałej
Date Ustawienie daty systemowej
Declare Deklaracja odwołania do procedury zewnętrznej w bibliotece DLL
DefBool Ustawienie na Boolean domyślnego typu danych dla zmiennych rozpoczynających
się od określonej litery
DefByte Ustawienie na Byte domyślnego typu danych dla zmiennych rozpoczynających się
od określonej litery
DefCur Ustawienie na Currency domyślnego typu danych dla zmiennych
rozpoczynających się od określonej litery
DefDate Ustawienie na Date domyślnego typu danych dla zmiennych rozpoczynających się
DefDbl Ustawienie na Double domyślnego typu danych dla zmiennych rozpoczynających
DefDec Ustawienie na Decimal domyślnego typu danych dla zmiennych rozpoczynających
Tabela 12.4. Wybrane instrukcje (ciąg dalszy)

Nazwa Opis
DefInt Ustawienie na Integer domyślnego typu danych dla zmiennych rozpoczynających
DefLng Ustawienie na Long domyślnego typu danych dla zmiennych rozpoczynających się
DefObj Ustawienie na Object domyślnego typu danych dla zmiennych rozpoczynających
DefSng Ustawienie na Single domyślnego typu danych dla zmiennych rozpoczynających
DefStr Ustawienie na String domyślnego typu danych dla zmiennych rozpoczynających
DefVar Ustawienie na Variant domyślnego typu danych dla zmiennych rozpoczynających
DeleteSetting Usunięcie sekcji lub ustawienia klucza w rejestrze Windows
Dim Deklaracja zmiennych i ich typów danych
Do...Loop Pętla programowa
End Zakończenie działania programu. W połączeniu z innymi słowami kluczowymi
oznacza zakończenie bloku, np. End Sub — zakończenie procedury
Enum Deklaracja typu wyliczeniowego
Erase Ponowne zainicjowanie elementów tablicy o ustalonych rozmiarach i zwolnienie
obszaru przydzielonego do przechowywania danych w przypadku tablic
dynamicznych
Error Symulacja błędu o zadanym numerze
Event Deklaracja zdarzenia zadeklarowanego przez użytkownika
Exit Do Wyjście z bloku pętli Do...Loop. Instrukcja może być używana tylko wewnątrz
pętli Do...Loop. Wyjście z pętli powoduje przekazanie sterowania do instrukcji
znajdującej się bezpośrednio za instrukcją pętli
Exit For Wyjście z bloku pętli For...Next lub For Each...Next. Instrukcja może być
stosowana tylko wewnątrz pętli For...Next lub For Each...Next. Wyjście z pętli
powoduje przekazanie sterowania do instrukcji znajdującej się bezpośrednio
za instrukcją pętli
Exit Function Wyjście z funkcji. Wyjście z funkcji powoduje przekazanie sterowania
do instrukcji znajdującej się bezpośrednio za wywołaniem funkcji
Exit Property Wyjście z procedury Property. Wyjście z procedury Property powoduje przekazanie
sterowania do instrukcji znajdującej się bezpośrednio za instrukcją, w której
wywołano procedurę Property
Exit Sub Wyjście z procedury Sub. Wyjście z procedury Sub powoduje przekazanie
sterowania do instrukcji znajdującej się bezpośrednio za instrukcją, w której
wywołano procedurę Sub
FileCopy Skopiowanie pliku
For Each...Next Pętla programowa. Powtórzenie grupy instrukcji dla każdego elementu w tablicy
lub kolekcji

Nazwa Opis
For...Next Pętla programowa. Powtórzenie grupy instrukcji określoną liczbę razy
Function Deklaracja nazwy i argumentów funkcji
Get Odczyt danych z otwartego pliku. Dane są przypisywane zmiennej
GoSub...Return Skok do podprogramu i powrót z niego wewnątrz procedury
GoTo Skok bezwarunkowy do wyspecyfikowanej linii wewnątrz procedury
If...Then...Else Uzależnione od sprawdzanego warunku wykonanie grupy instrukcji
Implements Określenie interfejsu lub klasy, która ma być zaimplementowana w module klasy
Input # Odczyt danych z sekwencyjnego pliku i przypisanie ich zmiennej
Kill Usunięcie pliku z dysku
Let Przypisanie wartości wyrażenia zmiennej lub właściwości
Line Input # Odczyt pojedynczej linii z otwartego pliku tekstowego i przypisanie jej zmiennej
typu String
Load Załadowanie obiektu bez jego wyświetlania
Lock, Unlocks Sterowanie dostępem przez inne procesy do całego lub części pliku otworzonego
przy użyciu polecenia Open
LSet Wyrównanie do lewej ciągu znaków zmiennej tekstowej
Mid Zastąpienie znaków w ciągu znaków
MkDir Utworzenie katalogu
Name Zmiana nazwy pliku lub katalogu
On Error Przekazanie sterowania do procedury obsługi błędów i określenie położenia
podprogramu w procedurze. Polecenie może być używane do zablokowania
podprogramu obsługi błędów
On...GoSub, Rozgałęzienie programu w zależności od wartości badanego wyrażenia.
On...GoTos Skok nastąpi do jednej z kilku wyspecyfikowanych linii programu
Open Otworzenie pliku tekstowego
Option Base Deklaracja wartości dolnego ograniczenia indeksu tablicy
Option Compare Deklaracja domyślnego trybu porównywania ciągu znaków
Option Explicit Wymuszenie deklaracji wszystkich zmiennych w module
Option Private Zadeklarowanie całego modułu jako prywatnego
Print # Zapisanie sformatowanych do wyświetlania danych do pliku sekwencyjnego
Private Deklaracja lokalnej tablicy lub zmiennej
Property Get Deklaracja nazw i argumentów procedury Property Get
Property Let Deklaracja nazw i argumentów procedury Property Let
Property Set Deklaracja nazw i argumentów procedury Property Set
Public Deklaracja publicznej tablicy lub zmiennej
Put Zapisanie zmiennej do pliku tekstowego
RaiseEvent Wygenerowanie zdarzenia zadeklarowanego na poziomie modułu wewnątrz klasy,
formularza lub dokumentu

Nazwa Opis
Randomize Zainicjowanie generatora liczb losowych
ReDim Zmiana wymiarów tablicy
Rem Komentarz. Oznaczenie równoważne z apostrofem
Reset Zamknięcie wszystkich plików dyskowych otwartych przy wykorzystaniu
polecenia Open
Resume Wznowienie wykonywania programu po zakończeniu procedury obsługi błędu
RmDir Usunięcie katalogu lub folderu
RSet Wyrównanie ciągu znaków w zmiennej tekstowej do prawej
SaveSetting Zapisanie lub utworzenie zapisu w rejestrze Windows
Seek Ustawienie pozycji do następnej operacji zapisu/odczytu w pliku otwartym przy
użyciu polecania Open
Select Case Warunkowe wykonanie jednej lub kilku grup instrukcji
SendKeys Wysłanie jednego lub więcej kodów wciśniętych klawiszy do aktywnego okna.
Symuluje to pisanie tekstu z klawiatury
Set Przypisanie adresu obiektu zmiennej lub właściwości
SetAttr Ustawienie atrybutów pliku
Static Zadeklarowanie zmiennych na poziomie procedury. Wartości będą
przechowywane przez zmienne przez cały czas działania kodu
Stop Zatrzymanie wykonywania programu
Sub Deklaracja nazwy, argumentów i kodu procedury Sub
Time Ustawienie godziny systemowej
Type Definicja typu danych użytkownika
Unload Usunięcie obiektu z pamięci
While...Wend Pętla programowa. Zawarte w niej instrukcje są powtarzane tak długo, jak długo
warunek ma wartość True
Width # Ustawienie wyjściowej szerokości pliku otworzonego przy wykorzystaniu
polecenia Open
With Określenie wielu właściwości obiektu
Write # Zapis danych do pliku sekwencyjnego
Operatory
Operatory arytmetyczne
Operatory arytmetyczne (tabela 12.5) służą do wykonywania podstawowych działań
arytmetycznych.
Tabela 12.5. Operatory arytmetyczne

Operator Opis
+ Dodawanie
\ Dzielenie. Zwraca wynik w formacie Integer
/ Dzielenie. Zwraca wynik w postaci liczby zmiennoprzecinkowej
* Mnożenie
- Odejmowanie
^ Potęgowanie
Mod Reszta z dzielenia
Przykład 195.
Napisz program, którego zastosowanie pozwoli wyliczyć resztę z dzielenia liczby
przez siedem.
1. W tabeli 12.5 odszukaj operator wyliczający resztę z dzielenia.
2. Załaduj przeglądarkę internetową.
3. W pasku adresu wpisz adres http://msdn.microsoft.com/en-US/office.
4. W polu wyszukiwarki wpisz termin mod (rysunek 12.21). Kliknij ikonę lupki.
Rysunek 12.21.
Serwis msdn jest
wyposażony w wygodną
wyszukiwarkę
5. Kliknij odsyłacz do artykułu MOD-function-9B6CD169-B6EE-406A-A97B-

EDF2A9DC24F3 (rysunek 12.22).
Rysunek 12.22.
Odsyłacz do artykułu

(rysunek 12.23). W sekcji Example znajduje się przykład zastosowania operatora.
9. Wyświetl okno wpisywania kodu. Naciśnij klawisz F7.
Rysunek 12.23. Podstawowe informacje o operatorze
10. Wpisz kod programu (rysunek 12.24). W drugiej linii programu jest
wyświetlane okno z prośbą o wpisanie dzielnej. Wprowadzona liczba jest
przypisywana zmiennej number1. W drugiej linii programu zmiennej number2
jest przypisywana liczba 7. W kolejnej linii jest wyliczana reszta z dzielenia
zmiennej number1 przez zmienną number2. W przedostatniej linii znajduje się
polecenie, którego wykonanie umożliwi wyświetlenie wyniku.
Rysunek 12.24. Kod programu

12. Zostało wyświetlone okno umożliwiające wpisanie dzielnej (rysunek 12.25).
Rysunek 12.25.
Okno do
wprowadzania
liczby, której reszta
z dzielenia przez
siedem ma zostać
wyliczona

Rysunek 12.26.
Wynik
Operatory porównania
Operatory porównania (tabela 12.6) umożliwiają porównywanie wartości liczb,
zmiennych, wyników zwracanych przez funkcje itp. Jeżeli relacja opisana operatorem
jest prawdziwa, wówczas jest zwracana wartość True. Jeżeli relacja opisana operato-
rem nie zachodzi, jest zwracana wartość False. Gdy jedna z porównywanych wielko-
ści ma wartość Null, jest zwracana wartość Null. Operatory można wykorzystywać do
konstruowania warunków.
Tabela 12.6. Operatory porównania

Operator Opis
<= Mniejszy lub równy. Zwraca wartość True, jeżeli wyrażenie1 <= wyrażenie2.
Zwraca wartość False, jeżeli wyrażenie1 > wyrażenie2. Zwraca wartość Null,
jeżeli wyrażenie1 lub wyrażenie2 = Null
< Mniejszy niż. Zwraca wartość True, jeżeli wyrażenie1 < wyrażenie2. Zwraca
wartość False, jeżeli wyrażenie1 >= wyrażenie2. Zwraca wartość Null,
<> Nierówny. Zwraca wartość True, jeżeli wyrażenie1 <> wyrażenie2. Zwraca wartość
False, jeżeli wyrażenie1 = wyrażenie2. Zwraca wartość Null, jeżeli wyrażenie1
lub wyrażenie2 = Null
= Równy. Zwraca wartość True, jeżeli wyrażenie1 = wyrażenie2. Zwraca wartość
False, jeżeli wyrażenie1 <> wyrażenie2. Zwraca wartość Null, jeżeli wyrażenie1
lub wyrażenie2 = Null
Tabela 12.6. Operatory porównania (ciąg dalszy)

Operator Opis
>= Większy lub równy. Zwraca wartość True, jeżeli wyrażenie1 >= wyrażenie2.
Zwraca wartość False, jeżeli wyrażenie1 < wyrażenie2. Zwraca wartość Null,
> Większy niż. Zwraca wartość True, jeżeli wyrażenie1 > wyrażenie2. Zwraca
wartość False, jeżeli wyrażenie1 <= wyrażenie2. Zwraca wartość Null, jeżeli
wyrażenie1 lub wyrażenie2 = Null
Przykład 196.
Napisz program, którego zastosowanie pozwoli na podawanie prowizji w zależności
od wysokości sprzedaży. Dane znajdują się w tabeli 12.7.
Tabela 12.7. Dane do przykładu 196

Sprzedaż Prowizja
0 – 25 000 0,10
25 001 – 50 000 0,12
50 001 – 75 000 0,14
75 001 i więcej 0,20

3. Wpisz kod programu (rysunek 12.27). W trzeciej linii programu jest
wyświetlane okno z prośbą o wpisanie wyników sprzedaży. Wprowadzona
liczba jest przypisywana zmiennej sprz. W czwartej linii programu rozpoczyna
się sprawdzanie wartości zmiennej sprz. Tabela 12.7 nie obejmuje wartości
mniejszych od zera. Jeżeli jednak wskutek pomyłki ktoś wpisze wartość
mniejszą od zera, zostanie wyświetlona informacja, a nie komunikat o błędzie.
Gdy wartość zmiennej sprz będzie większa od zera, ale mniejsza od 0.1,
zostanie spełniony warunek zapisany w linii piątej, a zmiennej prow —
przypisana wartość 0.1. Gdy wartość zmiennej sprz będzie większa lub równa
25001, zostanie spełniony warunek zapisany w linii szóstej, a zmiennej prow —
przypisana wartość 0.12. Gdy wartość zmiennej sprz będzie większa lub równa
50001, zostanie spełniony warunek zapisany w linii siódmej, a zmiennej prow
— przypisana wartość 0.14. Gdy wartość zmiennej sprz będzie większa lub
równa 75001, zostanie spełniony warunek zapisany w linii ósmej, a zmiennej
prow — przypisana wartość 0.2. Duże wartości zmiennej sprz spełniają więcej
niż jeden warunek. W takim przypadku zmiennej prow są przypisywane coraz
wyższe wartości. W przedostatniej linii jest wyświetlany wynik.
Rysunek 12.27.
Kod programu
4. Uruchom program.
5. Zostało wyświetlone okno umożliwiające wpisanie wyników sprzedaży
(rysunek 12.28).
Rysunek 12.28.
Okno do
wprowadzania
wysokości sprzedaży

Rysunek 12.29.
Porównaj wynik
z tabelą 12.7
Operator konkatenacji
Operator konkatenacji (tabela 12.8) może być wykorzystywany np. do wyświetlania
w tym samym oknie opisu i wyniku, czyli wartości zmiennej.
Tabela 12.8. Operator konkatenacji

Operator Opis
& Łączenie ciągów znaków. Wyrażenie "Miś" & " Uszatek" zwraca "Miś Uszatek".
Wyrażenie "Cena " & 999 & " Euro" zwraca "Cena 999 Euro"
Operator + powoduje sumowanie liczb.
Przykład 197.
Napisz program, którego zastosowanie pozwoli wczytać zawartość komórek A1 i B1,
połączyć je i zapisać w komórce C1.
3. Wpisz kod programu (rysunek 12.30). W trzeciej linii programu zmiennej
Lewa jest przypisywana zawartość komórki A1. W czwartej linii programu
zmiennej Prawa jest przypisywana zawartość komórki B1. W linii kolejnej
zawartość zmiennych jest łączona i wstawiana do komórki C1.
Rysunek 12.30.
Kod programu
4. Przygotuj dane testowe (rysunek 12.31).
Rysunek 12.31.
W oddzielnych
komórkach zapisano
kod pocztowy i nazwę
miejscowości
5. Uruchom program.
6. Ponownie obejrzyj arkusz Excela (rysunek 12.32).
Rysunek 12.32.
W komórce C1 znajdują
się połączone dane
z komórek A1 i B1

Zmodyfikuj program z przykładu 197. tak, aby pomiędzy łączonymi ciągami znaków
została wstawiona spacja (rysunek 12.33).
Rysunek 12.33.
W komórce C1 ciągi
z komórek A1 i B1 zostały
oddzielone spacją
Operatory logiczne
Operatory logiczne (tabela 12.9) umożliwiają zbudowanie formuły logicznej.
Tabela 12.9. Operatory logiczne

Operator Opis
And Iloczyn logiczny
Eqv Równość
Imp Implikacja
Not Negacja
Or Suma logiczna
Xor Nierównoważność logiczna dwóch wyrażeń
Przykład 199.
Napisz program, którego zastosowanie umożliwi podawanie w komórce C1 sumy lo-
gicznej wartości zapisanych w komórkach A1 oraz B1.
2. W komórce A1 wpisz 0.
3. W komórce B1 wpisz 1.
5. Wpisz kod programu (rysunek 12.34). Zmienne A, B oraz Y zostały zadeklarowane
jako zmienne typu logicznego. W trzeciej linii programu zmiennej A jest
przypisywana wartość odczytana z komórki A1 arkusza Excel. W czwartej
linii programu zmiennej B jest przypisywana wartość odczytana z komórki
B1 arkusza Excela. W linii piątej jest wyznaczana suma logiczna zmiennych A
i B. Wynik jest przypisywany zmiennej Y. W przedostatniej linii wartość
zmiennej Y jest wstawiana do komórki C1.
Rysunek 12.34.
Program
6. Uruchom program.
7. Wyświetl arkusz kalkulacyjny Excel. W komórce C1 jest widoczny wynik
sumy logicznej komórek A1 i B1 (rysunek 12.35).
Rysunek 12.35.
W komórce C1
nie ma formuły,
a jest wpisana wartość
8. Sprawdź, czy program działa poprawnie dla wartości podanych w tabeli 12.10.
Tabela 12.10. Tablica prawdy funkcji Or

A B A Or B
0 0 0
0 1 1
1 0 1
1 1 1
Podsumowanie
 Aby uzyskać informacje o poleceniach języka VBA, uruchom arkusz Excela.
Wyświetl okno edytora VBA. Naciśnij klawisz F1. W polu widocznym
w lewym górnym rogu okna pomocy wpisz szukany termin. Naciśnij klawisz
Enter. Kliknij odsyłacz do szczegółowych informacji.
Rozdział 13.
Funkcje arkuszowe
 Jak korzystać z funkcji arkuszowych w programach VBA.
Excel 2016 został w stosunku do swego poprzednika wzbogacony o nowe funkcje. Są

one dostępne dla piszących programy w VBA. Wraz z funkcjami dostępnymi w pro-
gramie Excel 2016 stanowią one potężny zestaw narzędzi. Ułatwia to znacznie korzy-
stanie z VBA osobom zaznajomionym z funkcjami arkuszowymi.
Spośród funkcji arkuszowych w VBA nie są dostępne te, które mają swoje dokładne
odpowiedniki wśród funkcji wbudowanych.
Wykorzystanie w VBA funkcji arkuszowych wymaga znajomości ich angielskich

nazw. Na szczęście VBA jest wyposażony w elektronicznego suflera, który wyświetla
listę dostępnych funkcji.
Drugie utrudnienie to konieczność poprzedzenia nazwy funkcji arkuszowej poleceniem

Applicaton.WorksheetFunction.
Przykład 200.
Wyświetl listę dostępnych funkcji arkuszowych. Odszukaj i wstaw do programu
funkcję odpowiedzialną za konwersję liczb rzymskich na arabskie.
2. Uruchom edytor VBA.
3. Wpisz początek programu (rysunek 13.1). Zmiennej A zostanie przypisana
wartość wyliczona przez funkcję arkuszową. Wpisz ciąg znaków
A = Application.WorksheetFunction. i zaczekaj, aż zostanie wyświetlone
okno elektronicznego suflera.
Rysunek 13.1.
Po wpisaniu kropki
po słowie
WorksheetFunction
jest wyświetlana lista
funkcji
4. Za konwersję liczb rzymskich na arabskie jest odpowiedzialna funkcja Arabic.

Kliknij ją (rysunek 13.2).
Rysunek 13.2.
Niestety okno z listą
funkcji jest dosyć
małe i jego zawartość
należy przewijać
5. Funkcja została dodana do programu (rysunek 13.3). Zmiennej A jest

przypisywana wartość wyliczona przez funkcję Arabic. Wynik jest wpisywany
do komórki B2.
Rysunek 13.3.
Wybrana z listy nazwa
funkcji została dodana
do programu.
6. Dopisz argument, który funkcja ma zamieniać na liczbę arabską (rysunek 13.4).

W przykładzie będzie to XXI.
Rysunek 13.4.
Dana jest wpisana do
programu. Wyliczona
wartość jest przypisywana
zmiennej A.
Na rysunku 13.5 pokazano wersję programu, która konwertuje liczbę rzymską XXI na
arabską. Wartość jest przypisywana zmiennej A. Program jest poprawny składniowo,
działa, ale wynik pozostaje w jego wnętrzu. Jeżeli taka sekwencja poleceń zostanie
wewnątrz dłuższego kodu, nie będzie robiła nic za wyjątkiem spowalniania działania.
Rozdział 13.  Funkcje arkuszowe 347
Rysunek 13.5.
Niestety okno z listą
funkcji jest dosyć małe
i jego zawartość
należy przewijać

Zmodyfikuj program z przykładu 200. tak, aby dane były wczytywane w komórki A2,
zaś wynik publikowany w B2 (rysunek 13.6).
Rysunek 13.6.
A2 — tu można wpisać
liczbę do konwersji.
B2 — w tej komórce
zostanie wyświetlony
wynik
Odpowiedniki funkcji arkuszowych w VBA

Ogólna postać wywołania funkcji arkuszowej przedstawia się więc następująco:
zmienna = Application.WorksheetFunction.nazwaFunkcji(argumenty)
Na tym na szczęście koniec komplikacji. W tabeli 13.1 znajdują się najczęściej wybie-
rane funkcje Excela i ich odpowiedniki w VBA
Największym problemem w przypadku korzystania z funkcji arkuszowych jest to, że do

ich wywołania w programie trzeba znać nazwę, jaką mają w VBA. Na to, że funkcji ACOS
odpowiada Application.WorksheetFunction.Acos, wpaść łatwo, ale że funkcji BD.ILE.
REKORDÓW odpowiada Application.WorksheetFunction.DCount już trudniej…
Tabela 13.1. Wybrane funkcje arkuszowe i ich odpowiedniki w VBA

Funkcja arkuszowa Nazwa w VBA
ACOS Application.WorksheetFunction.Acos
ACOSH Application.WorksheetFunction.Acosh
ASIN Application.WorksheetFunction.Asin
ASINH Application.WorksheetFunction.Asinh
ATAN2 Application.WorksheetFunction.Atan2
ATANH Application.WorksheetFunction.Atanh
BAHTTEXT Application.WorksheetFunction.BahtText
BD.ILE.REKORDÓW Application.WorksheetFunction.DCount
BD.ILE.REKORÓW.A Application.WorksheetFunction.DCountA
BD.ILOCZYN Application.WorksheetFunction.DProduct
BD.MAX Application.WorksheetFunction.DMax
Tabela 13.1. Wybrane funkcje arkuszowe i ich odpowiedniki w VBA (ciąg dalszy)
BD.MIN Application.WorksheetFunction.DMin
BD.ODCH.STANDARD Application.WorksheetFunction.DStDev
BD.ODCH.STANDARD.POPUL Application.WorksheetFunction.DStDevP
BD.POLE Application.WorksheetFunction.DGet
BD.SUMA Application.WorksheetFunction.DSum
BD.ŚREDNIA Application.WorksheetFunction.DAverage
BD.WARIANCJA Application.WorksheetFunction.DVar
BD.WARIANCJA.POPUL Application.WorksheetFunction.DVarP
COS Cos
COSH Application.WorksheetFunction.Cosh
CZAS TimeSerial
CZAS.WARTOŚĆ CDate
CZĘSTOŚĆ Application.WorksheetFunction.Frequency
CZY.BŁ Application.WorksheetFunction.IsErr
CZY.BŁĄD Application.WorksheetFunction.IsError
CZY.BRAK Application.WorksheetFunction.IsNA
CZY.LICZBA Application.WorksheetFunction.IsNumber
CZY.LOGICZNA Application.WorksheetFunction.IsLogical
CZY.NIE.TEKST Application.WorksheetFunction.IsNonText
CZY.PUSTA IsEmpty
CZY.TEKST Application.WorksheetFunction.IsText
DATA DateSerial
DATA.WARTOŚĆ CDate
DB Application.WorksheetFunction.Db
DDB Application.WorksheetFunction.Ddb
DŁ Len
DNI.360 Application.WorksheetFunction.Days360
DZIEŃ Day
DZIEŃ.TYG Application.WorksheetFunction.Weekday
DZIŚ Date
EXP Exp
FRAGMENT.TEKSTU Mid
FV Application.WorksheetFunction.Fv
GODZINA Hour
ILE.LICZB Application.WorksheetFunction.Count
ILE.NIEPUSTYCH Application.WorksheetFunction.CountA
ILOCZYN Application.WorksheetFunction.Product
IMPT Application.WorksheetFunction.Ipmt
INDEKS Application.WorksheetFunction.Index
IRR Application.WorksheetFunction.Irr
ISPMT Application.WorksheetFunction.Ispmt
JEŻELI If
KOD Application.WorksheetFunction.Asc
KOMBINACJE Application.WorksheetFunction.Combin
KOWARIANCJA Application.WorksheetFunction.Covar
KURTOZA Application.WorksheetFunction.Kurt
KWARTYL Application.WorksheetFunction.Quartile
KWOTA Application.WorksheetFunction.Dollar
LEWY Left
LICZ.JEŻELI Application.WorksheetFunction.CountIf
LICZ.PUSTE Application.WorksheetFunction.CountBlank
LICZBA.CAŁK Int
LITERY.MAŁE LCase
LITERY.WIELKIE UCase
LN Application.WorksheetFunction.Ln
LOG Application.WorksheetFunction.Log
LOG10 Application.WorksheetFunction.Log10
LOS Rnd
LUB Application.WorksheetFunction.Or
MACIERZ.ILOCZYN Application.WorksheetFunction.MMult
MACIERZ.ODW Application.WorksheetFunction.Minverse
MAX Application.WorksheetFunction.Max
MAX.K Application.WorksheetFunction.Large
MEDIANA Application.WorksheetFunction.Median
MIESIĄC Month
MIN Application.WorksheetFunction.Min
MIN.K Application.WorksheetFunction.Small
MINUTA Minute
MIRR Application.WorksheetFunction.MIrr
MOD Mod
MODUŁ.LICZBY Abs
NACHYLENIE Application.WorksheetFunction.Slope
NIE Not
NORMALIZUJ Application.WorksheetFunction.Standardize
NPER Application.WorksheetFunction.NPer
NPV Application.WorksheetFunction.Npv
OCZYŚĆ Application.WorksheetFunction.Clean
ODCH.KWADRATOWE Application.WorksheetFunction.DevSq
ODCH.STANDARD.POPUL Application.WorksheetFunction.StDevP
ODCH.STANDARDOWE Application.WorksheetFunction.StDev
ODCH.ŚREDNIE Application.WorksheetFunction.AveDev
ODCIĘTA Application.WorksheetFunction.Intercept
ORAZ Application.WorksheetFunction.And
PEARSON Application.WorksheetFunction.Pearson
PERCENTYL Application.WorksheetFunction.Percentile
PERMUTACJE Application.WorksheetFunction.Permut
PI Application.WorksheetFunction.Pi
PIERWIASTEK Sqr
PMT Application.WorksheetFunction.Pmt
PODAJ.POZYCJĘ Application.WorksheetFunction.Match
PODSTAW Application.WorksheetFunction.Substitute
POTĘGA Application.WorksheetFunction.Power
POWT Application.WorksheetFunction.Rept
POZYCJA Application.WorksheetFunction.Rank
PPMT Application.WorksheetFunction.Ppmt
PRAWDPD Application.WorksheetFunction.Prob
PRAWY Right
PROCENT.POZYCJA Application.WorksheetFunction.PercentRank
PRÓG.ROZKŁAD.DWUM Application.WorksheetFunction.CritBinom
PRZESUNIĘCIE Offset
PV Application.WorksheetFunction.Pv
R.KWADRAT Application.WorksheetFunction.RSq
RADIANY Application.WorksheetFunction.Radians
RATE Application.WorksheetFunction.Rate
REGBŁSTD Application.WorksheetFunction.StEyx
REGEXPP Application.WorksheetFunction.LogEst
REGEXPW Application.WorksheetFunction.Growth
REGLINP Application.WorksheetFunction.LinEst
REGLINW Application.WorksheetFunction.Trend
REGLINX Application.WorksheetFunction.Forecast
ROK Year
ROZKŁAD.BETA Application.WorksheetFunction.BetaDist
ROZKŁAD.BETA.ODW Application.WorksheetFunction.BetaInv
ROZKŁAD.CHI Application.WorksheetFunction.ChiDist
ROZKŁAD.CHI.ODW Application.WorksheetFunction.ChiInv
ROZKŁAD.DWUM Application.WorksheetFunction.BinomDist
ROZKŁAD.DWUM.PRZEC Application.WorksheetFunction.NegBinomDist
ROZKŁAD.EXP Application.WorksheetFunction.ExponDist
ROZKŁAD.F Application.WorksheetFunction.FDist
ROZKŁAD.F.ODW Application.WorksheetFunction.FInv
ROZKŁAD.FISHER Application.WorksheetFunction.Fisher
ROZKŁAD.FISHER.ODW Application.WorksheetFunction.FisherInv
ROZKŁAD.GAMMA Application.WorksheetFunction.GammaDist
ROZKŁAD.HIPERGEOM Application.WorksheetFunction.HypGeomDist
ROZKŁAD.LIN.GAMMA Application.WorksheetFunction.GammaLn
ROZKŁAD.LOG Application.WorksheetFunction.LogNormDist
ROZKŁAD.LOG.ODW Application.WorksheetFunction.LogInv
ROZKŁAD.NORMALNY Application.WorksheetFunction.NormDist
ROZKŁAD.NORMALNY.ODW Application.WorksheetFunction.NormInv
ROZKŁAD.NORMALNY.S Application.WorksheetFunction.NormSDist
ROZKŁAD.NORMALNY.S.ODW Application.WorksheetFunction.NormSInv
ROZKŁAD.POISSON Application.WorksheetFunction.Poisson
ROZKŁAD.T Application.WorksheetFunction.TDist
ROZKŁAD.T.ODW Application.WorksheetFunction.TInv
ROZKŁAD.WEIBULL Application.WorksheetFunction.Weibull
RTD Application.WorksheetFunction.RTD
RZYMSKIE Application.WorksheetFunction.Roman
SEKUNDA Second
SILNIA Application.WorksheetFunction.Fact
SIN Sin
SINH Application.WorksheetFunction.Sinh
SKOŚNOŚĆ Application.WorksheetFunction.Skew
SLN Application.WorksheetFunction.Sln
STOPNIE Application.WorksheetFunction.Degrees
SUMA Application.WorksheetFunction.Sum
SUMA.ILOCZYNÓW Application.WorksheetFunction.SumProduct
SUMA.JEŻELI Application.WorksheetFunction.SumIf
SUMA.KWADRATÓW Application.WorksheetFunction.SumSq
SUMA.X2.M.Y2 Application.WorksheetFunction.SumX2MY2
SUMA.X2.P.Y2 Application.WorksheetFunction.SumX2PY2
SUMA.XMY.2 Application.WorksheetFunction.SumXMY2
SUMY.POŚREDNIE Application.WorksheetFunction.Subtotal
SYD Application.WorksheetFunction.Syd
SZUKAJ.TEKST Application.WorksheetFunction.Search
ŚREDNIA Application.WorksheetFunction.Average
ŚREDNIA.GEOMETRYCZNA Application.WorksheetFunction.GeoMean
ŚREDNIA.HARMONICZNA Application.WorksheetFunction.HarMean
ŚREDNIA.WEWN Application.WorksheetFunction.TrimMean
TAN Tan
TANH Application.WorksheetFunction.Tanh
TEKST Application.WorksheetFunction.Text
TERAZ Now
TEST.CHI Application.WorksheetFunction.ChiTest
TEST.F Application.WorksheetFunction.FTest
TEST.T Application.WorksheetFunction.TTest
TEST.Z Application.WorksheetFunction.ZTest
TRANSPONUJ Application.WorksheetFunction.Transpose
UFNOŚĆ Application.WorksheetFunction.Confidence
USUŃ.ZBĘDNE.ODSTĘPY Application.WorksheetFunction.Trim
VDB Application.WorksheetFunction.Vdb
WARIANCJA Application.WorksheetFunction.Var
WARIANCJA.POPUL Application.WorksheetFunction.VarP
WARTOŚĆ CByte / CInteger / CLong / CSingle / CDouble
WSP.KORELACJI Application.WorksheetFunction.Correl
WYBIERZ Application.WorksheetFunction.Choose
WYST.NAJCZĘŚCIEJ Application.WorksheetFunction.Mode
WYSZUKAJ Application.WorksheetFunction.Lookup
WYSZUKAJ.PIONOWO Application.WorksheetFunction.VLookup
WYSZUKAJ.POZIOMO Application.WorksheetFunction.HLookup
WYZNACZNIK.MACIERZY Application.WorksheetFunction.MDeterm
ZAOKR Application.WorksheetFunction.Round
ZAOKR.DO.CAŁK Int
ZAOKR.DO.NPARZ Application.WorksheetFunction.Odd
ZAOKR.DO.PARZ Application.WorksheetFunction.Even
ZAOKR.DO.TEKST Application.WorksheetFunction.Fixed
ZAOKR.DÓŁ Application.WorksheetFunction.RoundDown
ZAOKR.GÓRA Application.WorksheetFunction.RoundUp
ZAOKR.W.DÓŁ Application.WorksheetFunction.Floor
ZAOKR.W.GÓRĘ Application.WorksheetFunction.Ceiling
ZASTĄP Application.WorksheetFunction.Replace
ZŁĄCZ.TEKSTY &
ZNAJDŹ Application.WorksheetFunction.Find
ZNAK Chr
ZNAK.LICZBY Sgn
Przykład 202.
Napisz program, który będzie przesuwać w lewo liczbę wpisaną w komórce A2 o liczbę
bitów wpisaną w komórce B2. Wynik będzie zapisywany w komórce C2.
3. Wpisz program (rysunek 13.7).
Rysunek 13.7. Program przesuwający liczbę zapisaną w komórce A2 o liczbę bitów zapisanych
w komórce B2 i zapisujący wynik w komórce C2
Rysunek 13.8.
Dane testowe
5. Uruchom program.
Rysunek 13.9.
Funkcja działa na liczbach
binarnych. Przesunięcie
bitów o jeden w lewo
oznacza pomnożenie
liczby przez dwa
Przykład 203.
Napisz program, który będzie przesuwać w prawo liczbę wpisaną w komórce A2 o liczbę
bitów wpisaną w komórce B2. Wynik będzie zapisywany w komórce C2.
Rysunek 13.10. Program przesuwający liczbę zapisaną w komórce A2 o liczbę bitów zapisanych
w komórce B2 i zapisujący wynik w komórce C2
Rysunek 13.11.
Dane testowe
5. Uruchom program.
Rysunek 13.12.
Funkcja działa na
liczbach binarnych.
Przesunięcie bitów
o jeden w prawo
oznacza podzielenie
liczby przez dwa
Przykład 204.
Napisz program, którego zastosowanie pozwoli porównać pozycje bitów postaci bi-
narnych dwóch liczb zapisanych w komórkach A2 i B2. Jeśli w którejkolwiek pozycji
znajduje się wartość 1, program zwraca liczbę 2 podniesioną do odpowiedniej potęgi,
w zależności od pozycji bitu. Następnie te liczby są sumowane. Wynik będzie zapisywany
w komórce C2.
Rysunek 13.13. Funkcja Bitor nazywa się tak samo w wersji polskiej i angielskiej Excela
Rysunek 13.14.
Arkusz z danymi
testowymi
5. Uruchom program.
Rysunek 13.15. Postacią binarną liczby 23 jest 10111. Postacią binarną liczby 10 jest 1010.
W każdej z pięciu pozycji liczba 1 występuje w co najmniej jednej z porównywanych liczb. Aby obie
liczby miały tę samą liczbę cyfr, liczbę 1010 można przedstawić w postaci 01010. Liczby 2^0, 2^1, 2^2,
2^3 i 2^4 są sumowane, a ich suma jest równa 31, gdyż 1 + 2 + 4 + 8 + 16=31

W programie z przykładu 204. funkcję Bitor zastąp funkcją Bitand (rysunek 13.16)
Sprawdź, jak zmienił się wynik (rysunek 13.16).
Rysunek 13.16. Funkcja Bitand zastąpiła funkcję Bitor
Rysunek 13.17. Żeby sprawdzić, czy obliczenia zostały wykonane poprawnie, należy obie dane
zamienić na postać binarną. Następnie należy przenalizować występowanie liczby 1 w każdej
z porównywanych liczb. Aby obie liczby miały tę samą liczbę cyfr, liczbę 1010 można przedstawić
w postaci 01010.
Przykład 206.
Napisz program, którego zastosowanie pozwoli wczytać wartość wpisaną do komórki A2,
a jej cosinus hiperboliczny zwrócić do komórki B2.
Rysunek 13.18. Program, którego zastosowanie pozwala wczytać liczbę z komórki A2, a do komórki
B2 zwrócić jej cosinus hiperboliczny
Rysunek 13.19.
Dane testowe
5. Uruchom program.
6. Wyświetl ponownie arkusz Excela (rysunek 13.20).
Rysunek 13.20.
Argument i wynik
Przykład 207.
a jej cosecans zwrócić do komórki B2.
Rysunek 13.21. Program, którego zastosowanie pozwala odczytać wartość z komórki A2 i wpisać
odpowiadający jej cosecans do komórki B2
Rysunek 13.22.
Arkusz do testowania
programu
5. Uruchom program.
6. Wyświetl ponownie arkusz kalkulacyjny (rysunek 13.23).
Rysunek 13.23.
Argument i wyliczona
wartość

Na rysunku 13.23 jest widoczna inna wartość w komórce aktywnej i pasku formuły.
Sprawdź, jaki wpływ na wartość wyświetlaną w komórce będzie miała zmiana formatu
komórki (menu podręczne, polecenie Formatuj komórki).

Na rysunku 13.23 jest widoczna inna wartość w komórce aktywnej i pasku formuły.
Sprawdź, która z nich jest widoczna na wydruku, a która używana do obliczeń?
Przykład 210.
a cosecans hiperboliczny liczby zespolonej zwrócić do komórki B2.
Rysunek 13.24. Funkcja operująca na liczbach zespolonych nosi nazwę rozpoczynającą się od Im
(ang. Imagine — urojony)
Rysunek 13.25.
Liczba zespolona składa
się z części rzeczywistej
i urojonej (poprzedzonej
literą i)
5. Uruchom program.
Rysunek 13.26.
Wynik, tak jak argument,
składa się z części
rzeczywistej i urojonej
Przykład 211.
Napisz program, którego zastosowanie pozwoli wczytać daty wpisane do komórek A2
i B2, a liczbę dni pomiędzy nimi zapisać do komórki C2.
Rysunek 13.27. Funkcja Days ma dwa argumenty
4. Przygotuj arkusz z danymi (rysunek 13.28).
Rysunek 13.28.
Arkusz z danymi
5. Uruchom program.
6. Ponownie wyświetl arkusz (rysunek 13.29).
Rysunek 13.29.
Czas napisania programu
i wykonania obliczeń przez
komputer był krótszy niż
policzenie dni dzielących obie
daty przy użyciu kalendarza
Przykład 212.
Napisz program, którego zastosowanie pozwala wczytać postać tekstową liczby z ko-
mórki A2. Podstawa jest określona w komórce B2. Wartość dziesiętna jest zwracana
do komórki C2.
Rysunek 13.30. Program konwertujący liczby na postać dziesiętną
Rysunek 13.31.
Jaką wartość w układzie
dziesiętnym ma liczba
FF w zapisie
heksadecymalnym?
5. Uruchom program.
6. Zapoznaj się z wyglądem arkusza (rysunek 13.32).
Rysunek 13.32.
Liczbie
heksadecymalnej FF
odpowiada 255
w układzie dziesiętnym
Przykład 213.
a jej wartość funkcji gamma — zwrócić do komórki B2.
Rysunek 13.33. Program, którego zastosowanie pozwala wczytać argument z komórki A2 oraz
wyliczyć i zapisać wartość funkcji do komórki B2
Rysunek 13.34.
Arkusz testowy
5. Uruchom program.
6. Ponownie obejrzyj arkusz (rysunek 13.35).
Rysunek 13.35.
Arkusz z wyliczoną
funkcją gamma
Przykład 214.
Napisz program, którego zastosowanie pozwoli wczytać datę wpisaną do komórki A2,
a następnie zwrócić do komórki B2 numer tygodnia roku w formacie ISO.
Rysunek 13.36. Program, którego zastosowanie pozwala podać numer tygodnia roku w formacie ISO
na podstawie daty
4. Przygotuj arkusz testowy (rysunek 13.37).
Rysunek 13.37.
Fragment arkusza
testowego
5. Uruchom program.
Rysunek 13.38.
Data i wyznaczony
na jej podstawie
numer tygodnia
Przykład 215.
Napisz program, którego zastosowanie pozwala wczytać wartość wpisaną do komórki A2,
a wyliczoną dla niej liczbę kombinacji (wraz z powtórzeniami) zwrócić do komórki B2.
Rysunek 13.39. Program, którego zastosowanie pozwala wyliczyć liczbę kombinacji (wraz z powtórzeniami)
Rysunek 13.40.
programu
5. Uruchom program.
Rysunek 13.41.
3 elementy spośród
4 mogą utworzyć
20 kombinacji
z powtórzeniami
Przykład 216.
Napisz program, którego zastosowanie pozwala zwrócić liczbę okresów wymaganych
przez inwestycję do osiągnięcia określonej wartości. Wartość inwestycji jest wpisana
do komórki A2. Wynik obliczeń powinien zostać zwrócony do komórki B2.
3. Wpisz program:
Option Explicit
Sub przykład_216()
Range("D2").Value =
Application.WorksheetFunction.PDuration((Range("A2").Value),
(Range("B2").Value), (Range("C2").Value))
End Sub
4. Przygotuj dane do testowania programu (rysunek 13.42).
Rysunek 13.42.
Przyjęto, że roczna stopa
procentowa wynosi 2,5%.
Aby uzyskać wynik
w miesiącach, należy użyć
do obliczeń oprocentowania
miesięcznego
5. Uruchom program.
Rysunek 13.43.
Przy przyjętych
założeniach podwojenie
kapitału nastąpi
po nieco ponad
333 miesiącach
Przykład 217.
a jej gęstość dla standardowego rozkładu normalnego zwrócić do komórki B2.
Rysunek 13.44. Program, którego zastosowanie pozwala wyliczać wartość standardowego rozkładu
normalnego
4. Przygotuj arkusz z zestawem danych (rysunek 13.45).
Rysunek 13.45.
programu
5. Uruchom program.
6. Wyświetl arkusz (rysunek 13.46).
Rysunek 13.46.
Liczba w komórce B2
jest efektem wykonania
programu
Przykład 218.
Napisz program, którego zastosowanie pozwala konwertować liczbę dziesiętną na
odpowiednik tekstowy o podanej podstawie. Liczba w układzie dziesiętnym jest wpi-
sana do komórki A2. Podstawa nowej liczby jest wpisana do komórki B2. Minimalna
długość liczby w postaci tekstowej jest wpisana do komórki C2. Program zwraca wynik
do komórki D2.
3. Wpisz program:
Sub przykład_218()
Range("D2").Value = Application.WorksheetFunction.Base((Range("A2").Value),
End Sub
4. Przygotuj arkusz do testowania programu (rysunek 13.47).
Rysunek 13.47.
Dane do testowania
programu
5. Uruchom program.
7. Odczytaj komunikat.
Rysunek 13.48.
Liczba w komórce D2
jest uzupełniana zerami,
aby w sumie miała taką
długość, jaka jest podana
w komórce C2. Aby zera
nie były usuwane, komórce D2
należy nadać format tekstowy
Przykład 219.
Napisz program, którego zastosowanie pozwala wyliczać wartość stopy procentowej.
Liczba okresów inwestycji jest wpisana do komórki A2. Wartość obecna inwestycji
jest wpisana do komórki B2. Wartość przyszła inwestycji jest wpisana do komórki C2.
Program zwraca wynik do komórki D2.
3. Wpisz program:
Option Explicit
Sub przykład_219()
Range("D2").Value = Application.WorksheetFunction.Rri((Range("A2").Value),
End Sub
Rysunek 13.49. Wiemy, ile mamy pieniędzy i ile będziemy potrzebowali za 96 miesięcy
5. Uruchom program.
Rysunek 13.50. Stopa procentowa to 0,0009933 miesięcznie lub około 12% rocznie
Przykład 220.
a jej secans hiperboliczny zwrócić do komórki B2.
Rysunek 13.51. Program wyliczający secans hiperboliczny
4. Przygotuj arkusz z danymi testowymi (rysunek 13.52).
Rysunek 13.52.
Arkusz z danymi
testowymi
5. Uruchom program.
Rysunek 13.53.
Arkusz z danymi
testowymi i wynikiem
obliczeń
Przykład 221.
Napisz program, którego zastosowanie pozwala zwracać liczbę (punkt kodowy) od-
powiadającą pierwszemu znakowi tekstu. Tekst jest wczytywany z komórki A2. Punkt
kodowy jest zwracany do komórki B2.
Rysunek 13.54. Program, którego zastosowanie pozwala zwracać kod pierwszego znaku tekstu
Rysunek 13.55.
Formuła chemiczna
Kingsize?
5. Uruchom program.
6. Ponownie obejrzyj arkusz (rysunek 13.56).
Rysunek 13.56.
Litera C ma kod 67
Przykład 222.
Napisz program, którego zastosowanie pozwala na podstawie wartości logicznych wpi-
sanych do komórek A2 i B2 zwrócić wartość logiczną alternatywy wykluczającej.
Wynik zostaje wpisany do komórki C2.
Rysunek 13.57. Program, którego zastosowanie pozwala wyznaczyć wartość XOR na podstawie
wyrażeń zapisanych w komórkach A2 i B2

5. Uruchom program.
Rysunek 13.58.
Dane testowe
Rysunek 13.59.
Wartość funkcji XOR
wyznaczona na
podstawie wartości
logicznej wyrażeń 1 i 2
Podsumowanie
 Aby skorzystać z funkcji arkuszowej w programie VBA, należy użyć jej
angielskiej nazwy i poprzedzić ciągiem Application.WorksheetFunction.
Dodatek A
Wybrane
kody błędów VBA
Jeżeli podczas działania programu VBA zostanie wykryty błąd, aplikacja przestanie
działać. Jest wówczas wyświetlany komunikat o błędzie. Zawarte w nim informacje
pozwalają na łatwiejsze znalezienie przyczyny błędu. Poniższe zestawienie zawiera
znaczenie najczęściej spotykanych kodów błędów języka VBA.
Tabela A.1. Wybrane kody błędów VBA

Kod błędu Znaczenie
3 Użycie instrukcji Return bez instrukcji GoSub
5 Niepoprawne wywołanie lub niepoprawny argument procedury
7 Brak pamięci fizycznej zainstalowanej w systemie
9 Indeks poza zakresem lub element o określonej nazwie nie istnieje
10 Tablica stała lub tymczasowo zablokowana
11 Dzielenie przez zero
13 Niezgodne typy
14 Brak miejsca na łańcuchy znaków
16 Wyrażenie zbyt złożone
17 Nie można wykonać żądanej operacji
18 Użytkownik przerwał działanie programu
28 Brak miejsca na stosie
35 Nie zdefiniowano procedury Sub, Function lub Property
48 Błąd ładowania pliku DLL
52 Błędna nazwa lub numer pliku
53 Nie znaleziono pliku
54 Niepoprawny tryb pliku
55 Plik został wcześniej otwarty
Tabela A.1. Wybrane kody błędów VBA (ciąg dalszy)

57 Błąd urządzenia wejścia-wyjścia
58 Plik już istnieje
59 Niepoprawna długość rekordu
61 Dysk jest pełny
63 Błędny numer rekordu
67 Zbyt wiele plików
68 Urządzenie niedostępne
70 Brak uprawnień
71 Dysk nie jest gotowy
75 Błąd dostępu do pliku lub katalogu
76 Niepoprawna ścieżka dostępu
91 Nie ustawiono zmiennej obiektowej lub zmiennej bloku With
92 Nie zainicjalizowano pętli For
93 Niepoprawny łańcuch wzorca
94 Nieprawidłowe użycie wartości Null
96 Nie można generować zdarzeń obiektu, ponieważ obiekt wygenerował zdarzenia
dla maksymalnej dla niego liczby odbiorców
97 Nie można wywołać funkcji zaprzyjaźnionej na rzecz obiektu, który nie jest
egzemplarzem klasy definiującej
98 Wywołanie właściwości lub metody nie może zawierać odwołania do prywatnego
obiektu ani w postaci argumentu, ani w postaci zwracanej wartości
321 Niepoprawny format pliku
322 Nie można utworzyć niezbędnego pliku tymczasowego
325 Niepoprawny format w pliku zasobów
380 Niepoprawna wartość właściwości
381 Niepoprawny indeks tablicy właściwości
382 Ustawianie wartości nie jest możliwe podczas pracy programu
383 Ustawianie wartości nie jest możliwe (właściwość tylko do odczytu)
385 Wymagany indeks tablicy właściwości
387 Niedozwolone jest użycie procedury Property Set
393 Pobieranie wartości nie jest możliwe podczas pracy programu
394 Pobieranie wartości nie jest możliwe (właściwość tylko do zapisu)
422 Właściwość nie została odnaleziona
423 Właściwość lub metoda nie została odnaleziona
424 Wymagany formularz
429 Komponent ActiveX nie może utworzyć obiektu
430 Klasa nie obsługuje automatyzacji
Dodatek A  Wybrane kody błędów VBA 369
Tabela A.1. Wybrane kody błędów VBA (ciąg dalszy)

432 Podczas wykonywania automatyzacji nie znaleziono pliku lub klasy
438 Obiekt nie obsługuje tej właściwości lub metody
440 Błąd automatyzacji
442 Utracono połączenie z biblioteką typów lub biblioteką obiektów dla procesu zdalnego
443 Obiekt automatyzacji nie ma wartości domyślnej
445 Obiekt nie obsługuje tego działania
446 Obiekt nie obsługuje nazwanych argumentów
447 Obiekt nie obsługuje bieżącego ustawienia lokalizacji
448 Nie znaleziono nazwanego argumentu
449 Argument nie jest opcjonalny
450 Niewłaściwa liczba argumentów
451 Nie zdefiniowano procedury Property Let, a procedura Property Get nie zwraca obiektu
452 Nieprawidłowa liczba porządkowa
453 Nie znaleziono wyspecyfikowanej funkcji DLL
454 Nie znaleziono zasobu kodu
455 Blokada zasobu kodu
457 Klucz jest już powiązany z elementem tej kolekcji
458 Dla zmiennej wykorzystano typ nieobsługiwany w języku VBA
459 Składnik nie obsługuje tego zbioru zdarzeń
460 Nieprawidłowy format schowka
461 Nie znaleziono metody lub składowej
462 Zdalny serwer nie istnieje lub jest niedostępny
463 Na komputerze lokalnym nie zarejestrowano klasy
481 Obraz nieprawidłowy
482 Błąd drukarki
735 Nie można zapisać pliku w katalogu TEMP
744 Nie znaleziono wyszukiwanego tekstu
746 Podstawiany tekst jest zbyt długi
1004 Błąd aplikacji lub obiektu
Dodatek B
Programowanie
obiektowe
Programowanie proceduralne
a obiektowe
Jeżeli pisałeś program w BASIC-u, C, Fortranie, Pascalu itp., posługiwałeś się progra-
mowaniem proceduralnym. Ten typ programowania zawdzięcza swoją nazwę moż-
liwości pisania procedur. Każda procedura ma do wykonania elementarne zadanie. Na-
stępnie procedury łączy się w program.
Modułowa budowa programu ułatwia jego testowanie. Prosty program może składać
się z trzech procedur:
1. Wprowadzania danych (np. procedura „prosi” o podanie imienia użytkownika);
2. Przetwarzania danych (np. zastosowanie procedury pozwala odczytać datę
z zegara systemowego i sprawdzić w tablicy z datami imienin, czy dziś są
imieniny użytkownika);
3. Wyświetlenia wyniku (np. zastosowanie procedury pozwala wyświetlić samo
powitanie lub powitanie i życzenia).
W taki sposób uczyłem się programować i ja. Programowanie proceduralne ma jedną

wadę — nijak nie przystaje do opisu rzeczywistości. Uczący się programowania ma
spore kłopoty ze zrozumieniem metod dostosowania sposobów wprowadzania, przetwa-
rzania i wyprowadzania danych, aby były użyteczne. Programista musi znać sporo „sztu-
czek”, aby programować szybko i bezbłędnie.
Odmienne podejście reprezentuje programowanie obiektowe. Jest ono zgodne z postrze-

ganiem świata przez człowieka. Człowiek widzi obiekty. Obiektem jest np. żarówka (ry-
sunek B.1). Ma ona właściwości: kolor bańki, napięcie znamionowe, moc, typ gwintu itp.
Rysunek B.1.
Do właściwości
obiektu „żarówka”
należą: kolor bańki,
napięcie znamionowe,
moc, typ gwintu itp.
W taki sposób dziecko poznaje świat. Widzi rzecz (obiekt), a następnie poznaje jej cechy
(właściwości). Gdy dziecko zaczyna myśleć logicznie i zna już wiele rzeczy, zaczyna
je klasyfikować i łączyć w grupy na podstawie cech wspólnych. W programowaniu obiek-
towym zbiór obiektów, które mają cechę wspólną, nosi nazwę klasy.
Gdy zacząłem poznawać zasady programowania obiektowego, uznałem, że są one bardzo

logiczne i naturalne. Gdy zacząłem pisać programy, okazało się, że jeśli pisząc program,
posługuję się moim naturalnym sposobem myślenia, mogę łatwiej panować nad więk-
szymi strukturami, niż miało to miejsce przy programowaniu strukturalnym.
Skąd wziął się pomysł programowania obiektowego? Otóż okazało się, że programo-
wanie przy wykorzystaniu języków strukturalnych było niewystarczające do niektórych
zastosowań, np. symulacji zachowań statków. Żeby poradzić sobie z problemem, posta-
nowiono pogrupować statki w rożne klasy obiektów pływających. Każda z klas sama
odpowiadała za określanie własnych danych i zachowań.
Na użytek programowania umówiono się, że są cztery aspekty obiektów używanych

do budowy programu:
1. Właściwości — atrybuty obiektów.
2. Metody — akcje, które obiekt może wykonać.
3. Zdarzenia — czynności, których wystąpienie obiekt wykrywa.
4. Kolekcje — grupy obiektów tego samego typu zawarte w innym obiekcie.
Dodatek B  Programowanie obiektowe 373
Właściwości
Właściwości opisują obiekt. Są jego cechami. W oknie edytora Visual Basic są zgru-
powane w oknie Properties (właściwości). Właściwością obiektu w programie Excel
jest nazwa (ang. Name). Zawiera ona wartość identyfikującą obiekt (rysunek B.2).
Rysunek B.2.
Obiekt nosi nazwę
Arkusz1
Właściwości obiektu są zależne od jego typu. Właściwościami obiektu Chart (wykres) są

HasTitle (tytuł) oraz Type (typ). Właściwościami obiektu Range (zakres) są Name (nazwa)
i Value (wartość).
Metody
Metoda jest operacją, którą można wykonać na obiekcie. Wykonuje ją nie użytkownik,
a program zapisany w języku VBA.
Arkusz wyświetlony w oknie programu Excel na pierwszym planie jest nazywany ar-
kuszem aktywnym. Jeżeli jednocześnie jest otworzonych kilka okien, aktywne jest to
okno, które zostało ostatnio kliknięte lub zostało wybrane po naciśnięciu kombinacji
klawiszy Alt+Tab.
Zmiana arkusza aktywnego w programie VBA polega na wywołaniu metody Activate

(uaktywnij).
Zdarzenia
Zdarzenie jest akcją, której wystąpienie obiekt wykrywa. Zdarzeniem może być np.
naciśnięcie klawisza (lub kombinacji klawiszy), kliknięcie wykresu, wpisanie danych
w komórce, ale także otwarcie lub zamknięcie skoroszytu.
Gdy akcja wystąpi, a użytkownik zdefiniował reakcję na nią, Excel uruchamia kod
z procedury obsługi zdarzenia. Na przykład po utworzeniu nowego skoroszytu w ko-
mórkach A1, A2 i A3 może zostać wpisany odpowiednio tekst: Lp., Towar, Cena.
Kolekcje
Kolekcja to grupa obiektów tego samego typu zawartych w innym obiekcie. Na przykład
skoroszyt składa się z wszystkich arkuszy należących do tego zeszytu (rysunek B.3).
Rysunek B.3.
Skoroszyt zawiera pięć
arkuszy
Zamiast ręcznie wprowadzać zmiany w każdym arkuszu, można zmianę wprowadzić

programowo. Korzyść z takiego rozwiązania staje się oczywista, gdy trzeba np. jedno-
licie sformatować raport składający się z kilkudziesięciu arkuszy.
Modele obiektowe
Pakiet Microsoft Office składa się z kilku programów: Access, Excel, Word. Każdy
z programów z uwagi na swoją specyfikę ma unikatowy model obiektowy.
Program — czy to powstały przez zarejestrowanie makropolecenia, czy napisany w VBA

— może wykorzystywać tylko obiekty znajdujące się w programie, na którym bazuje.
Nie można programu napisanego dla Excela uruchomić w Wordzie. Program dla Excela
korzysta bowiem z obiektów (arkuszy, funkcji, wykresów itp.), których próżno szukać
w Wordzie.
Metoda kropkowa
Dostęp do metod, podobnie jak do właściwości, można uzyskać za pośrednictwem no-
tacji kropkowej. Chcąc na przykład skopiować zaznaczony obszar do schowka, użyj pole-
cenia Seletion.Copy (rysunek B.4).
Rysunek B.4.
Przed kropką znajduje się
informacja, czego dotyczy
działanie, a po kropce znajduje
się informacja, jakie działanie
należy wykonać
Jeżeli odwołanie dotyczy obiektu składowego, należy określić jego lokalizację. Do tego
celu jest także wykorzystywany zapis z kropkami.
Odwołania są podobne do ścieżek dostępu. Zamiast folderów występują obiekty. Zamiast

znaków \ występują kropki.
Dodatek B  Programowanie obiektowe 375
Obiekty aktywne
Jeżeli na ekranie komputera jest wyświetlonych kilka okien, to znaki wpisane z klawiatury
będą odnosiły się do okna aktywnego (rysunek B.5). Okno aktywne jest widoczne na
pierwszym planie. Ma pasek tytułu w intensywniejszym kolorze niż okna nieaktywne.
Rysunek B.5. Okno aktywne jest widoczne na pierwszym planie
Z identyczną sytuacją mamy do czynienia podczas pracy z programem napisanym w VBA.

Jeżeli przed wydaniem polecenia nie zostanie określone, jakiego obiektu ono dotyczy,
będzie domyślnie odnosiło się do obiektu aktywnego.
Zakończenie
Programowanie jest rzemiosłem. Każdy problem można rozwiązać na wiele sposobów.
Który z nich wybrać? Nie można tej wiedzy posiąść tylko przez czytanie książek. Ko-
nieczne jest samodzielne rozwiązywanie problemów, pisanie programów, testowanie
ich i udoskonalanie.
Rzetelne rozwiązanie problemu wymaga wykorzystania posiadanych umiejętności i do-

świadczenia. Gdy okaże się, że nie są one wystarczające — wymaga również posze-
rzenia wiedzy. Nikt nie jest w stanie w jakiejś dziedzinie wiedzieć wszystkiego. Każdy
zrealizowany projekt doprowadzi do tego, że w określonym temacie wiedza projek-
tanta wzrośnie i zbliży się do 100%. Umiejętności programisty będą proporcjonalne
do linii łączącej wierzchołki słupków na wykresie z rysunku Z.1. Na osi poziomej są
umieszczone kolejne numery rozwiązanych problemów. Na osi pionowej ― stopień
zgłębienia wiedzy z wąskiej dziedziny, który był potrzebny do wykonania zadania. Linia
poprowadzona przez wierzchołki słupków jest wiedzą całkowitą.
Rysunek Z.1.
Im więcej problemów
projektant rozwiąże
i im solidniej to zrobi,
tym większa będzie
jego wiedza
Ostatnio na rynku pojawia się coraz więcej książek, które prezentują gotowe szablony
umożliwiające prowadzenie firmy przy wykorzystaniu edytora Word lub arkusza Excela.
Po uruchomieniu tego typu aplikacji na komputerze nikt nie będzie programistą. Będzie
najwyżej użytkownikiem ciekawego programu.
Prawdziwe umiejętności można zdobyć, rozwiązując własnoręcznie (raczej „własno-

głownie”) problemy. Książka powinna tylko pokazać, jakie są narzędzia do rozwiązywa-
nia problemów oraz jak ich w praktyce użyć. Reszta należy już do projektanta.
Jeżeli liczyłeś na to, że nabywając tę książkę, posiądziesz narzędzia, które pozwolą Ci na

rozwiązanie wszystkich problemów związanych z użytkowaniem komputera — bar-
dzo się myliłeś. Takiej książki nie ma i nigdy jej nie będzie. Zawsze bowiem w kon-
kretnym przypadku pojawi się niuans, którego nie przewidział programista. Grubaśne
tomisko szybko pójdzie w zapomnienie. Nikomu nie będzie chciało się szukać gotowych
rozwiązań, które w końcu i tak trzeba będzie modyfikować.
Jeżeli zaś spodziewałeś się, że dzięki tej książce zdobędziesz podstawy wiedzy umoż-
liwiające szybkie i prawidłowe rozwiązywanie problemów związanych z użytko-
waniem arkusza Excela za pomocą języka VBA — jest to książka dla Ciebie.
Skorowidz
-, 336 AddControl, 278 Arcsec, 324

", 336 AddinInstall, 263 Arcsin, 324
$, 75 Add-Ins, 98 arkusz
&, 340 AddinUninstall, 263 dezaktywacja, 264, 269, 272
*, 336 ADO, 318 dwukrotne kliknięcie, 264,
* xlsm, 36 adres 269, 272
* xlsx, 37 komórki, wpisywanie, 160 kliknięcie hiperłącza, 264
.docm, 11 losowy, 235 kliknięcie prawym
.docx, 11 obiektu zmiennej, 335 przyciskiem myszy, 264,
.dotm, 11 właściwości, 335 269, 272
.dotx, 11 adresowanie modyfikacja, 272
xlsm, 11 bezwzględne, 75 modyfikacja przez
xlsx, 11 komórki, 146 użytkownika, 264
xltm, 11 względne, 75 ochrona, 149
xltx, 11 AdvancedFilter, 317 uaktywnienie, 264, 272
/, 336 After, 296 utworzenie, 264
^, 336 AfterSave, 263 wykonanie obliczeń, 264
+, 336 AfterXmlExport, 263 zmiana zaznaczenia, 264, 272
<, 214, 338 AfterXmlImport, 263 Asc, 324
<=, 214, 338 aktywna komórka, 211 ASIN, 347
<>, 214, 338 Align, 111 ASINH, 347
=, 214, 338 alternatywa wykluczająca, 366 ATAN2, 347
>, 214, 339 ATANH, 347
amortyzacja środka trwałego,
>=, 214, 339 Atn, 324
327
1/Cos(X), 327 atrybuty pliku, 325, 335
And, 342
1/Sin(X), 324 AutoFill, 317
Anuluj, 168, 169, 170
1/Tan(X), 324 AutoFilter, 292, 317
API, 10
AppActivate, 332 AutoFit, 317
A AppleScript, 326 AutoOutline, 317
Applicaton.WorksheetFunction, AutoSize, 105, 258
Abs, 324 345
ACOS, 347
ACOSH, 347
ApplyNames, 317 B
ApplyOutlineStyles, 317
Activate, 263, 269, 278, 317 Arccos, 324 BackColor, 100, 102, 259
ActiveCell.Value, 221 Arccosec, 324 BAHTTEXT, 347
AddComment, 317 Arccotan, 324 BASIC, 7, 8
BD.ILE.REKORDÓW, 347 CDec, 324 Criteria

BD.ILE.REKORÓW.A, 347 Center in Form, 111 1, 293
BD.ILOCZYN, 347 CenterScreen, 101 2, 293
BD.MAX, 347 Change, 269 CSng, 324
BD.MIN, 348 ChDir, 332 CStr, 324
BD.ODCH.STANDARD, 348 ChDrive, 332 CurDir, 324
BD.ODCH.STANDARD.POPU CheckBox, 255 Currency, 120, 332
L, 348 CheckSpelling, 318 Cut, 318
BD.POLE, 348 Choose, 324 CVar, 324
BD.SUMA, 348 Chr, 324 CVErr, 324
BD.ŚREDNIA, 348 Chroń arkusz, 149 czarny, 204
BD.WARIANCJA, 348 ciąg bez końcowych spacji, 327 CZAS, 348
BD.WARIANCJA.POPUL, 348 ciąg bez początkowych spacji, czas dla podanej godziny, 328
Beep, 332 326 czas systemowy, 173
Before, 280 CInt, 324 czas wykonywania programu, 123
BeforeClose, 263 Class Modules, 94 CZAS.WARTOŚĆ, 348
BeforeDoubleClick, 269 Classes, 273 czcionka, kolor, 208
BeforeDragOver, 278 Clear, 318 czerwony, 204
BeforeDropOrPaste, 278 ClearComments, 318 CZĘSTOŚĆ, 348
BeforePrint, 263 ClearContents, 194, 196, 318 część
BeforeRightClick, 269 ClearFormats, 195, 318 całkowita liczby, 326
daty, 324
BeforeSave, 263 ClearNotes, 318
CZY.BŁ, 348
BeforeXmlExport, 263 ClearOutline, 318
CZY.BŁĄD, 348
BeforeXmlImport, 264 Click, 278
CZY.BRAK, 348
biały, 205 CLng, 324
CZY.LICZBA, 348
Bitand, 355 Close, 332
CZY.LOGICZNA, 348
Bitor, 355 Code Settings, 130 CZY.NIE.TEKST, 348
błąd, 126, 128 ColorIndex, 205, 207, 323 CZY.PUSTA, 348
obsługa, 334 ColumnCount, 259 CZY.TEKST, 348
odpowiadający kodowi, 325 ColumnDifferences, 318
opis, 180 COM, 10
zdefiniowany przez ComboBox, 253, 254 D
użytkownika, 324 Command, 324
dane, 278
źródło, 320 CommandButton, 101, 255, 258,
cząstkowe, 301
błędny typ danych, 142 274
eksportowanie, 318
błędy w obliczeniach, 127 Component Object Model, 10
grupowanie, 319
Boolean, 120, 144, 332 Consolidate, 318
kopiowanie, 317
BorderAround, 318, 320 Const, 332 scalenie, 318
buttons, 164 context, 154, 165 sortowanie, 320
Byte, 120, 126, 332 Copy, 318 wpisywanie, 160, 302
CopyFromRecordset, 318 wprowadzanie, 154
CopyPicture, 318
C Cos, 324
DAO, 318
DATA, 348
Calculate, 269, 318 COS, 348 data i czas systemowy, 331
Call, 332 Cosec, 324 data i godzina, 325
CallByName, 324 cosecans, 356 data systemowa, 173, 324,
Caption, 104, 259, 275, 279, 280 cosecans hiperboliczny, 325, 327, 332
carriage return, 154 357 modyfikacji pliku
Case Else, 230 COSH, 348 tekstowego, 325
CBool, 324 cosinus hiperboliczny, 325, 355 DATA.WARTOŚĆ, 348
CByte, 324 Cotan, 324 DataOption
CCur, 324 cotangens hiperboliczny, 325 1, 288
CDate, 324 CreateNames, 318 2, 288
CDbl, 324 CreateObject, 324 3, 288
Skorowidz 381
DataSeries, 318 DNI.360, 348 Exit Function, 333

Date, 121, 144, 178, 324, 326, 332 Do Until, 162 Exit Property, 333
Date$, 173 Do While, 241 Exit Sub, 333
DateAdd, 324 Do...Loop, 333 Exp, 325
DateDiff, 324 dodawanie, 336 EXP, 348
DatePart, 324 DoEvents, 325 ExportAsFixedFormat, 318
DateSerial, 324 dolne ograniczenia indeksu
DateValue, 324
Day, 325
tablicy, 334
domyślne formatowanie
F
DB, 348 komórek, 195 False, 122
DblClick, 107, 278 domyślny Field, 292
DDB, 325, 348 tryb porównywania ciągu, 334 File, 97
Deactivate, 264, 265, 269, 278 typ danych, 332 FileAttr, 325
Debug, 97, 126 Double, 120, 332 FileCopy, 333
Decimal, 121, 332 double-byte, 297 FileDateTime, 325
Declarations, 133 DoubleClick, 272 FileLen, 325
Declare, 332 drukowanie, obiekt, 319 FillDown, 318
default, 154 Duplicate declaration in current FillLeft, 319
Default, 259 scope, 133 FillRight, 319
DefBool, 332 duplikacja nazw, 245 FillUp, 319
DefByt, 332 dwukrotne kliknięcie, 278 Filter, 325
DefCur, 332 arkusza, 269, 272 filtr, rozwijanie, 293
DefDate, 332 dzielenie, 336 filtrowanie, 291, 292, 293, 295
DefDbl, 332 scalonego obszaru, 320 definiowanie kryteriów
DefDec, 332 DZIEŃ, 348 złożonych, 293
DefInt, 333 dzień miesiąca, 325 kryterium, 293
DefLng, 333 dzień tygodnia, 328 listy, 317
DefObj, 333 DZIEŃ.TYG, 348 przesunięcie pola, 292
DefSng, 333 DZIŚ, 348 Find, 296, 319
DefStr, 333 dźwięk, 332 FindNext, 319
DefVar, 333 FindPrevious, 319
deklaracja, 335 fioletowy, 204
funkcji, 334
E folder, atrybuty, 325
FollowHyperlink, 269
nazw i argumentów Edit, 97 Font, 208
procedury, 334 EditionOptions, 318 For ... Next, 231, 334
zdarzenia, 333 edytor, 77, 83 For Each… Next, 196, 199, 333
zmiennych, 130, 333 Visual Basic, 9 Format, 97, 110, 111, 112, 325
Delete, 318 eksplorator projektów, 93 FormatCurrency, 325
DeleteSetting, 333 eksportowanie danych, 318 FormatDateTime, 325
Deweloper, 27, 42, 46, 55, 64, 98 Enable Calculation, 96 formatka, 98
dezaktywacja End, 132, 333 nazwa, 100
arkusza, 269 End Sub, 40, 57, 74 położenie, 101
formularza, 278 Enum, 333 FormatNumber, 325
otwartego skoroszytu, 272 Environ, 325 FormatPercent, 325
DialogBox, 318 EOF, 325 formaty, wyczyszczenie, 318
Dim, 132, 333 Eqv, 342 Forms, 94
Dir, 325 Erase, 333 formularze, 94
Dirty, 318 Error, 278, 325, 326, 333 dezaktywacja, 278
DLL, 332 etykieta, 254 przewijanie, 278
DŁ, 348 Event, 333 uaktywnienie, 278
długość Example, 321 usunięcie, 278
pliku w bajtach, 325 Excel 5, 9 zamknięcie, 249, 278
tekstu, 184 Exit Do, 333 zmiana rozmiaru, 278
dni dzielące dwie daty, 358 Exit For, 333 zmiana wielkości, 278
formuła, wyczyszczenie, 318

FRAGMENT.TEKSTU, 348
I K
Frame, 255 ID zadania, 327 karta Dodatki, 10
FreeFile, 325 if, 118 karty, 255
Function, 334 If...Then, 225 katalog
FunctionWizard, 319 If...Then...Else, 226, 334 atrybuty, 325
funkcje Ignoruj, 168 bieżący, 332
arkusza, 323, 345 IIf, 326 utworzenie, 334
gamma, 359 ILE.LICZB, 348 zmiana nazwy, 334
Or, 343 ILE.NIEPUSTYCH, 348 Key
wykładnicze, 325 ILOCZYN, 348 1, 288
FV, 325, 348 iloczyn logiczny, 342 2, 288
Image, 255 3, 288
G Imp, 342 KeyDown, 278
General, 96 Implements, 334 KeyPress, 278
generator liczb losowych, 232, implikacja, 342 KeyUp, 278
335 IMPT, 348 Kill, 334
Get, 334 INDEKS, 348 klasa, 334, 372
GetAllSettings, 325 indeks tablicy, 328 klawisz
GetAttr, 325 Initialize, 278 wciśnięcie, 278
GetObject, 325 Input, 326 zwolnienie, 278
GetSetting, 325 Input #, 334 klawisz skrótu, 60
gęstość dla standardowego InputBox, 154, 155, 157, 175, kliknięcie, 278
rozkładu normalnego, 362 176, 178, 326 arkusza prawym przyciskiem
godzina, 230, 325 Insert, 97, 319 myszy, 269
GODZINA, 348 InsertIndent, 319 arkusza, 264
godzina systemowa, 327 InStr, 326 hiperłącza, 269, 272
ustawienie, 335 InStrRev, 326 prawym przyciskiem, 272
GoSub...Return, 334 instrukcje, 231, 332, 333, 334, klucz w rejestrze Windows, 333
GoTo, 180, 215, 216, 273, 334 335 kod, 27, 43, 46, 56
Group, 319 Int, Fix, 326 ASCII, 324
grupowanie danych, 319 Integer, 120, 142, 176, 180, 333 RGB koloru, 327
interfejs, 334 znaku, 324
Interior.Color, 204 KOD, 349
H IPmt, 326 kody błędów VBA, 367
HArccos, 325 IRR, 326, 349 kolejny dostępny numer pliku, 325
HArccosec, 325 IsArray, 326 kolekcja, 374
HArccota, 325 IsDate, 326 kolor
HArcsec, 325 IsEmpty, 326 czcionki, 208
HArcsin, 325 IsError, 326 komórki, 204
HArctan, 325 IsMissing, 326 ramki, 323
HCos, 325 IsNull, 326 tła, 259
HCosec, 325 IsNumeric, 326 KOMBINACJE, 349
HCotan, 325 IsObject, 326 komentarz, 40, 57, 74, 317, 335
Header, 288, 290 ISPMT, 349 wyczyszczenie, 318
Height, 259 komórka
Help, 98 adresowanie, 146
helpfile, 154, 165 J aktywna, 211
Hex, 325 JEŻELI, 349 domyślne formatowanie, 195
hiperłącze, kliknięcie, 269, 272 Join, 326 kolor, 204
Hour, 230, 325 Justify, 319 kopiowanie, 281, 284, 318
HSec, 326 nazwa, 317
HSin, 326 odczytanie, 320
HTan, 326 scalenie, 319
Skorowidz 383
sortowanie, 287
uaktywnienie, 317
kolumn, 259
kombinacji, 361
M
usuwanie formatowania, 193 konwertowanie, 325, 363 MacID, 326
usuwanie zawartości, 193, 194 losowa, 327 MACIERZ.ILOCZYN, 349
wstawienie, 319 okresów spłaty, 327 MACIERZ.ODW, 349
wypełnianie, 198, 319 okresów wymaganych przez MacScript, 326
zakres, 259 inwestycję, 361 Make Same Size, 110
zaznaczanie, 190 przesuwanie w lewo, 353 Makra, 60
zmiana zawartości, 269 przesuwanie w prawo, 353 makropolecenie, 10, 113, 302
komunikat, 164, 165, 308 reprezentująca czas, 328 blokowanie, 12
o błędzie, 119, 177, 178 sekund od północy, 328 dostępność, 20, 28
komunikowanie się procedur, 304 spacji, 327 edycja, 21, 38, 56, 73
koniec pliku tekstowego, 325 zaokrąglona, 327 klawisz skrótu, 20
kontrolka zespolona, 357 klawisz, 47
dodanie, 278 znaków, 184, 326 niebezpieczne, 81
opis, 259 LICZBA.CAŁK, 349 przycisk, 67
szerokość, 259 licznik, 231 rejestrowanie, 41, 59
tło, 259 Line Input #, 334 testowanie, 30, 45, 49, 62
usunięcie, 278 linefeed character, 154
uruchamianie przyciskiem, 31
wysokość, 259 lista, 246
uruchomienie, 320
kontynuowanie wyszukiwania, filtrowanie, 317
warunki początkowe, 18
rozwijana, 252
319 zapisywanie, 35, 51, 68
ListBox, 246, 255
konwertowanie liczb, 363 maksymalna długość ciągu
ListNames, 319
kopiowanie listy nieukrytych nazw, 319 znaków, 259
danych, 317 literówki, 245 małe litery, 326
komórek, 19, 26, 58, 202, LITERY.MAŁE, 349 MatchByte, 297
281, 284 LITERY.WIELKIE, 349 MatchCase, 288, 297
KOWARIANCJA, 349 LN, 349 MAX, 349
krok, 231 Load, 334 MAX.K, 349
kursor, wygląd, 259 Loc, 326 MaxLenght, 259
KURTOZA, 349 Lock, 334 MEDIANA, 349
KWARTYL, 349 LOF, 326 Members, 273
KWOTA, 349 Log, 326 Merge, 319
kwota LOG, 349 metoda, 190, 321, 373
odsetek, 326 LOG10, 349 Microsoft Office 2000, 9
spłaty pożyczki, 327 logarytm naturalny, 326 Mid, 183, 326, 334
lokalna tablica, 334 miejsce wystąpienia błędu, 126
lokalna zmienna, 334 miesiąc, 327
L Long, 120, 139, 333 MIESIĄC, 349
LongPtr, 120
Label, 254, 279 MIN, 349
LookAt, 296
Layout, 278 MIN.K, 349
LookIn, 296
LBound, 326 Loop, 162 MINUTA, 349
LCase, 326 LOS, 349 Minute, 326
Left, 259, 326 losowy adres, 235 minuty, 326
Len, 184, 326 LSet, 334 MIRR, 327, 349
Let, 334 LTrim, 185, 326 MkDir, 334
LEWY, 349 LUB, 349 mniejszy lub równy, 338
Library, 273 mniejszy niż, 338
LICZ.JEŻELI, 349 Ł mnożenie, 336
LICZ.PUSTE, 349 Mod, 336
liczba, 325, 326 łańcuch znaków, 327 MOD, 349
bajtów, 326 odwrócony, 328 modalność, 167
decymalna, 328 po konwersji, 328 Modules, 94
heksadecymalna, 328 łączenie ciągów znaków, 340 moduł prywatny, 334
MODUŁ.LICZBY, 349
moduły klas, 94
O Offset, 210
OK, 168, 169
modyfikacja obiekt, 372, 374 okno
arkusza, 272 drukowanie, 319 aplikacji, 332
zaznaczenia w arkuszu, 269 usunięcie, 318 dialogowe, 154, 174, 326
Month, 327 wycięcie, 318 komunikatu, 164, 165, 327
MonthName, 327 wyczyszczenie, 318 skoroszytu, 272
MouseDown, 278 zakres, 318, 320 tytuł, 155
MouseMove, 278 obiekt, 189 z kartami, 255
MousePointer, 259 aktywny, 375 z tekstem, 107
MouseUp, 278 OLE, 325 OLE, 324, 325, 326
msdn microsoft.com, 320 Range, 319 On Error, 175, 334
MsgBox, 107, 140, 164, 168, Object, 121, 189, 333 On Error GoTo 0, 175
175, 176, 178, 327 obliczenia iteracyjne, 213 On Error GoTo line, 175
MultiPage, 255 obraz, 255 On Error Resume Next, 175
mysz kopiowanie, 318 On...GoSub, 334
przemieszczenie wskaźnika, 278 obsługa On...GoTos, 334
wciśnięcie przycisku, 278 błędów, 334 OnKey, 273
zwolnienie przycisku, 278 zdarzeń, 325 OnTime, 273
obszar, dzielenie, 320 opcje, 255
obwiednia, 320 Open, 264, 265, 267, 334
N obwódka, 321 Operator, 293
NACHYLENIE, 349 ochrona arkusza, 149 opis
najmniejszy indeks tablicy, 326 Oct, 327 błędu, 180
największy indeks tablicy, 328 OCZYŚĆ, 349 zawijanie, 259
Name, 96, 334 ODCH.KWADRATOWE, 349 oprocentowanie dla okresu
napęd, bieżący, 332 ODCH.STANDARD.POPUL, spłaty pożyczki, 327
napis nad przyciskiem, 172 350 Option Base, 334
nazwa, 96 ODCH.STANDARDOWE, 350 Option Button, 255
komórki, 317 ODCH.ŚREDNIE, 350 Option Compare, 334
miesiąca, 327 ODCIĘTA, 350 Option Explicit, 131, 334
pliku lub katalogu, 325 odczyt Option Private, 334
negacja, 342 danych z otwartego pliku, Or, 342
NewChart, 264 334 ORAZ, 350
NewSheet, 264 danych z sekwencyjnego Order, 290
NewWorkbook, 272 pliku, 334 1, 288
Nie, 168, 170 pojedynczej linii z otwartego 2, 288
NIE, 349 pliku tekstowego, 334 3, 288
niebieski, 204 zawartości komórek, 320 OrderCustom, 288
nierównoważność logiczna, 342 odejmowanie, 336 Orientation, 288
nierówny, 338 odinstalowanie skoroszytu, 272 osobisty skoroszyt makr, 51
nieukryte nazwy, 319 odległość otwarcie
NORMALIZUJ, 349 od górnej krawędzi, 259 pliku tekstowego, 334
Not, 342 od lewej krawędzi, 259 skoroszytu, 272, 261, 264
notatki, wyczyszczenie, 318 odrzucenie zmian w tabeli
przestawnej, 269
Now, 230, 327
odwołanie, 75
P
NPer, 327
NPER, 349 odwrotny paleta, 103
NPV, 327, 349 cosecans hiperboliczny, 325 barw, 100
Null, 326 cotangens hiperboliczny, 325 Palette, 100, 103
numer tygodnia, 360 secans hiperboliczny, 325 Parameters, 321
sinus hiperboliczny, 325 Parse, 319
tangens hiperboliczny, 325 Partition, 327
odwrócony łańcuch znaków, 328 pasek przewijania, 255, 259
Skorowidz 385
PasteSpecial, 319 kombi, 252, 254 Set, 334

PEARSON, 350 listy, 246, 255 prośba o wpisanie ciągu znaków,
PERCENTYL, 350 tekstowe, 254 162
PERMUTACJE, 350 wyboru, 255 PRÓG.ROZKŁAD.DWUM, 350
Personal xlsb, 51 połączenie łańcuchów, 326 przeciąganie i upuszczanie, 278
pętla, 207, 333, 335 pomoc, 170 przedział czasu, 324
programowa, 333 przycisk, 167 przekazanie wartości do
Phonetic, 320 wyświetlanie, 318, 320 procedury, 139
PI, 350 Ponów próbę, 168 przekształcanie wyrażenia, 324
Picture, 259 porównanie przeliczanie, 318
PIERWIASTEK, 350 łańcuchów znaków, 328 przemieszczenie wskaźnika
pierwiastek kwadratowy, 241, pozycji bitów, 354 myszy, 278
328 POTĘGA, 350 Przerwij, 168
pierwsza liczba w łańcuchu potęgowanie, 336 PRZESUNIĘCIE, 350
znaków, 328 POWT, 350 przewijanie formularza, 278
pierwszy znak tekstu, 365 POZYCJA, 350 przycisk, 101, 168, 170
pisanie programów, technika, pozycja dopasowanie do napisu, 105
296 w pliku, 327 napis, 104
pisownia, sprawdzanie, 318 wydruku, 328 OK, 168
PivotTableAfterValueChange, wystąpienia ciągu znaków, 326 polecenia, 255
269 PPmt, 327 Pomoc, 167
PivotTableBeforeAllocate PPMT, 350 przełącznika, 255
Changes, 269 PRAWDPD, 350 w oknie komunikatu, 165
PivotTableBeforeCommit PRAWY, 350 zdarzenie, 106
Changes, 269 Print #, 334 przykład zastosowania metody,
PivotTableBeforeDiscardChang PrintOut, 319 321
es, 269 PrintPreview, 319 przypisanie wartości wyrażenia
PivotTableChangeSync, 269 Private, 334 zmiennej, 334
PivotTableCloseConnection, 264 procedura, 332 przypisywanie makra, 65
PivotTableOpenConnection, 264 koniec, 117 przyszła wartość rocznej spłaty,
PivotTableUpdate, 269 obsługi błędów, 175, 334, 335 325
plik obsługi zdarzeń, 261 Public, 133, 334
atrybuty, 325, 335 początek, 117 punkt kodowy, 365
pozycja, 327 przekazanie wartości, 139 Put, 334
tekstowy, 334 wywołanie, 312 PV, 327, 350
zmiana nazwy, 334 zapętlona, 313
plik XML zewnętrzna, 332
aktualizacja, 263 Procedure, 263
Q
eksport, 263 procent, 325 QBColor, 327
import, 263, 264 PROCENT.POZYCJA, 350 QueryClose, 278
Pmt, 327 program Quit, 273
PMT, 350 rozgałęzienie, 334
PODAJ.POZYCJĘ, 350 zapętlony, 315
podgląd wydruku, 319 zatrzymanie, 335 R
podprogram, wywołanie, 310 programowanie R.KWADRAT, 350
podprogramy, 301 obiektowe, 372 RADIANY, 350
PODSTAW, 350 proceduralne, 371 RaiseEvent, 334
podtyp zmiennej, 328 Project, 93, 94 Randomize, 232, 233, 335
podzbiór tablicy łańcuchów prompt, 154, 164 Range, 221, 270, 320
znaków z uwzględnieniem Properties, 93, 99, 102, 104, Range.Copy, 281
filtru, 325 105, 256, 373 Range.Find, 296
pole Property, 189 Range.Sort, 287
edycji, 174 Get, 334 Rate, 327
grupy, 255 Let, 334
RATE, 350 ROZKŁAD.NORMALNY.S. Show, 320

Recenzja, 149 ODW, 351 ShowDependents, 320
ReDim, 335 ROZKŁAD.POISSON, 351 ShowErrors, 320
RefEdit, 255 ROZKŁAD.T, 351 SILNIA, 351
REGBŁSTD, 350 ROZKŁAD.T.ODW, 351 Sin, 327
REGEXPP, 350 ROZKŁAD.WEIBULL, 351 SIN, 351
REGEXPW, 350 rozsunięcie tekstu, 319 Single, 120, 333
REGLINP, 350 równość, 342 single-byte, 297
REGLINW, 350 równy, 338 SINH, 351
REGLINX, 350 RSet, 335 sinus hiperboliczny, 326
rejestrowanie makra, 60 RTD, 351 składnia metody, 321
Rem, 335 RTrim, 185, 327 skok
Remarks, 321 Run, 97, 320 bezwarunkowy, 215, 334
RemoveControl, 278 RZYMSKIE, 351 do podprogramu, 334
RemoveDuplicates, 319 skopiowanie
Replace, 327 ADO, 318
Require Variable Declaration, 130
S DAO, 318
Reset, 335 komórek, 318
SaveSetting, 335 obrazu, 318
Resize, 278 scalenie
Resume, 335 pliku, 333
danych, 318 skoroszyt
reszta z dzielenia, 336 komórek, 319 dezaktywacja otwartego, 272
Return Value, 321 schemat blokowy, 301 dezaktywacja, 264
RGB, 327 Scroll, 278 drukowanie, 263
Right, 182, 327 ScrollBar, 255 makr osobistych, 43, 60
RmDir, 335 ScrollBars, 259 odinstalowanie, 263, 272
Rnd, 232, 233, 327 SearchDirection, 297 otwieranie, 272, 261, 264
rok, 328 SearchFormat, 297 programu Excel z obsługą
ROK, 350 SearchOrder, 297 makr, 23, 36, 52, 70
Round, 327 Sec, 327 programu Excel, 37, 53, 71
RowDifferences, 320 secans hiperboliczny, 326, 364 synchronizacja, 264
RowSource, 250, 253, 259 Second, 327 uaktywnienie okna, 264
rozdzielenie zakresu danych, 319 Seek, 327, 335 uaktywnienie, 263, 269, 272
rozgałęzienie programu, 334 SEKUNDA, 351 utworzenie nowego arkusza,
ROZKŁAD.BETA, 350 sekundy, 327 272
ROZKŁAD.BETA.ODW, 350 Select, 190, 192, 320 utworzenie nowego, 272
ROZKŁAD.CHI, 350 Select Case, 226, 227, 229, 335 wydrukowanie, 272
ROZKŁAD.CHI.ODW, 350 SelectionChange, 269 zainstalowanie, 263, 272
ROZKŁAD.DWUM, 350 SendKeys, 335 zamykanie, 263, 272
ROZKŁAD.DWUM.PRZEC, 350 seria danych, 318 zapisanie, 263, 272
ROZKŁAD.EXP, 351 Set, 335 zmiana rozmiaru okna, 264
ROZKŁAD.F, 351 SetAttr, 335 SKOŚNOŚĆ, 351
ROZKŁAD.F.ODW, 351 SetPhonetic, 320 skrypt AppleScript, 326
ROZKŁAD.FISHER, 351 Sgn, 327 SLN, 327, 351
ROZKŁAD.FISHER.ODW, 351 SheetActivate, 264, 272 Sort, 288, 320
ROZKŁAD.GAMMA, 351 SheetBeforeDoubleClick, 264, SortMethod, 288
ROZKŁAD.HIPERGEOM, 351 272 sortowanie, 288
ROZKŁAD.LIN.GAMMA, 351 SheetBeforeRightClick, 264, 272 danych, 320
ROZKŁAD.LOG, 351 SheetCalculate, 264, 272 elementów, 288
ROZKŁAD.LOG.ODW, 351 SheetChange, 264, 267, 272, 280 kolejność, 288
ROZKŁAD.NORMALNY, 351 SheetDeactivate, 264, 272 metoda, 288
ROZKŁAD.NORMALNY.ODW, SheetFollowHyperlink, 264, 272 nagłówek, 288
351 SheetPivotTableUpdate, 264, 272 porządek, 288
ROZKŁAD.NORMALNY.S, SheetSelectionChange, 264, 272 przesunięcie na liście, 288
351 Shell, 327 wielkość liter, 288
Skorowidz 387
Space, 327 kontrolki, 259 TextAlign, 259

spadek wartości środka pliku, 335 TextBox, 254
trwałego, 325 SZUKAJ.TEKST, 351 TextToColumns, 320
Spc, 327 Time, 328, 335
Speak, 320 Time$, 173
SpecialCells, 320
Ś Timer, 328
SpinButton, 255 ścieżka bieżącego katalogu, 324 TimeSerial, 328
Split, 327 ŚREDNIA, 351 TimeValue, 328
sprawdzanie pisowni, 318 ŚREDNIA.GEOMETRYCZNA, title, 154, 165
Sqr, 328 351 tło
stała, 332 ŚREDNIA.HARMONICZNA, kolor, 259
standardowa szerokość arkusza, 352 kontrolki, 259
96 ŚREDNIA.WEWN, 352 Toggle Button, 255
StandardWidth, 96 Toolbox, 99, 247
StartUpPosition, 101 Tools, 97
Static, 132, 335 T Top, 259
sterowanie dostępem, 334 Tab, 328 TRANSPONUJ, 352
Stop, 335 tabela danych, 320 Trim, 186
stopa procentowa, 364 tabela przestawna Trim s, 328
stopa zwrotu dla ciągu aktualizacja, 269 trójwymiarowa tablica, 237
przepływów gotówkowych, 326 odrzucenia zmian, 269 True, 122
STOPNIE, 351 otwarcie połączenia ze typ
Str, 328 źródłem danych, 264 danych użytkownika, 335
StrComp, 328 synchronizacja, 269 danych, 328
StrConv, 328 wprowadzenie danych, 264, wyliczeniowy, 333
String, 121, 141, 175, 328, 333 272 zmiennej, 175
StrReverse, 328 zamknięcie połączenia ze Type, 121, 288, 335
strzałka, 255 źródłem danych, 264 TypeName, 328
Sub, 40, 57, 74, 335 zmiana wartości, 269 tytuł okna, 155
SubscribeTo, 320 zmiany alokacji, 269
SUMA, 351
suma logiczna, 342
Table, 320 U
tablica, 237, 240, 326
SUMA.ILOCZYNÓW, 351 lokalna, 334 uaktywnienie
SUMA.JEŻELI, 351 zainicjowanie elementów, 333 komórki, 317
SUMA.KWADRATÓW, 351 zmiana wymiarów, 335 okna aplikacji, 332
SUMA.X2.M.Y2, 351 TabStrip, 255 okna skoroszytu, 272
SUMA.X2.P.Y2, 351 Tak, 168, 170 skoroszytu, 269, 272
SUMA.XMY.2, 351 Tan, 328 UBound, 328
sumowanie n liczb naturalnych, TAN, 352 UCase, 328
236 tangens hiperboliczny, 326 UFNOŚĆ, 352
SUMY.POŚREDNIE, 351 TANH, 352 Ungroup, 320
Switch, 328 Target, 270 Unload, 249, 335
SYD, 328, 351 tekst Unlocks, 334
symbol długość, 184 UnMerge, 320
błędu, 82, 89 rozsunięcie, 319 upuszczanie danych, 278
informacji, 82, 89 wyrównanie, 259 uruchomienie
symulacja TEKST, 352 makropolecenia, 320
błędu, 333 TERAZ, 352 programu, 89
pisania z klawiatury, 335 Terminate, 278 UserForm, 99, 278
Sync, 264 TEST.CHI, 352 usunięcie
Syntax, 321 TEST.F, 352 folderu, 335
Syntax error, 119 TEST.T, 352 formatowania z komórek, 193
szerokość TEST.Z, 352 formularza, 278
kolumny, 317 katalogu, 335
usunięcie vbYesNoCancel, 165, 171 With, 335

kontrolki, 278 VDB, 352 wklejanie danych, 278
obiektu z pamięci, 335 Vertical spacing, 112 właściwości, 189, 256, 373
obiektu, 318 View, 97 projektów, 93
pliku, 334 View Code, 275 WordWrap, 259
zawartości z komórek, 193, 194 VisibleDropDown, 293 WorkbookActivate, 272
zdublowanych obiektów, 319 Visual Basic, 8 WorkbookAddinInstall, 272
znaków białych, 185 Visual Basic for Applications, 7 WorkbookAddinUninstall, 272
USUŃ.ZBĘDNE.ODSTĘPY, 352 WorkbookAfterXMLExport,
utworzenie 272
katalogu, 334
W WorkbookAfterXMLImport,
nazw na podstawie etykiet WARIANCJA, 352 272
tekstowych, 318 WARIANCJA.POPUL, 352 WorkbookBeforeClose, 272
nowego arkusza, 272 wartość WorkbookBeforePrint, 272
obiektów Phonetic, 320 bezwzględna, 324 WorkbookBeforeSave, 272
tabeli danych, 320 ciągu wyrażeń logicznych, 328 WorkbookBeforeXMLExport,
w serii danych, 318 domyślna, 144, 259 272
inwestycji, 327 WorkbookBeforeXMLImport,
272
V kapitału dla raty pożyczki, 327
WorkbookDeactivate, 272
licznika, 231
Val, 328 logiczna, 121 WorkbookNewSheet, 272
Value, 197 netto, 327 WorkbookOpen, 272
Variant, 121, 125, 127, 141, stopy procentowej, 364 wpisywanie danych, 302
199, 292, 333 właściwości, 324 wpisywanie słowa do komórek,
VarType, 328 z listy argumentów, 324 198
VBA, 7, 8, 113 zmiennych, 308 Write #, 335
kiedy stosować, 13 WARTOŚĆ, 352 WSP.KORELACJI, 352
vbAbortRetryIgnore, 165 warunek, 241 wstawianie
vbApplicationModal, 167 warunkowe komórki, 319
vbBlack, 204 wykonanie grupy instrukcji, obiektu Range, 319
vbBlue, 204 334 wycięcia, 319
vbCritical, 166 wykonanie instrukcji, 335 wstążka, 10
vbCyan, 205 wciśnięcie wstrzymanie programu, 326
vbDefaultButton, 171 klawisza, 278 WYBIERZ, 352
vbDefaultButton1, 167 przycisku myszy, 278 wycięcie
vbDefaultButton2, 167 wczytanie adresu komórki, 159 obiektów, 318
vbDefaultButton3, 167 Weekday, 328 wstawianie, 319
VbDefaultButton4, 167 WeekdayName, 328 wyczyszczenie
vbExclamation, 166 wejście aplikacji w rejestrze formatów, 318
vbGreen, 204 Windows, 325 formuły, 318
vbInformation, 166 wewnętrzna stopa zwrotu dla komentarza, 318
vbMagenta, 204 ciągu okresowych notatek, 318
vbMsgBoxHelpButton, 167, 171 przepływów gotówkowych, obiektu, 318
vbMsgBoxRight, 167 327 wydruk
vbMsgBoxRtlReading, 167 What, 296 otwartego skoroszytu, 272
vbOKCancel, 165 While...Wend, 335 podgląd, 319
vbOKOnly, 165 Width, 259 wyeksportowanie pliku XML,
vbQuestion, 166, 171 Width #, 335 272
vbRed, 204 wielkie litery, 328 wygenerowanie zdarzenia, 334
vbRetryCancel, 166 większy lub równy, 339 wygląd kursora, 259
vbSystemModal, 167 większy niż, 339 wyjście z
vbWhite, 205 Window, 98 bloku pętli, 333
vbYellow, 204 WindowActivate, 264, 272 z funkcji, 333
vbYesNo, 166 WindowResize, 264, 272 z procedury, 333
Skorowidz 389
wykonanie obliczeń, 272 XML, 272 w pliku, 335

wykres, tworzenie, 264 Xor, 342 w rejestrze Windows, 335
wyliczanie wyrażenia, 326 xpos, 154 zmiennej do pliku
wymuszenie deklaracji tekstowego, 334
zmiennych, 334 zasięg
wypełnianie komórek, 317, 319
Y lokalny, 304
wyrównanie Year, 328 przypisania wartości
do lewej, 334 ypos, 154 zmiennej, 136
tekstu, 259 ZASTĄP, 352
znaków do prawej, 335 zastąpienie znaków, 334
wyróżnienie, zakres, 317 Z zatrzymanie programu, 335
wysłanie kodów wciśniętych zaimportowanie pliku XML, 272 zawijanie opisów, 259
klawiszy, 335 zainicjowanie elementów zaznaczanie, 317, 320
wysokość wiersza, dopasowanie, tablicy, 333 komórek, 190
317 zainstalowanie skoroszytu, 272 w arkuszu, 269
WYST.NAJCZĘŚCIEJ, 352 zakładkowe okno dialogowe, modyfikacja, 269
WYSZUKAJ, 352 255 zaznaczony zakres,
WYSZUKAJ.PIONOWO, 352 zakończenie wyświetlenie, 320
WYSZUKAJ.POZIOMO, 352 bloku, 333 zdarzenie, 261, 373
wyszukiwanie, 296, 319 procedury, 333 deklaracja, 333
całe słowa, 296 programu, 333 zdublowane obiekty, 319
ciągi znaków, 296 zakres, 327 zezwól na wykonywanie
formatu, 297 arkusza, 255 obliczeń, 96
formuły, 296 danych, 319 zgodność wsteczna, 10
kierunek, 297 komórek, 253, 259 zielononiebieski, 205
kolumnami, 297 obiektu, 318, 320 zielony, 204
kontynuowanie, 319 wyróżnienie, 317 ZŁĄCZ.TEKSTY, 352
niepustych pól, 293 zależność, 320 zmiana
powtórzenie, 297 zaktualizowanie obliczeń, 269 alokacji tabeli przestawnej,
pustych pól, 293 zależność zakresu, 320 269
wielkość liter, 297 załadowanie obiektu, 334 nazwy katalogu, 334
wierszami, 297 zamiana nazwy pliku, 334
wyświetlanie ciąg znaków na datę, 324 rozmiaru formularza, 278
okna komunikatu, 164 daty na liczbę, 324 rozmiaru okna skoroszytu, 272
pomocy, 318, 320 liczby na znaki, 328 w tabeli przestawnej, 269
zaznaczonego zakresu, 320 zamknięcie wartości w tabeli przestawnej,
wywołanie metody, 321 formularza, 249, 278 269
WYZNACZNIK.MACIERZY, plików dyskowych, 335 wielkości formularza, 278
352 pliku, 332 wymiarów tablicy, 335
wznowienie wykonywania skoroszytu, 272 zawartości komórki, 269
programu, 335 ZAOKR, 35 zaznaczenia, 272
ZAOKR.DO.CAŁK, 352 zmienna, 115
deklaracja, 130
X ZAOKR.DO.NPARZ, 352
globalna, 137, 304, 305, 307
ZAOKR.DO.PARZ, 352
xl Part, 296 ZAOKR.DO.TEKST, 352 lokalna, 132, 334
xlAscending, 290 ZAOKR.DÓŁ, 352 na poziomie procedury, 335
XlAutoFilterOperator, 293 ZAOKR.GÓRA, 352 nazwa, 116, 117
xlByColumns, 297 ZAOKR.W.DÓŁ, 352 środowiskowa systemu
xlByRows, 297 ZAOKR.W.GÓRĘ, 352 operacyjnego, 325
xlFormulas, 296 zapętlony program, 315 tekst, 140
xlNext, 297 zapis wartość domyślna, 144
xlPrevious, 297 danych do pliku, 335 zasięg, 304
xlWhole, 296 otwartego skoroszytu, 272 ZNAJDŹ, 352
xlYes, 290
znak, 324
liczby, 327
ZNAK.LICZBY, 352
Zoom, 278
Ź
z łańcucha, 326 zwolnienie źródło błędów, 320
z pliku, 326 klawisza, 278
ZNAK, 352 przycisku myszy, 278

VBA Dla Excela 2016 PL. 222 Praktyczne Przykłady - Witold Wrotek

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

VBA Dla Excela 2016 PL. 222 Praktyczne Przykłady - Witold Wrotek

Hochgeladen von

Copyright:

Verfügbare Formate

Wszelkie prawa zastrzeżone.

Nieautoryzowane rozpowszechnianie całości

Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi

Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte

Redaktor prowadzący: Michał Mrowiec

Kody źródłowe wybranych przykładów dostępne są pod adresem:

Copyright © Helion 2016

 Poleć książkę na Facebook.com  Księgarnia internetowa

Pierwszy program . ........................................................................................................... 98

Wykonanie grupy instrukcji określoną liczbę razy ........................................................ 231

Modele obiektowe . ........................................................................................................ 374

Napisany w nim program, którego zastosowanie pozwalało drukować zadaną liczbę

Liczby po lewej stronie to numery linii. Wpisywano je ręcznie. Numerowano je co

Visual Basic for Applications

VB był wyposażony w dobrodziejstwa, które przyniósł system Windows. Zamiast

VBA został zaimplementowany w aplikacjach pakietu Microsoft Office (rysunek W.2).

Rysunek W.2. Okno VBA

VBA nie pozwala na kompilowanie programów i zapisywanie ich do plików wykony-

Program napisany w VBA wymaga do pracy zainstalowanej w komputerze odpowied-

Microsoft Access Runtime pozwala na uruchamianie plików Accessa bez konieczności

Czy VBA jest przeżytkiem?

VBA i Office 2007, 2010, 2013, 2016

Wraz z wprowadzeniem Windows 7 oraz Office 2010 VBA programistom stworzono

Zmieniony wygląd okna programu

Makropolecenia w Microsoft Office 2007,

Tabela w.1. Wybrane rozszerzenia plików programów Word i Excel

Za pomocą programów wchodzących w skład pakietów Microsoft Office 2007,

Bezpieczeństwo w Microsoft Office 2007,

Jaką funkcję może pełnić VBA?

Komputer wraz z odpowiednim oprogramowaniem również może stanowić uzupełnie-

Człowiek, który ma wyszukać w dokumencie wszystkie znaki wyróżnione kolorem

Kiedy warto stosować VBA?

Kiedy nie warto stosować VBA?

Kopiowany ze schowka tekst przyjmuje formatowanie dokumentu, do którego jest wsta-

Zdecydowanie, ale to zdecydowanie, odradzam rozpoczynanie pisania programu, jeśli

Makro jest sekwencją automatycznie wykonywanych instrukcji VBA. Ma ono własną

Polecenia wykonywane podczas rejestrowania makra są zapisywane do pliku. Makro-

Jak zarejestrować makropolecenie i edytować je, dowiesz się z kolejnego rozdziału.

Przypadek 1. Wykonujesz określoną pracę przy wykorzystaniu programu z pakietu

Microsoft Office 2007,

Planując makropolecenie, zastanów się, jakie elementarne czynności trzeba wykonać,

Wcześniejsze wersje pakietu

Rysunek 1.1. Okno Excel 2007

Aby zarejestrować makropolecenie:

5. Makropolecenie może być uruchamiane po wybraniu polecenia Wyświetl

Rysunek 1.3. Polecenie umożliwia zakończenie rejestrowania makropolecenia

11. Kliknij czarną strzałkę widoczną pod przyciskiem Makra.

4. Zostało wyświetlone okno Makro (rysunek 1.5).

5. Zaznacz makropolecenie, które chcesz otworzyć do edycji.

3. Został wyświetlony komunikat informujący o tym, że w skoroszycie Microsoft

Rysunek 1.9. Arkusze można zapisywać w wielu formatach

5. Kliknij przycisk Zapisz.

Rysunek 1.10. Zmiana nazwy pliku jest konieczna

8. Kliknij przycisk Zapisz.

Microsoft Office 2010

Planowanie i rejestrowanie makropolecenia

2. Skopiować dane z zaznaczonego obszaru do schowka, np. posługując się

3. Umieścić kursor w komórce C1. Możesz to zrobić, klikając komórkę C1

4. Wkleić zawartość schowka, np. posługując się kombinacją klawiszy Ctrl+V

5. Wcisnąć klawisz Esc (rysunek 1.19).

„Próba generalna” wypadła pomyślnie. Dane z obszaru A1 – A3 zostały skopiowane

2. Odszukaj sekcję Kod.

4. Zostało wyświetlone okno dialogowe Rejestrowanie makra. W polu Nazwa

5. Makropolecenie może być uruchamiane po naciśnięciu skrótu klawiaturowego.