This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Spis Treści SPIS TREŚCI........................................................................................................................................................ 1 ROZDZIAŁ 1. TWORZENIE DYNAMICZNYCH APLIKACJI INTERNETOWYCH............................. 6 CZYM BYŁA SIEĆ WWW ..................................................................................................................................... 6 Specyfikacja HTML 2 ..................................................................................................................................... 7 Specyfikacja HTML 3.2 .................................................................................................................................. 8 Specyfikacja HTML 4 ..................................................................................................................................... 8 ZAWARTOŚĆ STATYCZNA A ZAWARTOŚĆ DYNAMICZNA ...................................................................................... 8 TWORZENIE SKRYPTÓW PO STRONIE KLIENTA I PO STRONIE SERWERA............................................................... 10 Tworzenie skryptów po stronie klienta ......................................................................................................... 10 Tworzenie skryptów po stronie serwera ....................................................................................................... 14 SKŁADNIKI DYNAMICZNYCH ROZWIĄZAŃ INTERNETOWYCH ............................................................................. 17 Przejście przez stronę quizu ......................................................................................................................... 18 HTML ........................................................................................................................................................... 18 Składnik bazy danych ................................................................................................................................... 19 Komponenty serwera .................................................................................................................................... 22 Kod ASP (Active Server Page) ..................................................................................................................... 26 Współpraca z serwerem internetowym .................................................................................................... 28 NIE TYLKO IIS SYSTEMU NT ............................................................................................................................. 29 ROZDZIAŁ 2. SERWER IIS WIDZIANY Z PERSPEKTYWY TWÓRCY STRON ................................ 30 CZYM JEST IIS? ................................................................................................................................................. 30 OTRZYMYWANIE KOPII IIS ................................................................................................................................ 31 KONSOLA ZARZĄDZANIA MICROSOFTU ............................................................................................................. 31 WŁAŚCIWOŚCI USŁUG WWW............................................................................................................................ 33 Właściwości witryny WWW .......................................................................................................................... 34 Właściwości związane z wydajnością........................................................................................................... 36 Właściwości filtrów ISAPI............................................................................................................................ 37 Właściwości katalogu macierzystego ........................................................................................................... 37 Dokumenty.................................................................................................................................................... 38 Błędy klienta ................................................................................................................................................. 39 WITRYNY WWW W SERWERZE IIS ................................................................................................................... 40 DODAWANIE WITRYNY WWW .......................................................................................................................... 42 WŁAŚCIWOŚCI WITRYNY WWW ....................................................................................................................... 45 Wiele witryn pod jednym adresem IP........................................................................................................... 45 Zakładka właściwości witryny WWW........................................................................................................... 47 Właściwości katalogu macierzystego ........................................................................................................... 48 EKSPLORACJA WITRYNY .................................................................................................................................... 48 Katalogi wirtualne........................................................................................................................................ 49 Właściwości folderu i pliku .......................................................................................................................... 51 APLIKACJE ASP ................................................................................................................................................ 52 Zmienne trwałe i zakresowe ......................................................................................................................... 52 Zdarzenia...................................................................................................................................................... 53 Tworzenie aplikacji ASP .............................................................................................................................. 53
Spis Treści
2
Konfigurowanie aplikacji ASP ..................................................................................................................... 55 WITRYNY FTP................................................................................................................................................... 58 ROZDZIAŁ 3. NARZĘDZIA PRACY............................................................................................................. 60 PRZEGLĄD APLIKACJI DO TWORZENIA STRON .................................................................................................... 60 NOTATNIK ......................................................................................................................................................... 60 FRONTPAGE 2000.............................................................................................................................................. 62 Środowisko pracy ......................................................................................................................................... 62 Tworzenie sieci Web ..................................................................................................................................... 68 Przeglądanie strony...................................................................................................................................... 70 Dodawanie strony......................................................................................................................................... 71 Praca ze stroną............................................................................................................................................. 72 NETOBJECTS FUSION ......................................................................................................................................... 74 Środowisko pracy ......................................................................................................................................... 74 Tworzenie witryny WWW przy użyciu programu Fusion ............................................................................. 80 Praca ze stroną............................................................................................................................................. 80 NETOBJECTS SCRIPTBUILDER ........................................................................................................................... 81 Środowisko programowe .............................................................................................................................. 81 Praca z kodem w programie ScriptBuilder .................................................................................................. 87 Weryfikacja kodu w programie ScriptBuilder.............................................................................................. 92 MICROSOFT VISUAL INTERDEV 6.0................................................................................................................... 94 OSTATNIE SŁOWO O NARZĘDZIACH.................................................................................................................... 96 ROZDZIAŁ 4. PODSTAWY ASP .................................................................................................................... 97 KONSTRUKCJA KODU ASP................................................................................................................................. 97 Znacznik <% = X %> .................................................................................................................................. 97 <% Pojedyncza linia kodu %> .................................................................................................................... 98 <% Blok kodu %>........................................................................................................................................ 99 < Script> Kod ........................................................................................................................... 100 HTML w kodzie .......................................................................................................................................... 101 SKRYPT W SKRYPCIE........................................................................................................................................ 103 Dyrektywa przetwarzania........................................................................................................................... 105 Pliki Include ............................................................................................................................................... 106 Po co ich używać .................................................................................................................................... 106 Włączanie pliku ...................................................................................................................................... 106 Plik Include — struktura i przykład ....................................................................................................... 107 Wywoływanie procedur ......................................................................................................................... 108 KOD ASP W UŻYCIU ........................................................................................................................................ 108 Komentarze, puste miejsca i wielkość liter ................................................................................................ 108 Zmienne ...................................................................................................................................................... 111 Typy danych................................................................................................................................................ 112 Zakres i trwałość ........................................................................................................................................ 113 Operatory ................................................................................................................................................... 114 Warunki ...................................................................................................................................................... 116 Pętle............................................................................................................................................................ 121 Konwersja zmiennych................................................................................................................................. 125 Funkcje daty i czasu ................................................................................................................................... 127 Zatwierdzanie obecności i typów danych ................................................................................................... 131 Techniki zatwierdzania danych .................................................................................................................. 133 Formatowanie liczb, dat i kwot pieniężnych .............................................................................................. 135 Operowanie ciągami .................................................................................................................................. 139 Liczby losowe ............................................................................................................................................. 145 Procedury ................................................................................................................................................... 146 ROZDZIAŁ 5. OBIEKT REQUEST.............................................................................................................. 148
3
ASP – Kompendium programisty
HIERARCHIA I MODELE OBIEKTÓW ASP .......................................................................................................... 148 Czym są hierarchie obiektów? ................................................................................................................... 148 Model obiektów ASP .................................................................................................................................. 149 ODBIERANIE INFORMACJI OD ODWIEDZAJĄCEGO ............................................................................................. 151 Zbiory obiektu Request ............................................................................................................................... 151 Zbiór Form.............................................................................................................................................. 151 Zbiór QueryString .................................................................................................................................. 154 Zbiór ServerVariables ............................................................................................................................ 157 Zbiór Cookies ......................................................................................................................................... 159 Zbiór ClientCertificate ........................................................................................................................... 160 WŁAŚCIWOŚĆ OBIEKTU REQUEST .................................................................................................................... 161 Właściwość TotalBytes ............................................................................................................................... 161 METODA OBIEKTU REQUEST ........................................................................................................................... 162 Metoda BinaryRead.................................................................................................................................... 162 OBIEKT REQUEST W DZIAŁANIU ...................................................................................................................... 163 Przykład certyfikatu klienta........................................................................................................................ 163 Procesor e-mail dla formularza ................................................................................................................. 168 Procesor bazy danych dla formularza........................................................................................................ 172 Witryna logowania ..................................................................................................................................... 174 ROZDZIAŁ 6. OBIEKT RESPONSE............................................................................................................ 180 WYSYŁANIE INFORMACJI DO GOŚCI ................................................................................................................. 180 ZBIÓR OBIEKTU RESPONSE .............................................................................................................................. 180 Zbiór cookie................................................................................................................................................ 181 WŁAŚCIWOŚCI OBIEKTU RESPONSE ................................................................................................................. 184 Właściwość Buffer ...................................................................................................................................... 184 Właściwość CacheControl ......................................................................................................................... 186 Właściwość Charset ................................................................................................................................... 186 Właściwość ContentType............................................................................................................................ 186 Właściwość Expires .................................................................................................................................... 187 Właściwość ExpiresAbsolute ...................................................................................................................... 188 Właściwość IsClientConnected .................................................................................................................. 190 Właściwość PICS........................................................................................................................................ 191 Właściwość Status ...................................................................................................................................... 192 METODY OBIEKTU RESPONSE .......................................................................................................................... 192 Metoda AddHeader .................................................................................................................................... 193 Metoda AppendToLog ................................................................................................................................ 193 Metoda BinaryWrite ................................................................................................................................... 193 Metoda Clear.............................................................................................................................................. 196 Metoda End ................................................................................................................................................ 196 Metoda Flush.............................................................................................................................................. 197 Metoda Redirect ......................................................................................................................................... 198 Metoda Write .............................................................................................................................................. 199 OBIEKT RESPONSE W DZIAŁANIU ..................................................................................................................... 199 Readresowanie i obiekt wyboru ................................................................................................................. 199 Pasek zaawansowania ................................................................................................................................ 203 Strona preferencji....................................................................................................................................... 207 ROZDZIAŁ 7. OBIEKT SERVER................................................................................................................. 212 WEJŚCIE NA SZCZYT ........................................................................................................................................ 212 WŁAŚCIWOŚĆ OBIEKTU SERVER ...................................................................................................................... 212 Właściwość ScriptTimeout ......................................................................................................................... 213 METODY OBIEKTU SERVER .............................................................................................................................. 214 Metoda CreateObject ................................................................................................................................. 215 Metoda HTMLEncode ................................................................................................................................ 218
Spis Treści
4
Metoda MapPath ........................................................................................................................................ 219 Metoda URLEncode ................................................................................................................................... 221 OBIEKT SERVER W DZIAŁANIU ........................................................................................................................ 222 Automatyzacja biura................................................................................................................................... 222 ROZDZIAŁ 8. OBIEKT SESSION, OBIEKT APPLICATION ORAZ PLIK GLOBAL.ASA............... 232 APLIKACJE ASP .............................................................................................................................................. 232 TWORZENIE APLIKACJI ASP ............................................................................................................................ 233 OBIEKT SESSION .............................................................................................................................................. 235 Zbiory obiektu Session................................................................................................................................ 235 Zbiór Contents ........................................................................................................................................ 235 Zbiór StaticObjects................................................................................................................................. 239 Właściwości obiektu Session ...................................................................................................................... 240 Właściwość CodePage............................................................................................................................ 241 Właściwość LCID .................................................................................................................................. 242 Właściwość SessionID ........................................................................................................................... 244 Właściwość TimeOut ............................................................................................................................. 244 Metoda obiektu Session .............................................................................................................................. 245 Metoda Abandon .................................................................................................................................... 245 OBIEKT APPLICATION ...................................................................................................................................... 246 Zbiory obiektu Application ......................................................................................................................... 246 Zbiór Contents ........................................................................................................................................ 246 Zbiór StaticObjects................................................................................................................................. 250 Metody obiektu Application........................................................................................................................ 251 Metoda Lock........................................................................................................................................... 251 Metoda Unlock ....................................................................................................................................... 253 PLIK GLOBAL.ASA............................................................................................................................................ 253 Zdarzenia pliku global.asa ......................................................................................................................... 255 Zdarzenie Application_OnStart.............................................................................................................. 255 Zdarzenie Application_OnEnd............................................................................................................... 259 Zdarzenie Session_OnStart .................................................................................................................... 259 Zdarzenie Session_OnEnd ..................................................................................................................... 261 Deklaracje obiektów w pliku global.asa................................................................................................. 263 APLIKACJE ASP W UŻYCIU .............................................................................................................................. 264 ROZDZIAŁ 9. OBIEKTY CDO DLA WINDOWS NT SERVER .............................................................. 266 UZUPEŁNIENIE STRONY ASP O FUNKCJĘ WYSYŁANIA WIADOMOŚCI E-MAIL ................................................... 266 OBIEKT NEWMAIL .......................................................................................................................................... 267 Właściwości obiektu NewMail.................................................................................................................... 268 Właściwość To ....................................................................................................................................... 268 Właściwość From ................................................................................................................................... 269 Właściwość Subject................................................................................................................................ 270 Właściwość Body ................................................................................................................................... 270 Właściwość CC ...................................................................................................................................... 273 Właściwość BCC.................................................................................................................................... 273 Właściwość Importance.......................................................................................................................... 274 Właściwości BodyFormat i MailFormat ................................................................................................ 275 Właściwości ContentBase i ContentLocation ........................................................................................ 278 Właściwość Value .................................................................................................................................. 279 Właściwość Version ............................................................................................................................... 280 Metody obiektu NewMail............................................................................................................................ 281 Metoda Send........................................................................................................................................... 281 Metoda AttachFile .................................................................................................................................. 282 Metoda AttachURL ................................................................................................................................ 284 Metoda SetLocaleID............................................................................................................................... 285
5
ASP – Kompendium programisty
OBIEKT NEWMAIL W DZIAŁANIU .................................................................................................................... 285 ROZDZIAŁ 10. SKŁADNIKI ASP ................................................................................................................ 287 OBIEKTY ZWIĘKSZAJĄCE MOŻLIWOŚCI STRON ASP......................................................................................... 287 SKŁADNIK BROWSER CAPABILITIES ................................................................................................................ 287 Modyfikacja pliku browser.ini.................................................................................................................... 295 SKŁADNIK AD ROTATOR ................................................................................................................................. 296 SKŁADNIK PAGE COUNTER.............................................................................................................................. 303 SKŁADNIK COUNTERS ..................................................................................................................................... 311 SKŁADNIK CONTENT LINKING ......................................................................................................................... 316 SKŁADNIK CONTENT ROTATOR ....................................................................................................................... 324 SKŁADNIK MYINFO ......................................................................................................................................... 328
Rozdział 1. Tworzenie dynamicznych aplikacji internetowych Czym była sieć WWW Przez minione lata Internet niesamowicie wpłynął na nasze życie. Światowa sieć jest teraz potężnym zlepkiem informacji. Obecnie kiedy chcemy poznać adres firmy lub nawet jej lokalizację, sprawdzamy to w Internecie. Chcesz wiedzieć jaka sztuka jest wystawiana w miejscowym teatrze? Sprawdź w Internecie. Musisz poznać ceny jakiegoś produktu? Zobacz w sieci WWW. Szukasz pracy w Des Moines? Znajdziesz ją na sieci. Ale sieć WWW nie była tak nasycona informacjami od samego początku. Podstawowym przeznaczeniem Internetu była wymiana informacji pomiędzy badaczami naukowymi. Stworzenie języka HTML (HyperText Markup Language) było podyktowane koniecznością znalezienia powszechnej formy prezentowania informacji na różnorodnych platformach i systemach operacyjnych. Komputery używane do przeglądania stron HTML miały zainstalowane programy klienckie oraz przeglądarki, które odczytywały i interpretowały kod HTML, a następnie przedstawiały jego interpretację osobie oglądającej stronę. Te podstawowe przeznaczenie pozostało siłą Internetu, choć drastycznie zmieniły się sposoby prezentowania informacji. Wczesna wersja strony WWW wyglądała podobnie jak ta pokazana na rysunku 1.1.
7
ASP – Kompendium programisty
Rysunek 1.1. Pierwotna wersja HTML Zauważ, że pierwsza wersja HTML zawierała jedynie podstawowe informacje, jak również miała możliwość odsyłania do innych dokumentów. Już wczesna wersja posiadała zdolność zignorowania tych znaczników, których nie potrafiła zrozumieć. Jest to w dalszym ciągu znacząca cecha HTML, z której twórcy stron korzystają przez cały czas. Ale w tej wersji z roku 1992 nie było możliwości prezentowania informacji graficznych, takich jak obrazy, tabele czy obiekty. Zauważ również, że nie było wtedy sposobu na uzyskanie informacji od osoby przeglądającej stronę WWW.
Specyfikacja HTML 2 Kolejna wersja HTML zawierała wspaniałe ulepszenia. Rysunek 1.2. pokazuje niektóre elementy, które mogła zawierać wersja 2 specyfikacji HTML.
Rysunek 1.2. Przykładowa strona stworzona przy wykorzystaniu HTML 2 Prawdopodobnie najważniejszymi nowymi składnikami HTML 2 były znaczniki tabeli, obrazu i formularza. Znacznik tablicy po raz pierwszy pozwolił na wyświetlenie informacji w postaci tabeli. Było to jednak jego pierwotne przeznaczenie. Szybko stał się spełnieniem marzeń tych twórców stron WWW, którzy potrzebowali lepszego rozmieszczenia elementów na stronie. Teraz twórcy stron często używają znaczników tabeli do precyzyjnego rozłożenia pozycji na stronie WWW. Znacznik obrazu pozwalał twórcom na dekorowanie swych stron. Mogli umieszczać na nich logo firmy, zdjęcia pracowników oraz zdjęcia okolicznościowe. Grafika również mogła być wykorzystywana do dekoracji układu strony. Dodatkowo używano małych, niewidocznych obrazków przy pomocy których rozmieszczano inne elementy strony WWW. Na przykład niektórzy twórcy stron używali pustych obrazków o określonym rozmiarze do zaznaczenia akapitu. Specyfikacja HTML 2 dodatkowo została wzbogacona w formularze. Przed użyciem formularzy kontakt z odwiedzającymi stronę był bardzo ograniczony. Dzięki formularzom i ich standardowym elementom możliwe stało się gromadzenie informacji o gościach pozwalających na udostępnianie im właściwej strony, gromadzenie informacji osobistych oraz dodawanie gości do listy dystrybucyjnej lub wielu innych aplikacji. Zawartość formularzy była udostępniana programom CGI (CGI — Common Gateway Interface) do przetwarzania w postaci strumienia bajtów. Programy CGI, zwykle pisane w PERL lub C, mogły dokonać analizy składniowej danych w strumieniu, przetwarzać je, aby później zwrócić wyjściowe informacje przeglądarce.
Specyfikacja HTML 3.2 Kolejną znaczącą wersją HTML wydaną przez W3C Consortium była wersja 3.2, która już w niewielkim stopniu różniła się od tego, czym HTML jest dzisiaj. Do istniejących znaczników dodano liczne parametry i unowocześnienia, jak również wprowadzono nowe znaczniki, z których najważniejszym był znacznik apletu. Znacznik apletu pozwalał twórcom na włączenie aplikacji Javy wprost do ich stron WWW. Takie dodatki jak aplety Javy mogły być pełnymi aplikacjami realizującymi różnorakie zadania. Mogłeś stworzyć przy ich użyciu wysuwane obrazki, które odsyłały gości do różnych miejsc, kiedy kliknęli jeden z nich. Mogłeś mieć aplet Javy prezentujący uaktualnione dane na temat cen produktów. Mogłeś napisać applet Javy będący programem do rysowania dla dzieci. Liczba aplikacji, dla których znacznik ten był wykorzystywany była wielka, co spowodowało znaczny rozrost sieci WWW.
Specyfikacja HTML 4 HTML 4 jest bieżącą wersją wydaną przez W3C Consortium. Znaczącymi dodatkami tej specyfikacji są znaczniki obiektu, skryptu oraz formularza stylów. Znacznik formularza stylów pozwala na tworzenie wspólnych stylów dla elementów strony WWW. Kiedy styl zostaje zdefiniowany, może zostać przeniesiony na inną stronę. Pozwala to na przykład na jednorazowe zdefiniowanie koloru, rozmiaru i czcionki nagłówka. Następnie ten styl może zostać zastosowany na wielu innych stronach. Jeśli konieczna jest zmiana stylu nagłówka, należy jej dokonać tylko w jednym miejscu, w definicji elementu, a zmiana ta zostanie przeniesiona na inne strony korzystające z tego znacznika. Znacznik skryptu pozwala na włączenie kodów zwanych skryptami po stronie klienta (client-side scripts). Oznacza to, że w HTML wbudowano kod, który jest uruchamiany przez przeglądarkę zainstalowaną na komputerze klienta. Przyjrzymy się skryptom po stronie klienta nieco dalej w tym rozdziale, podczas omawiania zalet i wad tego rodzaju tworzenia skryptów. Kolejnym znaczącym ulepszeniem w tej wersji jest włączenie do niej znacznika obiektu, który dostarcza mechanizmów pozwalających na umieszczenie multimediów i innych obiektów w granicach strony WWW. Na przykład znacznik obiektu może być wykorzystany podczas odwiedzania witryny grupy dyskusyjnej w celu stworzenia na twoim komputerze potokowego wejścia audio-wideo, jak również można go użyć przy przeglądaniu trójwymiarowego elementu zamieszczonego na stronie i możliwego do obejrzenia po zainstalowaniu odpowiedniego plug-inu w przeglądarce.
Zawartość statyczna a zawartość dynamiczna Wcześniej większość zawartości Internetu stanowiły składniki statyczne, to znaczy, że odwiedzając jakąś stronę WWW za każdym razem mogłeś spodziewać się dokładnie tej samej treści. Te same teksty, grafiki, formatowanie, po prostu wszystko. Aby zmienić zawartość strony twórca musiał ręcznie modyfikować tekst strony i ponownie umieszczać ją w Internecie. Wykorzystywanie tej techniki powodowało, że sieć WWW była nieco skostniała. Użytkownicy sieci mogli odwiedzić twoją stronę raz lub dwa, lecz jeśli jej treść nie zmieniała się, prawdopodobnie kolejne odwiedziny były wymuszone. W ostatnich latach twórcy stron zdali sobie sprawę z tego, że statyczna zawartość to trochę za mało. Coraz więcej firm zaczęło wystawiać zawartość dynamiczną przynajmniej w części swoich witryn WWW. Obecnie znalezienie dużej witryny, która nie zawiera jakiegoś składnika dynamicznego to wydarzenie naprawdę niezwykłe. Dynamiczna zawartość WWW to pojęcie odnoszące się do stron, których treść zmienia się przez cały czas. Na przykład strona pokazana na rysunku 1.3. ukazuje jedno z ustawień strony, kiedy aktualny dzień przypada na weekend, zaś kiedy aktualny dzień tygodnia to poniedziałek, wtorek, środa, czwartek lub piątek, wtedy strona wyświetli zawartość pokazaną na rysunku 1.4.
ASP – Kompendium programisty
9
Rysunek 1.3. Próbna strona o zawartości wyświetlanej w czasie weekendów
Rysunek 1.4. Ta sama próbna strona pokazująca zawartość wyświetlaną w tygodniu Jak widzisz zawartość strony z rysunku 1.4. jest dynamiczna. Jej treść może się zmieniać przez cały czas. Zmiana może następować po każdorazowym przeglądnięciu strony lub w losowych bądź stałych odstępach czasowych. Te zmiany to znacząca kwestia. Tworzenie takich dynamicznych aplikacji internetowych to główny temat tej książki. Kod wymagany podczas tworzenia zawartości dynamicznej może być zaimplementowany przez rozmaite mechanizmy. Kod poprzedniego przykładu był stworzony w VBScript na stronie ASP. Pokazany został poniżej. <% if weekday(Date) = 7 or weekday(Date) = 1 then %>
Nie przejmuj się tym, jeśli nie potrafisz przeczytać tego kodu teraz; szczegóły poznamy w kolejnych rozdziałach książki. Jednak powyższy kod nie musiał być napisany wykorzystując ASP przy użyciu VBScript. Mógł być zaimplementowany przez składnik napisany w C++ lub przez biblioteki filtrujące wyszukujące strony z określonymi rozszerzeniami i przetwarzające je odpowiednio. Mógł być również napisany w JavaScript. W następnym podrozdziale zobaczysz, że kod może zostać napisany zarówno po stronie klienta, jak i po stronie serwera.
Tworzenie skryptów po stronie klienta i po stronie serwera Tworzenie skryptów po stronie klienta Tworzenie skryptów w tym kontekście to pojęcie odnoszące się do miejsca, w którym kod jest przetwarzany. Tworzenie skryptów po stronie klienta oznacza, że kod jest uruchamiany na komputerze klienta (bezpośrednio w przeglądarce). Kiedy odwiedzający chce przeglądnąć stronę, HTML i każdy inny kod strony jest pobierany przez przeglądarkę odwiedzającego. Następnie przeglądarka dokonuje analizy składniowej i realizuje każdy rozpoznany kod strony. Rezultaty tych czynności przeglądarka pokazuje odwiedzającemu stronę. Przykładem może być tutaj grafika pokazana na rysunku 1.5. o treści „Welcome to NetStats2000 — NetStats Live”.
Rysunek 1.5. Przykładowa grafika zrealizowana po stronie klienta. Teraz spójrz na tą samą stronę, kiedy kursor myszy znajduje się ponad wspomnianą grafiką, jak pokazano na rysunku 1.6. Zauważ, że teraz treść grafiki brzmi „Click here to contact us”. Jest to realizowane przez kod po
ASP – Kompendium programisty
11
stronie klienta. Przeglądarka wczytuje każdy kod i przetwarza go. W tym przykładzie kod napisany został w JavaScript i przedstawia się następująco: <SCRIPT LANG="Javascript">= 3 )) || ((navigator.appName == "Microsoft Internet Explorer") && (parseInt(navigator.appVersion) >= 4 ))) version = "ok", else version = "x", if (version == "ok") { img6off = new Image(); img6off.src = "./assets/images/baroff.jpg"; img6on = new Image(); img6on.src = "./assets/images/baron.jpg"; } function imgover(imgName) {
Zauważ, że kod jest otoczony znacznikami skryptu, które informują przeglądarkę o typie zastosowanego kodu. Jednak bardzo ważną okolicznością jest fakt, że nie wszystkie przeglądarki rozpoznają dany kod. Wobec tego co się stanie, kiedy przeglądarka, która nie rozpoznaje znacznika skryptu, próbuje dokonać analizy składniowej strony? Cały blok zostanie zignorowany, ponieważ nie rozpoznane znaczniki są pomijane. W tym przykładzie nie ma to znaczenia. Jeśli goście nie zobaczą naszej palety— grafiki pojawiającej się podczas przesuwania kursorem myszy nad obrazkiem — nie zmieni to rzeczywistej funkcjonalności strony. Spójrzmy jednak na kolejny przykład, w którym pominięcie bloku może nie być takie proste (Rysunek 1.7).
Rysunek 1.7. Przykładowy skrypt strony klienta używający pola zatwierdzenia W tym przykładowym skrypcie strony klienta korzystamy z kodu zatwierdzającego wejście użytkownika, zanim odwiedzający będzie mógł wystawić żądanie dostępu. Jeśli użytkownik zostawi to pole nie wypełnione, ujrzy wiadomość pokazaną na rysunku 1.8.
Rysunek 1.8. Wiadomość, która ukaże się tym odwiedzającym stronę, którzy nie wypełnią przedłożonego pola zatwierdzenia Gdy odwiedzający wpisze w pole wartość, jest ona zatwierdzana, a użytkownik zostaje odesłany do strony odpowiadającej tej wartości. Kod realizujący zatwierdzanie jest następujący: <SCRIPT language="JavaScript">
ASP – Kompendium programisty
13 { for (var i=0; i
Kod dla przycisku Submit Request:
Pamiętaj co się stanie, kiedy przeglądarka nie rozpozna znacznika skryptu lub języka użytego w skrypcie. Cały kod znajdujący się pomiędzy znacznikami skryptu zostanie zignorowany, tak więc strona stanie się bezużyteczna dla przeglądarek, które nie obsługują tych skryptów. Odwiedzający zobaczy stronę, ale po naciśnięciu przycisku Submit Request nic się nie stanie. Jest to ryzyko, które musisz rozważyć. Oczywiście tworzenie skryptów po stronie klienta ma swoje korzyści. Ponieważ przetwarzanie odbywa się po stronie klienta, twój serwer ma mniej pracy, mniejsza liczba przywołań redukuje ruch w sieci, a odwiedzający stronę nie musi czekać na dodatkowe wywołania twojej przeglądarki. Istnieje również pewne niebezpieczeństwo. Cały twój kod jest ujawniany gościom strony, jeśli więc zechcą oni poznać kod źródłowy strony przy pomocy menu opcji swojej przeglądarki, ujrzą każdy jego wiersz.
Tworzenie skryptów po stronie serwera Głównym tematem tej książki jest tworzenie skryptów po stronie serwera. Ponownie będziemy zajmować się miejscem uruchamiania kodu. Podczas pisania skryptów po stronie klienta kod uruchamiany jest przez przeglądarkę zainstalowaną na komputerze odwiedzającego stronę. Podczas tworzenia skryptów po stronie serwera kod, zanim zostanie wysłany do przeglądarki gościa, przetwarzany jest najpierw na serwerze. Użytkownicy uzyskują dostęp do strony WWW przez wpisanie jej nazwy w oknie przeglądarki lub klikając odpowiednie łącze. Serwer internetowy otrzymuje żądanie dostępu, a następnie wyszukuje stronę. Każdy kod strony serwera jest wtedy przetwarzany, a strona WWW może zostać zwrócona w czystej postaci HTML. Przeglądarka dokonuje analizuje składniowej podstawowego języka HTML i prezentuje jej rezultat odwiedzającemu. W ten sposób tworzenie skryptów po stronie serwera nie wymaga od przeglądarki specjalnych możliwości. Nie musi ona wiedzieć jak przeczytać dany rodzaj skryptu, ponieważ przetwarzanie odbywa się na serwerze, który zwraca jedynie podstawową postać HTML. Chroniony jest również twój kod. Często zdarza się, że nie chcesz udostępniać całemu światu twojego kodu źródłowego. Kod może być prawnie zastrzeżony dla twojej firmy lub może zawierać ukryte informacje systemowe, które nie powinny być dostępne dla osób postronnych. Tworzenie skryptów po stronie serwera rozwiązuje ten problem dzięki zwracaniu nie samego kodu, lecz jedynie rezultatu wykonania kodu. Jeśli więc użytkownik żąda dostępu do strony, która zawiera kod logowania do bazy danych, nie musisz mu pokazywać schematu działania twoich zapytań, nazw pól, techniki zatwierdzania, itd. Przy przetwarzaniu po stronie serwera, odwiedzający stronę poznaje jedynie wynik działania kodu. Spójrzmy na kilka przykładów wykorzystania skryptu strony serwera. Strona pokazana na rysunku 1.9. zawiera standardowy formularz logowania firmy. Zatwierdza ona wejście użytkownika na fikcyjną stronę WWW. Strona pozwala gościom na wprowadzenie nazwy użytkownika oraz hasła. Jeśli wprowadzą niewłaściwe hasło, ujrzą stronę, którą prezentuje rysunek 1.10.
Rysunek 1.9. Pierwszy widok strony logowania
ASP – Kompendium programisty
15
Rysunek 1.10. Przykładowa witryna logowania wyświetlająca wiadomość o próbie niewłaściwego wejścia Odwiedzający otrzymują wiadomość o tym, że wprowadzona informacja nie została rozpoznana. Jeśli wprowadzą wartość poprawną, wyświetli się strona pokazana na rysunku 1.11.
Rysunek 1.11. Tekst widoczny na stronie logowania po udanym wejściu. Strona logowania jest implementowana jako pojedyncza strona ASP. Poniżej pokazano jej kod. Również w tym przypadku nie musisz przejmować się tym, że nie rozumiesz jeszcze wszystkich jego szczegółów — po prostu przeczytaj go pobieżnie. Później omówimy tego typu kody dość obszernie. <%@ Language=VBScript %> <%
if not isempty(Request.Form("LogIn")) then set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" set RSUser = conn.Execute("select UserName from C1Login " _ & "where UserName = '" & Request.Form("UserName") _ & "' and Password = '" & Request.Form("Password") _ & "'") if RSUser.EOF then TheMessage = "You have entered an incorrect login. " _ & "Please try again." else TheMessage = "You are now logged in!" end if else TheMessage = "Please enter your user name and password below." end if %>
Po pierwsze kod sprawdza, czy naciśnięty został przycisk Log On. Jeśli tak, kod zweryfikuje nazwę użytkownika i jego hasło z rekordami bazy danych. Jeśli taki zapis istnieje oznacza to, że użytkownik wprowadził właściwe wartości i ukaże się odpowiednia wiadomość. Gdyby rekord nie został odnaleziony, wyświetlona zostałaby inna wiadomość mówiąca o niepoprawnym wejściu. Ostatnia wiadomość zawiera treść, jaką pierwotnie zawierała strona. Pomyśl o tym, co by się stało, gdybyś próbował to zaimplementować po stronie klienta. Po pierwsze mogłoby to działać jedynie pod ostatnimi wersjami Internet Explorer, ponieważ kod został zapisany w VBScript. Kolejnym problemem mógłby być fakt ujawnienia hasła bazy danych w kodzie źródłowym podczas wysyłania go do przeglądarki. Przy korzystaniu ze skryptu po stronie serwera nie mamy takich zmartwień. Kod zostanie przetworzony przez serwer i żaden z bloków kodu nie będzie widoczny dla odwiedzających; dodatkowo nie musimy martwić się o to, z jakiej przeglądarki oni korzystają, ponieważ przeglądarka otrzymuje jedynie wynik w postaci HTML. Kolejną dużą zaletą tworzenia skryptów po stronie serwera jest możliwość korzystania przez serwer ze składników, które mogą być nieosiągalne na komputerze klienta. Przykładowo załóżmy, że chcę na mojej stronie WWW stworzyć kalkulator obliczający kwotę spłaty pożyczki. Mógłby on wyglądać tak, jak to pokazuje rysunek 1.12.
17
ASP – Kompendium programisty
Rysunek 1.12. Przykładowa strona kalkulatora obliczającego kwotę spłaty pożyczki Odwiedzający stronę wpisywaliby potrzebne do obliczeń dane. Po naciśnięciu przycisku Calculate kodowaliby obliczenie kwoty spłaty na podstawie wprowadzonych parametrów. Jak widzieliśmy, istnieje wiele możliwości wyboru miejsca ulokowania tego kodu oraz sposobu jego implementacji. Teraz już wiesz, że kod jest lepiej chroniony przed nielegalnym skopiowaniem przez innego twórcę stron, jeśli piszesz skrypty po stronie serwera. Wiesz, że nie musisz martwić się o to, czy przeglądarka będzie w stanie właściwie zinterpretować napisany przez ciebie kod. Ale ponadto jeszcze trzecia korzyść płynie z tej formy tworzenia skryptów. Jeśli kiedykolwiek próbowałeś tworzyć od zera kalkulator obliczający kwotę spłaty pożyczki to wiesz, że to żmudna i narażona na wiele błędów praca. Dlaczego nie skorzystać ze składników (komponentów) znajdujących się na twoim serwerze, które wykonują obliczenia dla ciebie? Na przykład Microsoft Excel potrafi wykonywać wiele obliczeń finansowych. Możesz wykorzystać te komponenty w skrypcie po stronie serwera i uniknąć w ten sposób powielania kodu, który już posiadasz. Tak więc tworząc skrypty po stronie serwera możesz wykorzystać funkcje składników serwera na potrzeby aplikacji nie martwiąc się o to, czy odwiedzający stronę posiadają odpowiednie składniki na swoich komputerach.
Składniki dynamicznych rozwiązań internetowych Do tej pory zastanawialiśmy się co decyduje o tym, że strona WWW jest statyczna lub dynamiczna. Przyjrzeliśmy się różnym sposobom tworzenia stron dynamicznych, jak również ich wadom i zaletom. W tym podrozdziale zwrócimy uwagę na różnorodne składniki tworzące dynamiczne rozwiązania i sposoby ich współdziałania. Rozwiązanie dynamiczne może zawierać rozmaite składniki. Po pierwsze, HTML. Nawet najbardziej dynamiczna strona posiada jakiś statyczny składnik HTML wiążący ze sobą elementy dynamiczne. Często dynamiczna strona lub witryna zawiera bazę danych, której treść jest również dynamiczna. Bardziej zaawansowane rozwiązania łączą w sobie wszystkie składniki, które znajdują się na serwerze. Niejednokrotnie elementy te zawierają przepisy firmowe i pośredniczą między bazą danych a częściami dynamicznymi strony WWW. Mogą posiadać również jakiś rodzaj kodu, który wstawia w stronę treść dynamiczną, jak to jest w przypadku kodu ASP. Zwykle też rozwiązania dynamiczne będą wykorzystywały jakiś serwer WWW, na przykład internetowy serwer informacyjny, w celu odebrania żądania od przeglądarki, przetworzenia kodu na stronie i zwrócenia rezultatu.
Przejście przez stronę quizu Aby zademonstrować jak funkcjonuje każdy ze składników rozwiązania dynamicznego, na kilku kolejnych stronach zaprezentowano przykładowy quiz. Używa on języka HTML dla statycznych elementów strony. Korzysta z bazy danych w celu zapamiętywania pytań i odpowiedzi. Składnik Visual Basic realizuje wezwania bazy danych pozwalające na wyszukiwanie pytań i sprawdzanie poprawności odpowiedzi. Strona quizu implementowana jest jako strona ASP i zawiera kod dynamicznego wyświetlania w oparciu o aktualne pytania; znajduje się ona na internetowym serwerze informacyjnym, który przetwarza kod i zwraca jego wynik przeglądarce. Quiz wykonany jest jako pojedyncza strona WWW. Kiedy użytkownicy odwiedzą ją po raz pierwszy, ujrzą widok przedstawiony na rysunku 1.13. Kiedy rozpoczną quiz, zobaczą pytanie pierwsze. Wybiorą odpowiedź, którą uważają za prawidłową i nacisną przycisk Check Answer. Wtedy ukaże się strona pokazana na rysunku 1.14. Proces ten powtarza się dopóki użytkownicy nie odpowiedzą na ostatnie pytanie quizu, po którym ukaże się im strona przedstawiona na rysunku 1.15. Rysunek 1.13. Pierwsza strona quizu Rysunek 1.14. Drugie pytanie quizu Rysunek 1.15. Ostatnia strona quizu Zauważ, że po zakończeniu quizu odwiedzający stronę nie mają żadnych dodatkowych pytań ani nie widać już przycisku odpowiedzi na pytanie. Jak dowiesz się z dalszego omówienia, kod ASP steruje tym wyjściem na stronie.
HTML W tym dynamicznym środowisku internetowym, HTML jest połączeniem dowolnego statycznego składnika pierwotnego żądania oraz wyjścia kodu uruchamianego na serwerze. Kiedy więc odwiedzający stronę poproszą o pierwsze pytanie quizu, otrzymają w odpowiedzi sam HTML. Przykładowo, chociaż pytania quizu są elementem dynamicznym, opartym na aktualnym żądaniu pytania, wyjściowym elementem jest następujący kod HTML:
With this type of scripting, the code runs in the browser.
Lista rozwijana obiektu sterującego wyborem zawiera możliwe odpowiedzi na zadane pytania, a jeśli odwiedzający zdecyduje się na obejrzenie kodu źródłowego strony, może przykładowo zobaczyć: <SELECT NAME="Answer" >
Faktycznie z punktu widzenia odwiedzającego, ta pojedyncza witryna zdaje się być czterema osobnymi stronami: po jednej na każde pytanie plus jedna końcowa. HTML w tym przykładzie obejmuje też formularz, który jest zgrupowaniem elementów HTML takich jak pola tekstowe (również niesformatowane, zwane Textarea), obiekty sterujące wyborem, przyciski opcji oraz pola sprawdzające. W naszym przykładzie formularz jest pojedynczym obiektem sterującym wyborem, który zawiera zbiór możliwych odpowiedzi na pytania. Ale formularz posiada również wiele innych obiektów sterujących, które zawierają ukryte wartości. Elementy ukryte niosą w sobie wartości, które chcesz przedłożyć wraz z
ASP – Kompendium programisty
19
formularzem, ale nie chcesz, aby były one widoczne dla odwiedzających stronę. W kolejnej stronie przykładu użyte zostały trzy ukryte elementy.
Pierwszy ukryty element zawiera numer bieżącego pytania. Potrzebujemy tej wartości w celu sprawdzenia, czy odwiedzający wybrał właściwą odpowiedź na to pytanie. Element ukryty Question zapamiętuje liczbę pytań, na które odpowiedział gość. Wartość NumberCorrect informuje o liczbie poprawnych odpowiedzi. Te trzy ukryte wartości oraz wartość obiektu wyboru, które zawierają odpowiedź użytkownika na dane pytanie, są przedkładane wraz z formularzem po naciśnięciu przycisku Check Answer. Oznacza to, że przeglądarka wysyła te pola w postaci strumienia bajtów pod adres określony w znaczniku formularza:
Przy wyborze przycisków poświęconych elementom strony zostaniesz poproszony o podanie nieco innych informacji, zależnych od typu elementu, który wybrałeś. Przykładowo przy wyborze pola tekstowego będziesz musiał podać nazwę pola, jego wartość, długość oraz czy jest to pole z hasłem. Rezultatem może być następujący znacznik:
Jeśli jednak naciśniesz przycisk obszaru tekstowego, zostaniesz poproszony o określenie nazwy pola, domyślnego tekstu, jego rozmiaru oraz sposobu jego obramowania.
Weryfikacja kodu w programie ScriptBuilder ScriptBuilder posiada również parę narzędzi wspierających sprawdzanie napisanego przez ciebie kodu. Są to: Korektor składni (Syntax Checker) i Kontroler skryptu (Script Inspector). Jednym z błędów, które często zdarzają mi się podczas tworzenia stron ASP, jest opuszczanie nawiasów, jak w wierszu kodu poniżej: If isempty(Request.Form(" OK") then
ASP – Kompendium programisty
93
Ładuję stronę na serwer myśląc, że wszystko jest w porządku, a kiedy ją uruchamiam okazuje się, że wystąpił błąd w wierszu kodu. Wiem, w czym leży problem, ale muszę najpierw edytować tą stronę, a następnie ponownie umieścić ją na serwerze. Korektor składni jest w tym względzie bardzo pomocny. Nie znajdzie on błędów związanych z użyciem niewłaściwej metody czy właściwości obiektu i pewnie nie rozpozna błędów logicznych, ale błędy składni, podobne do tego zaprezentowanego powyżej, zostaną przez program odnalezione. Powiedzmy, że twój blok kodu wygląda następująco: <% if isempty(Session("StudentID")) then Response.Redirect "../index.asp" end if if isempty(Request.QueryString("CourseID") then Response.Redirect "../html/student_menu.asp" end if %>
Jesteś już gotów do wysłania twojej strony do serwera, ale przedtem chcesz sprawdzić, czy nie ma w niej jakichś błędów składni. Z menu Narzędzia (Tools) wybierz opcję Korektor składni (Syntax Checker). W rezultacie tego wyboru w oknie programu ScriptBuilder pojawi się dodatkowy panel, który pokazany jest na rysunku 3.50.
Rysunek 3.50. Rezultat uruchomienia Korektora składni Zwróć uwagę na panel, który znajduje się a dole okna. Wyszczególnia on błąd w stronie w szóstym jej wierszu. Panel ten pokaże listę wszystkich błędów składni znalezionych w stronie. Jeśli klikniesz dwa razy wiadomość o błędzie, program przeniesie cię do tego wiersza, który ten błąd wywołał. Korektor składni wyszuka wiele błędów podobnych do tego. Poinformuje cię o tym, że użyłeś instrukcji If bez End If lub instrukcji For bez Next. Zauważyłem jednak, że czasami korektor widzi błędy składni tam, gdzie ich nie ma. Weźmy następując fragment kodu, który w stronie ASP jest pojedynczym wierszem kodu: ">
Rozdział 3 – Narzędzia pracy
Ta linia spowoduje wystąpienie błędu, chociaż błędu nie ma. Taką reakcję programu ScriptBuilder wywoła pojawienie się kodu ASP wraz z HTML. Innym narzędziem weryfikacji jest Kontroler skryptu. Przeglądnie on twój HTML, kod strony serwera i strony klienta i poda wersje przeglądarek Navigator i Explorer, które będą mogły rozpoznać twój kod. Aby skorzystać z tego narzędzia, otwórz stronę, którą chcesz przetestować i wybierz opcję Kontroler skryptu (Script Inspector) z menu Narzędzia (Tools). W wyniku tego na dole okna ukażą się panele, które pokazane zostały na rysunku 3.51. Jeśli drugi panel nie został wyświetlony, kliknij prawym przyciskiem w obszarze panelu widocznego i wybierz Pokaż szczegóły (Show Details).
Rysunek 3.51. Wynik uruchomienia Kontrolera skryptu Zauważ, że Kontroler skryptu zgłosił znalezienie znacznika VBScript strony klienta, który nie jest obsługiwany przez większość obecnych wersji przeglądarek Navigatora. Jeśli klikniesz podwójnie wiadomość o błędzie wyświetloną w najniżej położonym panelu, program przeniesie cię do tego wiersza kodu, który jest źródłem wystąpienia problemu.
Microsoft Visual InterDev 6.0 Kolejnym pomocnym narzędziem, którego możesz użyć do tworzenia stron ASP jest Microsoft Visual InterDev 6.0. Ponieważ jest o produktem firmy Microsoft, łączą go bliskie relacje z Internetowym serwerem informacyjnym (IIS) oraz systemem NT. Z perspektywy twórcy stron najważniejszymi cechami tego programu są: wyróżnianie wizualne oraz automatyczne zakańczanie kodu. Rysunek 3.52. pokazuje stronę ASP otwartą przy użyciu Visual InterDev. Program, dzięki zastosowaniu kolorowych czcionek, kolorów tła oraz pogrubienia tekstu, czyni stronę bardzo czytelną. W prosty sposób można wtedy dostrzec, gdzie się zaczyna, a gdzie kończy blok kodu; instrukcje w blokach kodu są pogrubione.
ASP – Kompendium programisty
95
Rysunek 3.52. Okno programu Visual InterDev 6.0 Zauważ, że na dole okna znajdują się trzy zakładki odnoszące się do strony: Projekt (Design), Źródło (Source) i Szybki podgląd (Quick View). Niestety jeśli uruchomisz stronę zawierającą kod ASP wraz z HTML — czyli prawie każdą — zakładka Projekt (Design) nie zadziała; natomiast zakładka Szybki podgląd (Quick View) nie będzie funkcjonowała, ponieważ program nie przetwarza kodu strony serwera. Tak więc jedynym widokiem, który mamy do dyspozycji przez cały czas jest Źródło (Source). Inną nadzwyczaj pomocną funkcją Visual InterDev są listy zakańczania kodu, generowane w chwili użycia kropki w składni kodu dla jednego z wbudowanych obiektów ASP. Na przykład jednym z najważniejszych obiektów ASP jest Response. Używany jest do komunikowania się z przeglądarką, która wywołała twoją stronę ASP. Obiekt ma liczne właściwości i metody, które pozwalają na podjęcie działań. Jeżeli w oknie Visual InterDev wpiszesz następujący kod: Response.
pojawi się lista pokazana na rysunku 3.53. Będzie ona zawierała wszystkie właściwości i metody obiektu Response. Możesz zacząć wpisywać wybraną metodę albo po prostu przewinąć listę i wybrać z niej odpowiedni punkt.
Rozdział 3 – Narzędzia pracy
96
Rysunek 3.53. Lista rozwijana zakończenia kodu dla obiektu Response
Ostatnie słowo o narzędziach Bez względu na to, na które narzędzie się zdecydujesz, pamiętaj, że to tylko narzędzie — jeśli użyjesz właściwego, ułatwisz sobie pracę. Powinieneś przeanalizować ich pełne możliwości, ponieważ większość najciekawszych funkcji często bywa zagrzebana na samym dnie menu. Postaraj się nie zadowalać jednym tylko produktem. Nowe produkty i programy usługowe przez cały czas pojawiają się na rynku, a ich zastosowanie często zaoszczędzi ci mnóstwa czasu.
Rozdział 4. Podstawy ASP Konstrukcja kodu ASP Strony ASP złożone są ze statycznego HTML-a oraz dynamicznego kodu ASP. Te dwa składniki mogą być łączone ze sobą na różne sposoby, które zostaną omówione w tym podrozdziale: HTML może być umieszczony w kodzie, kod w HTML oraz skrypty strony serwera mogą być zawarte w skryptach kodu klienta.
Znacznik <% = X %> Aby odróżnić początek od końca kodu, będziesz potrzebował pewnego rodzaju znacznika. Najprostszy znacznik przedstawia się następująco: <% = X %>
Nakazuje on kompilatorowi wypisanie wyniku wyrażenia X. Na przykład, jeśli chcesz stworzyć stronę WWW wyświetlającą aktualną datę oraz czas, stwórz kod podobny do tego: <TITLE>Simple Tag Page
Witam na stronie z zegarem
Teraz jest: <% = Now() %>
Strona jest napisana przy użyciu standardowego HTML-a aż do wiersza:
Teraz jest: <% = Now() %>
Pierwszą częścią wiersza jest standardowy HTML, ale pojawia się tutaj podstawowy znacznik ASP. Ponieważ po otwarciu <% następuje znak równości, kompilator wie, że to, co jest później powinno zostać obliczone, a wynik ma być wysłany w postaci HTML. W tym przypadku obliczona powinna być funkcja Now(). Jak się dowiesz później, funkcja Now() zwraca datę i godzinę systemu. Tak więc poprzedni wiersz, wysłany do przeglądarki, faktycznie wygląda tak:
Teraz jest: 7/12/99 12:10:14 PM
Widok tej strony ASP prezentuje rysunek 4.1.
Rozdział 4 – Podstawy ASP
98
Rysunek 4.1. Strona ASP ze znacznikiem podstawowym
<% Pojedyncza linia kodu %> Kolejnym sposobem na umieszczenie kodu w stronie ASP jest wstawienie pojedynczej linii pomiędzy znacznikiem <% a znacznikiem %>. Przykładem użycia tej składni niech będzie strona wyświetlająca liczbę dni do Bożego Narodzenia:
<TITLE>Days Until Christmas
Ile czasu zostało?
Dni do Bożego Narodzenia: <% Response.Write DateDiff("d",Date,"12/25/" & Year(Date)) %>
Strona zbudowana jest z samego HTML-a aż do wiersza:
Dni do Bożego Narodzenia: <% Response.Write DateDiff("d",Date,"12/25/" & Year(Date)) %>
Kompilator ASP widzi znacznik <% i wie, że wszystko, co znajduje się pomiędzy nim a znacznikiem %>, jest kodem wymagającym przetworzenia. W tym przypadku korzystamy z metody o nazwie Write obiektu Response w celu wysłania wyniku do przeglądarki (obiekt ten zostanie szczegółowo omówiony w rozdziale 6.). Szczególną wartością wysłaną do przeglądarki jest liczba dni do Bożego Narodzenia, powstała po odjęciu liczby od siebie dni pozostałych pomiędzy aktualną datą a datą tegorocznego święta. Wiersz wynikowy kodu:
Dni do Bożego Narodzenia: 157
ASP – Kompendium programisty
99 Wygląd strony przedstawia rysunek 4.2.
Rysunek 4.2. Strona zawierająca pojedynczą linię kodu ASP
<% Blok kodu %> Możesz również użyć znaczników <% i %> do stworzenia bloku kodu, który jest serią wierszy otrzymujących określone zadania. Powiedzmy, że musisz stworzyć stronę, która wysyła lub przeadresowuje odwiedzającego do innej strony, opierając się przy tym na dniu tygodnia. Poniższy blok kodu realizuje to zadanie: <% If WeekDay(Date) = 1 then Response.Redirect "Sunday.html" ElseIf WeekDay(Date) = 2 then Response.Redirect "Monday.html" ElseIf WeekDay(Date) = 3 then Response.Redirect "Tuesday.html" ElseIf WeekDay(Date) = 4 then Response.Redirect "Wednesday.html" ElseIf WeekDay(Date) = 5 then Response.Redirect "Thursday.html" ElseIf WeekDay(Date) = 6 then Response.Redirect "Friday.html" Else Response.Redirect "Saturday.html" End If %>
To byłaby cała zawartość strony. Nie posiada ona widoku wyjściowego i jest napisana jedynie w kodzie ASP. Kod sprawdzi dzień tygodnia w oparciu o aktualną datę, a następnie połączy odwiedzającego ze stroną odpowiedniego dnia.
Rozdział 4 – Podstawy ASP
100
< Script> Kod Jeśli już pracowałeś ze skryptami po stronie klienta, to prawdopodobnie jesteś zaznajomiony ze znacznikiem <Script>. Jest on alternatywą dla znaczników zaprezentowanych do tej pory, dlatego możesz go używać podczas konstruowania stron ASP. Musisz jednak użyć parametru RunAt i ustawić go dla serwera, ponieważ w innym wypadku twój kod ASP będzie pominięty przez przeglądarkę podczas przetwarzania. Poniżej pokazano kod strony WWW używającej znacznika <Script>.
<TITLE>Session Object
Czas trwania sesji
Czas trwania sesji upływa po (minutach): <SCRIPT LANGUAGE=VBScript RUNAT=Server > Response.Write Session.Timeout
Strona wygląda jak zwykła strona HTML aż do znacznika <Script>: <SCRIPT LANGUAGE=VBScript RUNAT=Server >
Zauważ, że określony został użyty język oraz to, że kod zostanie uruchomiony po stronie serwera. Następnie mamy jeden wiersz kodu, który wypisuje w minutach czas trwania sesji (Timeout): Response.Write Session.Timeout
Kod zakończony jest znacznikiem . Obliczonym przez kod wynikiem uwidocznionym w przeglądarce jest: 30
Wyjściowa strona pokazana jest na rysunku 4.3.
ASP – Kompendium programisty
101
Rysunek 4.3. Strona ASP używająca znacznika <Script>
HTML w kodzie Do tej pory przyglądaliśmy się przypadkom umieszczenia kodu w HTML-u, lecz możliwe są również sytuacje odwrotne. Możemy umieścić HTML w kodzie. Mógłbyś na przykład napisać kod, który powoduje wyświetlenie innego koloru tła w czasie dnia, a innego w nocy. Przykładem może tutaj być następujący kod:
<TITLE>Change the Light <% if hour(Time) > 6 and Hour(Time) < 19 then Response.Write "" else Response.Write "" end if %>
W nocy wyłączamy światło.
Zwróć uwagę na to, jak wygląda kod. Posiada jeden znacznik treści () dla godzin od 7 rano do 6 wieczorem oraz drugi dla pozostałej części dnia. Tak więc w nocy wynikiem bloku kodu będzie ten HTML:
Rysunek 4.4. pokazuje wygląd strony w nocy.
Rozdział 4 – Podstawy ASP
Rysunek 4.4. Strona zmieniająca kolor tła — w godzinach nocnych W czasie dnia wyjściowym znacznikiem treści kodu będzie:
Wygląd strony w tym wypadku pokazuje rysunek 4.5.
Rysunek 4.5. Strona zmieniająca kolor tła — w czasie dnia
102
ASP – Kompendium programisty
103
Skrypt w skrypcie Możesz również włączyć wynik twojego skryptu strony serwera do skryptu po stronie klienta, w ten sposób kod strony serwera zostanie uruchomiony i umieści tekst w kodzie po stronie klienta, który z kolei będzie rozpoznany przez przeglądarkę. Aby to zademonstrować, spróbujmy stworzyć kalkulator obliczający cenę, z którego klienci mogliby skorzystać w celu określenia, ile będzie kosztowała pewna ilość produktu. Stałym klientom oferujemy inną cenę niż pozostałym. Chcemy, aby cena była obliczana po stronie klienta w celu zredukowania liczby połączeń i aby szybkość działania kalkulatora pozwalała klientom na wielokrotne wpisywanie cen. Musimy jednak stworzyć skrypt po stronie klienta, aby cena była ustalana indywidualnie w oparciu o typ klienta, co z kolei zapisane jest w zmiennej po stronie serwera. Poniższy kod realizuje to zadanie, łącząc skrypt strony klienta i strony serwera: <TITLE>Client and Server <% If Session("CustomerType") = "Preferred" then TheRate = 25 else TheRate = 50 end if %> <SCRIPT language="JavaScript"> * document.sampleform.Quantity.value; alert("Twoja cena wynosi $" + TheMessage); } // -->
Pierwszy blok kodu jest kodem ASP strony serwera napisanym w VBScripcie. Rozpoznajemy to po użytych znacznikach: <% If Session("CustomerType") = "Preferred" then TheRate = 25 else TheRate = 50 end if
Rozdział 4 – Podstawy ASP
104
%>
Kod sprawdza zmienną sesji, która została omówiona dalej, w rozdziale 8. W zmiennej TheRate kod ustawia odpowiednią wartość w oparciu o typ klienta (CustomerType). Następnie blok wstawia wynik kodu strony serwera w blok kodowy strony klienta. <SCRIPT language="JavaScript"> * document.sampleform.Quantity.value; alert("Twoja cena wynosi $" + TheMessage); } // -->
Znacznik Script bez zaznaczenia, że należy go uruchomić na serwerze, jest zinterpretowany jako kod strony klienta. Zauważ, że wewnątrz bloku kodu znajduje się kod ASP strony serwera: <% response.write TheRate %>
Kod strony serwera jest uruchamiany przed wysłaniem bloku kodu do przeglądarki. Jeśli więc odwiedzający nie jest stałym klientem, jego przeglądarka otrzyma następujący HTML: <TITLE>Client and Server <SCRIPT language="JavaScript">
Na wstępie powinieneś zauważyć, że brak jest pierwszego bloku kodu. Jest tak, ponieważ brakujący blok jest blokiem kodu strony serwera, a my teraz obserwujemy to, co jest wysyłane do klienta. Zauważ również, że
ASP – Kompendium programisty
105
zmienna TheRate w znacznikach skryptu została zastąpiona wartością 50, tak więc cały kod strony serwera zniknął, a przeglądarka otrzymała dostosowaną do klienta wersję procedury CheckPrice. Rysunek 4.6. pokazuje wygląd tej strony, a rysunek 4.7. przedstawia okno wiadomości prezentujące obliczoną cenę.
Rysunek 4.6. Strona kodu klienta i serwera
Rysunek 4.7. Okno pojawiające się po naciśnięciu przycisku Pokaż cenę Jeśli odwiedzający stronę jest stałym klientem, jego cena będzie ustalona na poziomie 25 $ za jednostkę produktu. Skrypt strony klienta będzie wtedy zawierał nieco inny wiersz kodu określającego cenę pojawiającą się w wiadomości: TheMessage = 25 * document.sampleform.Quantity.value
Dyrektywa przetwarzania Domyślnie ustawionym językiem kodu ASP w serwerze IIS jest VBScript. Możesz też wyraźnie stwierdzić, że będziesz używał VBScripta jako twojego kodu poprzez umieszczenie na górze strony następującej dyrektywy przetwarzania: <%@ LANGUAGE=VBSCRIPT %>
Zapamiętaj, że ten wiersz musi znaleźć się na stronie jako pierwszy. Informuje on kompilator o tym, że używanym w stronie językiem programowania będzie VBScript. Jeśli chcesz użyć języka JScript, dyrektywa będzie wyglądała następująco:
Rozdział 4 – Podstawy ASP
106
<%@ LANGUAGE=JSCRIPT %>
Pliki Include Po co ich używać W miarę jak twoja strona ASP będzie się rozbudowywała zobaczysz, że jej bloki kodu rozrastają się do bardzo dużych rozmiarów, a ty przez cały czas wpisujesz do nich te same procedury. Pliki Include pomagają radzić sobie z takimi problemami, dzięki nim można bowiem wstawić kod do pliku, a następnie wywołać ten kod w stronie ASP. Załóżmy na przykład, że posiadasz standardowe procedury zatwierdzania danych, które odwiedzający wprowadza do formularza na stronie. W formularzu może znajdować się sprawdzane w jakiś sposób pole daty, kilka pól, których wypełnienie jest wymagane oraz sprawdza się w nim liczby i ich zakres. Ten rodzaj kodu prawdopodobnie znalazłby zastosowanie w wielu stronach. Jeśli chciałbyś zmodyfikować działanie którejś z procedur, musiałbyś dokonać zmian na każdej ze stron, która z procedury korzysta. Lepiej więc umieścić kod zatwierdzania w osobnym pliku tekstowym, a następnie po prostu połączyć z plikiem te strony, które z niego korzystają. Pliki Include pomagają oczyścić nadmiernie rozbudowane strony, czyniąc je w ten sposób łatwiejszymi do uruchomienia. Jest tak, ponieważ kod jest położony w centralnym punkcie, przez co w prostszy sposób można go modyfikować. Kolejnym powodem umieszczania kodu w plikach Include jest ochrona programistów przed nadmierną złożonością kodu. Możesz mieć w firmie programistę, który jest ekspertem od obiektów danych współpracujących (CDO — Collaborative Data Objects). Obiekty CDO są używane do wysyłania poczty elektronicznej poprzez twoją stronę ASP oraz do współpracy z Microsoft Exchange. Taki programista może mieć klika skomplikowanych procedur zarządzającymi kalendarzami Exchange. Jeśli przekazał on swój kod innym pracownikom, aby go umieścili na swoich stronach ASP, istnieje ryzyko, że będą oni używali tego kodu w sposób niepoprawny, ponieważ mogą go nie rozumieć. Jeśli programista CDO umieściłby swój kod w pliku Include, inni pracownicy firmy nie musieliby rozumieć zawiłości kodu w nim zawartego. Mogliby po prostu włączyć w stronę plik CDO i wywoływać jego procedury. Włączanie pliku Aby włączyć plik w zawartość strony ASP, użyj po prostu znacznika Include: <SCRIPT LANGUAGE="vbscript" RUNAT="server">
Wiersz Include jest otoczony znacznikami skryptu. Plik Include nosi nazwę FieldValidation.inc i musi być położony w tym samym katalogu, co strona ASP, która go wywołuje. Możesz jednak użyć ścieżki względnej do zaznaczenia położenia pliku Include: <SCRIPT LANGUAGE="vbscript" RUNAT="server">
W tym przykładzie plik Include musi być umieszczony w katalogu o nazwie Lib, który jest położony o jeden poziom wyżej niż bieżący katalog. Włączenie pliku powoduje efekt umieszczenia całego znajdującego się w nim kodu dokładnie w tym miejscu, gdzie pojawił się wiersz Include. Każdy wiersz włączonego pliku nie staje się jednak fizycznie częścią strony ASP.
ASP – Kompendium programisty
107 Plik Include — struktura i przykład
Plik Include jest prostym plikiem tekstowym zawierającym twój kod. Tak jak w przypadku każdej strony ASP, kod ma następującą strukturę: <% 'blok kodu jest tutaj %>
Kod objęty jest znacznikami <% i %>. Na przykład plik Include, zapisany jako FieldValidation.inc, zawiera procedurę, która sprawdza, czy wpisana data faktycznie jest datą i czy należy do określonego zakresu. Zawiera również procedurę sprawdzająca, czy dane pole jest polem liczbowym i czy liczba w nim jest zgodna z narzuconym zakresem. Wartości te są weryfikowane odpowiednio jako prawidłowa data urodzin oraz kod pocztowy. <% Function DateRange(DateToTest, StartDate, EndDate) if not isdate(DateToTest) then DateRange = 0 elseif cdate(DateToTest) < cdate(StartDate) or _ cdate(DateToTest) > cdate(EndDate) then DateRange = 0 else DateRange = -1 end if End Function
Function NumberRange(FieldToTest, MinNumber, MaxNumber) If Not IsNumeric(FieldToTest) Then NumberRange = 0 ElseIf CSng(FieldToTest) < MinNumber Or _ CSng(FieldToTest) > MaxNumber Then NumberRange = 0 Else NumberRange = -1 End If End Function
Function Birthdate(FieldToTest) If Not IsDate(FieldToTest) Then Birthdate = 0 ElseIf CDate(FieldToTest) > Date Then Birthdate = 0 Else Birthdate = -1 End If End Function
Function ZipCode(FieldToTest) If Len(FieldToTest) = 5 Then If IsNumeric(FieldToTest) Then ZipCode = -1
Rozdział 4 – Podstawy ASP
108
Else ZipCode = 0 End If ElseIf Len(FieldToTest) = 10 Then If IsNumeric(Left(FieldToTest, 5)) And _ IsNumeric(Right(FieldToTest, 4)) Then ZipCode = -1 Else ZipCode = 0 End If Else ZipCode = 0 End If End Function %>
Wywoływanie procedur Mogłeś użyć pliku Include wspomnianego w poprzednim podrozdziale korzystając z następującej składni: <SCRIPT LANGUAGE="vbscript" RUNAT="server">
Plik o nazwie FieldValidation.inc musi znajdować się w tym samym katalogu, co strona ASP, która go wywołuje. Cały kod pliku Include jest wtedy umieszczany przez kompilator w miejscu pojawienia się znacznika. Od tej pory procedury pliku Include mogą być wywoływane wewnątrz kodu strony ASP: Response1 = DateRange(Request.Form("Test1"), _ "12/1/99", "12/15/99") Response1 = NumberRange(Request.Form("Test1"), _ 7, 10) Response1 = Birthdate(Request.Form("Test1")) Response1 = ZipCode(Request.Form("Test1"))
W dalszej części tego rozdziału omówimy procedury, dlatego nie martw się o to, że nie rozumiesz struktury pliku Include. Użyty został tutaj również obiekt Request, który zostanie omówiony w rozdziale 6. Teraz ważne jest jedynie to, abyś zrozumiał, że kod strony ASP możesz umieścić osobno w pliku Include.
Kod ASP w użyciu W tym podrozdziale sięgniemy do VBScripta, najczęściej używanego języka podczas tworzenia stron ASP. Nauczysz się korzystać z typów danych, operatorów, instrukcji i funkcji VBScripta, dzięki którym tworzy się bloki kodu i procedury.
Komentarze, puste miejsca i wielkość liter W VBScripcie, podobnie jak w Visual Basicu i Visual Basicu dla aplikacji (VBA), komentarze są zaznaczone apostrofem lub pojedynczym cudzysłowem. Możesz umieścić komentarz na końcu wiersza kodu: If Year(Request.Form("StartDate")) = Year(Date) then 'to jest komentarz do tego wiersza
ASP – Kompendium programisty
109
Możesz również użyć apostrofu do zaznaczenia, że cały wiersz jest komentarzem: If Year(Request.Form("StartDate")) = Year(Date) then 'kod wykona instrukcję jedynie wtedy, gdy wprowadzona data jest dniem tego roku
Możesz również stworzyć blok komentarza, który często spotykany jest na samym początku procedury lub strony ASP. Może on zawierać imię i nazwisko autora, datę utworzenia i nazwę procedury, opis jej działania, parametry oraz zwracane wartości. '''''''''''''''''''''''''''''''''''''''''''' ' ' Programista: Greg Buczek ' Data utworzenia: 2/1/2000 ' Nazwa procedury: DateRange '
Opis procedury: Procedury używa się do określenia, czy przekazana wartość
'
jest datą. Jeśli jest, sprawdza również, czy należy do zakresu.
'
Parametry: Przekazywane są 3 parametry, dane testowane, ich najmniejsza
'
i największa wartość.
'
Wartość zwracana: Procedura zwraca –1, jeśli wartość jest datą i należy do zakresu.
'
Jeśli tak nie jest, zwracane jest 0.
''''''''''''''''''''''''''''''''''''''''''
Kiedy oznaczysz wiersz jako komentarz, cała jego zawartość jest interpretowana jako komentarz. Na przykład: 'Komentarz ' x = 5
W tym wierszu kod x = 5 nie zostanie wykonany, ponieważ jest częścią wiersza komentarza. Komentarze są pomijane przez kompilator, możesz więc używać ich tak często, jak tylko chcesz. Pamiętaj, że programista przeglądający kod po tobie, być może nie będzie potrafił go odczytać bez odpowiedniego wyjaśnienia. Istnieje również taka możliwość, że ty sam nie będziesz wiedział dlaczego napisałeś dany wiersz kodu, jeśli będziesz go przeglądał po latach. Komentarze pomagają też przemyśleć to, co chcesz zrobić. Mogą być wykorzystane, aby stworzyć pewien zarys działania kodu oraz określić, na jakie sytuacje kod został przygotowany. Innym sposobem na uczynienie kodu łatwiejszym do odczytania przez ciebie lub innego programistę to dobre wykorzystanie w kodzie pustych miejsc, to znaczy znaków tabulacji, dodatkowych linii oraz spacji. Na przykład zwróć uwagę na czytelność poniższego bloku kodu: if isempty(Session("StudentID")) then Response.Redirect "../index.asp" end if if isempty(Request.Form("QuizID")) then Response.Redirect "../index.asp" end if set conn=server.createobject("adodb.connection") conn.open "ASPBook","sa","yourpassword" set RSQuiz=conn.execute("SELECT CourseID, QuizName, " _ & "CorrectToPass FROM " _ & "OCQuizzes where QuizID = " & Request.Form("QuizID")) NumberCorrect=0 for each Question in Request.Form if Question<>"TestIt" then set RSQuestion=conn.Execute("select QuizAnswer from " _
Rozdział 4 – Podstawy ASP
110
& "OCQuizQuestions where QuizQuestionID = " _ & Question) if Request.Form(Question)=RSQuestion("QuizAnswer") then NumberCorrect=NumberCorrect + 1 end if end if next
Z bloku kodu usunięto wszystkie dodatkowe puste miejsca. Jest trudny do odczytania. Przebiegając oczami ten kod nie jesteś pewny, w jakiej pętli aktualnie znajduje się kod oraz w którym miejscu rozpoczyna się pełen wiersz kodu i gdzie się kończy. Teraz spójrz na ten sam blok kodowy z dodanymi do niego pustymi miejscami: if isempty(Session("StudentID")) then Response.Redirect "../index.asp" end if if isempty(Request.Form("QuizID")) then Response.Redirect "../index.asp" end if
set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" set RSQuiz = conn.execute ("SELECT CourseID, QuizName, CorrectToPass " _ & "From OCQuizzes where QuizID = " & Request.Form("QuizID")) NumberCorrect = 0 for each Question in Request.Form if Question <> "TestIt" then set RSQuestion = conn.Execute("select QuizAnswer from " _ & "OCQuizQuestions where QuizQuestionID = " _ & Question) if Request.Form(Question) = RSQuestion("QuizAnswer") then NumberCorrect=NumberCorrect + 1 end if end if next
Przy zastosowaniu pustych miejsc kod staje się bardziej czytelny. Możemy od razu stwierdzić gdzie rozpoczyna się i gdzie kończy instrukcja If. Rozróżniamy między sobą poszczególne instrukcje If, wiemy, który kod zadziała przy danym warunku. Dodanie pustych miejsc nie wpływa na wykonywanie kodu. Większa ich ilość spowoduje, że strona ASP będzie nieco większa, ale to niewielka cena za uczynienie kodu bardziej czytelnym. VBScript, podobnie jak Visual Basic i Visual Basic dla aplikacji nie rozróżnia wielkości liter. To znaczy, że zmienna NumCorrect
jest tą samą zmienną, co numcorrect
oraz
ASP – Kompendium programisty
111 nUMcORRECT
Jeśli wcześniej programowałeś w języku, w którym wielkość liter miała znaczenie, jakim jest na przykład C++, będziesz musiał uważać podczas przydzielania nazw zmiennym i procedurom. Gotowe modele obiektów ASP oraz funkcje napisane w VBScript również nie rozpoznają wielkości liter. Możesz więc odnieść się do metody pisania w ten sposób: Response.Write
Lub w ten sposób: response.write
Aby twój kod był czytelny, staraj się być konsekwentny. Jeśli stworzyłeś następującą zmienną: Dim OrderTotal
to powinieneś przez cały czas używać jej w tej postaci, z tym samym wyszczególnieniem wielkości liter.
Zmienne Zmienne służą do zapamiętywania informacji w twoim kodzie. W VBScripcie zmienne muszą rozpoczynać się literą i nie mogą mieć więcej niż 255 znaków. Mogą zawierać litery i cyfry, ale nie mogą zawierać kropek oraz innych znaków specjalnych. Poniżej przedstawiono przykłady prawidłowych nazw zmiennych: Dim x Dim ABC Dim A241 Dim BardzoDlugaNazwaKtoraJestPoprawna
Te deklaracje nie są poprawne: Dim 2C Dim ABC+ Dim AB.3
W VBScripcie nie musisz deklarować zmiennej na wstępie — możesz jej po prostu użyć. Na przykład pierwszym wierszem kodu może być: X = 3
Chociaż nie musisz deklarować twoich zmiennych, to jednak przekonasz się, że o wiele łatwiej jest usuwać błędy w kodzie, jeśli to zrobisz dodatkowo wykorzystując instrukcję Option Explicit. Jeśli wstawisz następujący wiersz na początku strony: Option Explicit
informujesz kompilator o tym, że będziesz deklarował wszystkie swoje zmienne. Jeśli kompilator znajdzie zmienną, która nie została zdeklarowana, wtedy wygeneruje stan błędu. Zwróć uwagę na ten blok kodu: MyVariable = 2
Jaka liczba pojawi się w przeglądarce? Jeden. Zauważ, że w trzecim wierszu wystąpił błąd literowy. Ponieważ nie dodałeś instrukcji Option Explicit, kompilator przyjmuje, że właśnie tworzysz nową zmienną o nazwie MyVaraible. Nowa zmienna będzie miała wartość zero; zero plus jeden daje jeden. Jest to jeden z najtrudniejszych do wykrycia błędów, ponieważ kod zostanie uruchomiony bez wystąpienia stanu błędu, błędny będzie tylko wynik. Jeśli kod byłby napisany w ten sposób: Option Explicit Dim MyVariable MyVariable = 2 MyVariable = MyVariable * 3 MyVariable = MyVaraible + 1 Response.Write MyVariable
wtedy kompilator wyrzuciłby błąd w wierszu trzecim. Wiedzielibyśmy, że problem wystąpił i w prosty sposób mógłby zostać znaleziony. W przypadku kodu złożonego z czterech wierszy nie ma kłopotu z analizą, ale w wypadku procedury składającej się z kilkuset wierszy, zastosowanie tej instrukcji może być wielką pomocą.
Typy danych W większości języków dysponujesz różnymi typami danych podczas tworzenia zmiennych. Na przykład w Visual Basic możesz stworzyć zmienne następujących typów: Dim X as Long Dim Y as Currency Dim Z as String
W C++ określone są następujące typy: int TheNumber; char TheName[100]; float TheFloat;
W VBScripcie jednakże dostępny jest jeden tylko typ danych, który implikowany jest następująco: Dim X
Ten typ nazywany jest wariantem. Funkcjonuje podobnie jak dowolny typ, który możesz stworzyć w Visual Basic oraz tak samo, jak typ danych obiektu. Jeśli umieścisz wartość w wariancie, zadecyduje on za ciebie, w jaki sposób należy zapisać daną. Tak więc w kodzie: Dim X X = 5
typ danych wariantu jest liczbą, prawdopodobnie bajtem. Jeśli tej samej zmiennej przydzielisz inną wartość: X = "Hello"
ASP – Kompendium programisty
113
zmienna jest teraz ciągiem znaków. Tak samo byłoby w przypadku, gdyby w zmiennej znalazła się data bądź każdy inny typ danych. Tak więc przez cały czas istnienia zmiennej może ona zmieniać typ. Wariant może być również obiektem: Dim X Set X = Server.CreateObject("adodb.connection")
Zauważ, że kiedy używamy wariantu do zapisania obiektu, korzystamy z instrukcji Set. Zostanie ona omówiona nieco dalej w tym rozdziale.
Zakres i trwałość W odniesieniu do zmiennych, pojęcie zakres określa miejsce ich dostępności. Na przykład jeśli zmienna jest dostępna w całej aplikacji, ma zakres publiczny bądź globalny. Trwałość odnosi się okresu czasu, w którym zmienna pozostaje dostępna. Na przykład zmienną zdeklarowaną w procedurze można uznać za trwałą od momentu rozpoczęcia działania procedury aż do chwili jego zakończenia. Kiedy deklarujesz zmienną w stronie ASP, znajdującą się na zewnątrz procedury, ma ona zakres strony, co oznacza, że jest dostępna dla dowolnego wiersza kodu strony oraz w każdej procedurze. Weźmy na przykład następujący kod: <% Option Explicit Dim MyString MyString = "Hello" Procedure1 Response.Write MyString %> W tym miejscu jest HTML <% Sub Procedure1 MyString = "GoodBye" End Sub %>
W trzecim wierszu tego kodu zdeklarowano zmienną MyString. Ponieważ jest ona zdeklarowana w głównym bloku kodu, a nie w procedurze, ma ona szeroki zakres strony. Kolejny wiersz wpisuje do zmiennej ciąg znaków ”Hello”. Kod wywołuje następnie procedurę o nazwie Procedure1, która znajduje się na końcu strony. Procedura ta wpisuje do tej samej zmiennej ciąg znaków "GoodBye". Procedura kończy swe działanie i zmienna MyString jest wpisywana do przeglądarki. Pojawia się w niej ciąg znaków GoodBye. Teraz przyjrzyj się kolejnemu blokowi kodu. <% Option Explicit MyString = "Hello" Procedure1 Response.Write MyString %> W tym miejscu jest HTML <% Sub Procedure1 Dim MyString MyString = "GoodBye"
Rozdział 4 – Podstawy ASP
114
End Sub %>
Tutaj zmienna MyString jest deklarowana w procedurze Procedure1. Jest ona dostępna jedynie w tej procedurze, tak więc kompilator wygeneruje błąd w trzecim wierszu, gdzie próbujemy wpisać do zmiennej MyString ciąg znaków "Hello". Błąd pojawi się, ponieważ zmienna nie została zdeklarowana dla kodu strony. Teraz popatrz na kolejny blok kodu i spróbuj powiedzieć, jaka wartość zostanie wysłana do przeglądarki. <% Option Explicit Dim MyString MyString = "Hello" Procedure1 Response.Write MyString %> W tym miejscu jest HTML <% Sub Procedure1 Dim MyString MyString = "GoodBye" End Sub %>
Tym razem mamy dwie zmienne o nazwie MyString; jedna z nich znajduje się w kodzie ogólnym, a druga w Procedure1. Kiedy wpisujemy "GoodBye" w zmienną MyString bloku Procedure1,używamy tej, która została zdeklarowana w procedurze. Tak więc ciąg "Hello" nie ulegnie zmianie i to właśnie "Hello" zostanie wysłane do przeglądarki. W rozdziale 8. przyjrzymy się zmiennym, które są widoczne dla wielu stron. Trwałość zmiennej również zależy od tego, gdzie została ona zdeklarowana. Zmienne deklarowane w kodzie strony są zachowywane dopóki nie zakończy się przetwarzanie strony — są uruchamiane wraz ze stroną i kończą się razem z nią. Zmienne zadeklarowane w procedurze zaczynają i kończą swe istnienie wspólnie z procedurą. Za każdym razem, gdy procedura jest wywoływana, zmienna jest na nowo definiowana. W ten sposób wartości zapisane w zmiennych zadeklarowanych w procedurze są kasowane w chwili zakończenia jej działania.
Operatory Przy użyciu VBScripta możliwe jest przeprowadzanie w stronach ASP wielu operacji matematycznych. Standardowe operacje, czyli dodawanie, odejmowanie, mnożenie i dzielenie realizuje się przy użyciu operatorów +, - ,* oraz /. Możesz również przeprowadzać dzielenie całkowite, w wyniku którego otrzymujemy liczbę całkowitą bez reszty czy dziesiętnej części ułamkowej. Dzielenie całkowite realizowane jest przy zastosowaniu operatora \. Tak więc wynikiem następującej instrukcji: X = 3 \ 2
będzie wpisanie do zmiennej X wartości 1. Do dyspozycji masz również funkcję Modulus przykład wynikiem kodu:
Operator,
której wartością zwracaną jest reszta z dzielenia. Na
X = 5 MOD 3
będzie przypisanie zmiennej X wartości 2, ponieważ właśnie dwójka jest resztą z tego dzielenia.
ASP – Kompendium programisty
115
Ten rodzaj operacji jest bardzo użyteczny podczas realizowania zadań w pewnych odstępach czasowych, w pętli. Załóżmy, że chcesz wyświetlać w rzędach informacje, które znajdują się w rekordach tabeli, ale żeby te informacje były bardziej czytelne, po każdych dziesięciu rekordach ma się pojawiać nagłówek. Kod mógłby wyglądać w taki sposób: <% 'ten wiersz sprawdza w pętli każdy rekord tabeli Do until RS.EOF 'ten wiersz wypisuje rekord Response.Write RS("TheData") 'zwiększa stanu licznika RecordsPrinted = RecordsPrinted + 1 'sprawdza czy wypisano 10 rekordów if RecordsPrinted MOD 10 = 0 then RESPONSE.Write "Nagłówek" End if 'przejdź do następnego rekordu RS.MoveNext Loop %>
Nagłówek będzie wypisywany po każdych dziesięciu rekordach, to znaczy kiedy wynikiem operacji RecordsPrinted MOD 10 będzie zero. Łączenie ciągów znaków w jeden pojedynczy ciąg nazywane jest składaniem, a realizuje się je przez operator &. Wynikiem poniższego kodu <% Dim OneString Dim TwoString OneString = "Hello" TwoString = OneString & "World!" Response.Write TwoString %>
będzie pojawienie się tekstu "Hello World!" w przeglądarce. Składania można dokonać również przekazując więcej niż jeden ciąg znaków jako pojedynczy parametr: <% Dim OneString Dim TwoString OneString = "Hello" TwoString = "World!" Response.Write TwoString & OneString %>
Zaokrąglania liczb w kodzie dokonuje się przez parę różnych mechanizmów. Możesz użyć funkcji Int, która w prosty sposób obcina część ułamkową liczby: <% Dim X Dim Y X = 3.14
Rozdział 4 – Podstawy ASP
116
Y = int(X) Reaponse.Write Y %>
Wynikiem powyższego kodu będzie wysłanie do przeglądarki cyfry 3. Możesz również zaokrąglać liczby przy użyciu funkcji Round. Przekazujesz funkcji liczbę do zaokrąglenia oraz ilość miejsc po przecinku, do ilu należy zaokrąglić liczbę. Jeśli nie określisz ilości pozycji po przecinku, liczba zostanie zaokrąglona do wartości całkowitej. <% Dim X 'zaokrągla do 3 X = Round(3.199) 'zaokrągla do 3.2 X = Round(3.199, 1) 'również zaokrągla do 3.2 X = Round(3.199, 2) %>
Warunki Często występuje potrzeba sprawdzania w kodzie pewnych wartości i na ich podstawie przeprowadzania odpowiednich zadań. W tym celu podczas tworzenia kodu strony ASP w języku VBScript możesz posłużyć się instrukcjami If i Select Case. Instrukcja If pozwala na sprawdzenie warunku. Jeśli warunek zinterpretowany zostaje jako prawda, kod instrukcji If jest wykonywany. Jeśli warunek oceniony zostaje jako fałsz, to albo kod nie jest wykonywany, albo wykonywana jest ta część kodu, która znajduje się po instrukcji Else. Kompilator interpretuje każdą niezerową wartość jako prawdę, jedynie zero oceniane jest jako fałsz. Dlatego kod: If 5 then
będzie za każdym razem interpretowany jako wartość prawdziwa, ponieważ cyfra 5 jest wartością niezerową. Często będziesz spotykał się z tego typu składnią, w której nie dochodzi do porównania, a jedynie do oceny wartości. Na przykład jeśli chcielibyśmy stworzyć procedurę, która wyszukuje określony znak w ciągu, a następnie po jego pierwszym wystąpieniu zamienia ten znak na jakiś inny, mogłaby ona wyglądać tak: <% Function ConvertIt(StringToConvert, ReplaceChar, ConversionChar) If Instr(StringToConvert, ReplaceChar) then 'tutaj znajduje się kod konwersji end if End Function %>
Zwróć uwagę na instrukcję If. Żadne wartości nie są tutaj porównywane, obliczane jest natomiast wyrażenie. Funkcją używaną podczas obliczania jest Instr, która sprawdza obecność określonego ciągu znaków w innym ciągu. Jeśli ciąg zostanie znaleziony, zwracane jest miejsce jego pierwszego pojawienia się. Następujące wywołanie: Instr("Hello", "l")
ASP – Kompendium programisty
117
zwróci liczbę 3, ponieważ szukana litera „l” pojawia się w słowie po raz pierwszy na trzecim miejscu. Jeśli będziemy chcieli znaleźć w słowie literę „z”, wynikiem poprzedniego wywołania będzie zero, ponieważ ta litera nie pojawia się w testowanym ciągu znaków. Tak więc w powyższej procedurze zamiany znaków, instrukcja If zinterpretuje swój warunek jako prawdę, jeśli funkcja Instr zwróci niezerową wartość, co będzie oznaczało znalezienie znaku w ciągu. Jeśli poszukiwany znak nie zostanie znaleziony, wyrażenie zinterpretowane będzie jako fałsz, ponieważ funkcja Instr zwróci wartość zero. Ważną sprawą do zapamiętania jest możliwość użycia prostego porównania w instrukcji If, ale również to, że możesz użyć obliczonego wyrażenia do określenia zachowania się instrukcji If. Instrukcji If możesz używać na kilka różnych sposobów. Po pierwsze, instrukcja może być użyta w jednym wierszu: <% If Request.QueryString("TheNumber") = 5 then _ Response.Write "Zgadza się! " Response.Write "To wszystko" %>
Po pierwsze zwróć uwagę na znak „_” w pierwszej linii. Spotkałeś się już z nim wcześniej. Jest on nazywany znakiem kontynuacji i używa się go do umieszczenia jednego wiersza kodu w kilku wierszach tekstu, aby uczynić kod bardziej czytelnym. W poprzednim przykładzie instrukcja If zawarta jest w jednym wierszu. Ocenia ona wyrażenie, a jeśli wyniesie ono 5, warunek instrukcji interpretowany jest jako prawda, a wtedy w oknie przeglądarki pojawi się napis Zgadza się!, co pokazano na rysunku 4.8.
Rysunek 4.8. Rezultat wpisania poprawnej cyfry Zauważ, że przeglądający stronę widzi również tekst kolejnego wiersza kodu — To wszystko. Jeśli odwiedzający wpisze inną cyfrę niż pięć, nie zobaczy wiadomości Zgadza się!, lecz jedynie tekst To wszystko, ponieważ ten wiersz kodu znajduje się poza instrukcją If. Do pojedynczego wiersza instrukcji If możesz dodać również instrukcję Else Kod tego wiersza będzie uruchomiony wtedy, gdy wartość wyrażenia instrukcji If zinterpretowana zostanie jako fałsz. Poniższy kod jest przykładem zastosowania instrukcji Else: <% If Request.QueryString("TheNumber") = 5 then _
Ten sam tekst będzie wysłany do przeglądarki, jeśli odwiedzający wpisze właściwą liczbę. W przeciwnym wypadku ujrzą inny tekst, Źle!, jak to pokazano na rysunku 4.9.
Rysunek 4.9. Rezultat wpisania niepoprawnej cyfry Nie musisz ograniczać się do pojedynczego tylko wiersza kodu uruchamianego przez instrukcję If. Możesz tworzyć całe bloki kodowe zarówno dla części If, jak i części Else. <% If Request.QueryString("TheNumber") = 5 then Response.Write "" Response.Write "Zgadza się! " Response.Write "" else Response.Write "" Response.Write "Źle! " Response.Write "" end if Response.Write "To wszystko" %>
Zauważ, że zniknęły znaki kontynuacji. Każda z linii jest jednym wierszem kodu. Zwróć również uwagę na podwójny cudzysłów wokół +2. Jest to sposób na umieszczenie cudzysłowu w ciągu znaków. Teraz rozpoznanie warunku jako prawdy przez instrukcję If spowoduje wykonanie wszystkich wierszy kodu, które znajdują się ponad instrukcją Else. W przeciwnym wypadku wykonane zostaną trzy wiersze kodu znajdujące się poniżej instrukcji Else. Następnie bez względu na warunek, wykonany zostanie kod ostatniego wiersza. Wynik udzielenia nieprawidłowej odpowiedzi jest pokazany na rysunku 4.10.
ASP – Kompendium programisty
119
Rysunek 4.10. Rezultat udzielenia niepoprawnej odpowiedzi w przykładzie z blokiem kodu W obrębie instrukcji If może znaleźć się również instrukcja ElseIf, która sprawdza dodatkowy warunek, jeśli pierwszy warunek If nie został spełniony. Spójrz na poniższy blok kodu: <% If Request.QueryString("TheAge") < 13 then Response.Write "Jesteś dzieckiem" ElseIf Request.QueryString("TheAge") < 20 then Response.Write "Jesteś nastolatkiem" ElseIf Request.QueryString("TheAge") < 40 then Response.Write "Jesteś dorosły" ElseIf Request.QueryString("TheAge") < 60 then Response.Write "Masz doświadczenie" Else Response.Write "Dobrze się bawisz" End If %>
Ten blok wyświetla wiadomość w oparciu o wprowadzony wiek danej osoby. Na wstępie obliczana jest pierwotna instrukcja If. Jeśli wartość TheAge jest mniejsza od 13, wyświetlona zostanie pierwsza wiadomość i kod przeskoczy do instrukcji End If bez sprawdzania pozostałych warunków. Jeśli pierwszy warunek instrukcji If nie jest prawdziwy, oznacza to, że zmienna TheAge musi mieć wartość większą lub równą 13. Wtedy brany pod uwagę jest drugi warunek: ElseIf Request.QueryString("TheAge") < 20 then
W tym momencie kod sprawdza, czy dana osoba ma więcej niż 12, a mniej niż 20 lat. Jeśli tak nie jest, kod wprowadzi następną instrukcję warunkową. Jeśli wartość zmiennej TheAge jest mniejsza od 20, to przed przejściem do End If wykonany zostanie blok kodu poniżej instrukcji warunkowej. Kod przechodzi w ten sposób przez wszystkie instrukcje ElseIf. Jeśli żaden z warunków instrukcji If i ElseIf nie okaże się prawdą, kod przejdzie do bloku Else. Pamiętaj, że nie musisz używać instrukcji Else. Jeśli jej nie będzie i żaden z warunków nie okaże się prawdziwy, kod po prostu wychodzi z instrukcji If. Możesz również zagnieżdżać instrukcje If, to znaczy jedna instrukcja If może znajdować się w kolejnej:
Rozdział 4 – Podstawy ASP
120
<% If Request.QueryString("TheAge") < 13 then Response.Write "Jesteś małym/ą" If Request.QueryString("Sex") = "Female" then Response.Write "dziewczynką" else Response.Write "chłopcem" end if Response.Write "." ElseIf Request.QueryString("TheAge") < 20 then Response.Write "Jesteś nastolatkiem" ElseIf Request.QueryString("TheAge") < 40 then Response.Write "Jesteś dorosły" ElseIf Request.QueryString("TheAge") < 60 then Response.Write "Masz doświadczenie" Else Response.Write "Dobrze się bawisz" End If %>
Kod ten podobny jest do poprzedniego przykładu, ale użyto tutaj dodatkowej instrukcji If. Teraz jeśli pierwszy warunek będzie prawdziwy, w przeglądarce ukaże się tekst Jesteś małym/ą. Następnie szacowany jest kolejny warunek. W efekcie wyświetlany jest dodatkowy tekst, którego treść zależna jest od tego, czy dana osoba jest płci męskiej czy żeńskiej. Bez względu na wprowadzoną wartość, do przeglądarki wysyłana jest również kropka. Tak więc przy zastosowaniu wewnętrznej instrukcji If masz możliwość uruchomienia najpierw jednej części kodu , a po przerwie zależnej od warunku zagnieżdżonej instrukcji, wykonania jego dalszej części. Instrukcje If mogą być umieszczone bardzo głęboko w kodzie, przez co istnieje dla nich wiele możliwych zastosowań. W instrukcjach If możesz również stosować operatory And i Or. Jeśli użyty zostanie And, obydwa warunki muszą zostać spełnione. Przykładowo: If Request.QueryString("TheAge") < 13 and _ Request.QueryString("Sex") = "Female" then
Obydwa warunki muszą być prawdziwe. Dana osoba musi być płci żeńskiej i musi mieć mniej niż 13 lat. Inaczej jest w wypadku tego kodu: If Request.QueryString("TheAge") < 13 or _ Request.QueryString("Sex") = "Female" then
Ta instrukcja If obejmuje wszystkie osoby płci żeńskiej, a także wszystkich, którzy mają mniej niż 13 lat. Aby jej kod został wykonany, przynajmniej jeden z tych warunków musi być spełniony. Możesz łączyć ze sobą warunki And i Or w celu tworzenia warunków złożonych, ale w tym wypadku należy korzystać z nawiasów, aby określić kolejność sprawdzania warunków. Przykładowo: If (LastName = "Flintstone" and FirstName = "Fred") _ Or FirstName = "Wilma" then
Zwróć uwagę na to, że wyrażenie w nawiasie będzie ocenione jako prawda, gdy imię i nazwisko osoby będzie brzmiało Fred Flintstone. Warunek instrukcji będzie prawdziwy również w wypadku, gdy imię danej osoby, bez względu na jej nazwisko, będzie brzmiało Wilma. To co innego niż:
ASP – Kompendium programisty
121 If LastName = "Flintstone" and (FirstName = "Fred" _ Or FirstName = "Wilma") then
Jedyną różnicą między dwoma ostatnimi przykładami kodu polega na innym rozmieszczeniu nawiasów. Warunek tej instrukcji będzie uznany za prawdę tylko dla dwóch osób: Freda Flintstone’a i Wilmy Flintstone. Inną instrukcją warunkową, którą możesz wykorzystać, jest Select Case, która zachowuje się bardzo podobnie do If uzupełnionej o instrukcje ElseIf. Spójrz na ten przykład: <% Select Case Request.QueryString("Quantity") Case 1 Response.Write "$50" Case 2 Response.Write "$90" Case 3 Response.Write "$130" Case 4 Response.Write "$150" Case Else Response.Write "$" & Request.QueryString("Quantity") * 40 End Select %>
Pierwszy wiersz instrukcji Select
Case
zawiera testowany warunek:
Select Case Request.QueryString("Quantity")
Potem następuje seria możliwych wartości warunku oraz odpowiedzi na nie. Pierwsza z nich odpowiada wpisaniu liczby 1: Case 1 Response.Write "$50"
Jeśli tekst zmiennej równy będzie jeden, wykonany zostanie blok znajdujący się poniżej instrukcji. Tak samo będzie w wypadku innych pozycji listy. Podobnie jak to było z instrukcją If, kiedy jeden z bloków jest wykonywany inne są pomijane, a kod przeskakuje do instrukcji End Select. Jeśli pierwszy warunek nie jest spełniony, kod przechodzi do następnego. Jeśli żaden z warunków nie jest rozpoznany jako prawdziwy, kod przechodzi do instrukcji Case Else, która jest odpowiednikiem części Else instrukcji If.
Pętle Mianem pętli określa się fragment kodu, który jest wykonywany wielokrotnie. W tym podrozdziale przyjrzymy się trzem mechanizmom tworzenia pętli: Do Until, For...Next oraz For Each. W pętli Do Until zadanie wykonywane jest dopóki wyrażenie nie będzie zinterpretowane jako prawda. Na przykład: X = 4 Do Until X = 5 Response.Write X X = X + 1
Rozdział 4 – Podstawy ASP
122
Loop
Ten kod przejdzie przez pętlę jeden raz. Kiedy kod wejdzie w pętlę, zmienna X będzie porównana do piątki. Ponieważ podczas pierwszego przejścia przez pętlę ma ona wartość 4, wyrażenie potraktowane zostanie jako fałsz. Wtedy kod w pętli zostanie wykonany. W bloku kodu do zmiennej X dodaje się 1, więc kolejną wartością zmiennej będzie 5.Przy następnym przejściu przez wiersz Do Until, wartość zmiennej X będzie po raz kolejny sprawdzana. Tym razem jednak kod pominie całą pętlę. Tutaj na przykład kod pętli nigdy nie będzie wykonany: X = 5 Do Until X = 5 Response.Write X X = X + 1 Loop
Ponieważ X ma wartość 5 już na samym wstępie, wyrażenie w wierszu Do wypadku kod przechodzi od razu do instrukcji Loop. W następnym przykładzie kod przejdzie przez pętlę trzy razy:
Until
jest prawdą, a w takim
X = 3 Do Until X > 5 Response.Write X X = X + 1 Loop
Podczas pierwszego przejścia wartość X zmieniana jest na cztery, za drugim razem na pięć. Ponieważ pięć jest ostatnią liczbą spełniającą warunek X > 5, kod ponownie przejdzie przez pętlę zmieniając wartość X na sześć. Wtedy po raz pierwszy kod pominie pętlę. Często będziesz używał instrukcji Do Until do przejścia kolejno przez zbiór rekordów bazy danych. Tak samo często będziesz wybierał poszczególne rekordy z bazy danych, aby nimi operować w różnorodny sposób bądź prezentować je użytkownikowi. Zwróć uwagę na następujący blok pokazujący wszystkie produkty, które odwiedzający sklep wirtualny umieścił w koszyku na zakupy. <% set conn = server.createobject ("adodb.connection") conn.open "Ecommerce", "sa", "yourpassword" set RSOrderItems = conn.Execute("select ItemID, " _ & "ItemName, ItemType, Quantity, TotalPrice, " _ & "DetailText from WIOrderItems where " _ & SessionID = " & Session("SessionID")) do until RSOrderItems.EOF %>
O łączeniu się i pracy z bazami danych pomówimy szerzej w rozdziale 14., nie przejmuj się więc, jeśli nie potrafisz zrozumieć powyższego kodu. Na wstępie zwróć uwagę na to, że kod składa się z trzech bloków: pierwszy z nich, zbudowany jedynie z kodu, zawiera informacje inicjujące; drugi łączy w sobie HTML z wbudowanym w niego kodem; trzeci blok zawiera kod, który kończąc pętlę, odsyła nas z powrotem do bloku pierwszego. Pętla zaczyna się w tym wierszu: do until RSOrderItems.EOF
Będziemy poruszać się w pętli tak długo, dopóki będziemy mieli rekordy do przetworzenia. Jeżeli rekordów nie będzie już za pierwszym razem, kod w pętli nie będzie w ogóle wykonywany. Wewnątrz pętli każde pole rekordu jest wpisywane do przeglądarki. Następujący wiersz, na przykład, wypisuje ilość danego produktu: Quantity: <% Response.Write RSOrderItems("Quantity") %>]
Na samym końcu pętli kod przechodzi do kolejnego rekordu, który będzie przetwarzany: RSOrderItems.MoveNext
Następnie słowo kluczowe Loop odsyła kod do instrukcji Do Until i ponownie sprawdzana jest wartość wyrażenia. Jeśli istnieją w bazie cztery rekordy, które należy wyświetlić, kod przejdzie przez pętlę czterokrotnie. Jeśli nie będzie ani jednego rekordu, pętla zostanie w całości pominięta. Kolejnym sposobem na wielokrotną iterację kodu jest pętla For...Next. Ilość przejść przez pętlę For...Next jest określona w kodzie liczbowo. Zamiast sprawdzać wyrażenie, jak to było w wypadku pętli Do Until, pętla For...Next uruchamiana jest przy jednej liczbie, a jej działanie kończy się przy kolejnej. Na przykład: <% Option Explicit Dim I For I = 1 to 3 Response.Write I & " " Next %>
W tym przykładzie kod bloku For...Next zostanie wykonany trzy razy. Na początku do zmiennej I wpisywana jest wartość 1. Ponieważ jeden należy do zakresu od 1 do 3, kod uruchomi blok For...Next. Następnie wartość zmiennej I jest inkrementowana. Teraz wynosi więc już 2, czyli w dalszym ciągu należy do określonego zakresu. Kod ponownie przejdzie przez pętlę i wartość I będzie wynosiła 3. Po kolejnym przejściu będzie to już 4 (poza zakresem od 1 do 3), a wtedy kod przeskoczy pętlę bez jej wykonywania. Jednakże pętla nie musi być uruchamiana przy pierwszej wartości równej jeden. Zwróć uwagę na ten przykład kodu: <% Option Explicit Dim I For I = -3 to 6 Response.Write "Witaj " Next %>
Ta pętla działa dla liczb z zakresu od –3 do 6. Wynikiem jest widok pokazany na rysunku 4.11.
Rozdział 4 – Podstawy ASP
124
Rysunek 4.11. Wynik zastosowania pętli For...Next Kolejnym narzędziem na umieszczenie bloku kodu w pętli jest instrukcja For Each, która jest bardzo podobna do For...Next z tym jednak wyjątkiem, że przechodzi ona kolejno przez zbiór pozycji. Poniższy kod przechodzi przez zbiór o nazwie ServerVariables: <% Option Explicit Dim TheVariable For Each TheVariable in Request.ServerVariables Response.Write TheVariable & " - " _ & Request.ServerVariables(TheVariable) _ & " " Next %>
Jak zostanie to omówione w rozdziale 7., zbiór ServerVariables zawiera informacje o gościach i ich przeglądarkach. Kod przechodzi kolejno przez każdą pozycję zbioru. Każde przejście przez pętlę instrukcji For Each odbywa się przy innej zmiennej serwera. Kod działa dotąd, aż nie zostaną wyświetlone wszystkie zmienne serwera. Wynik wykonania kodu prezentuje rysunek 4.12.
ASP – Kompendium programisty
125
Rysunek 4.12. Wyjście ServerVariables
Konwersja zmiennych Przyjrzyj się następującemu kodowi: <% If "12/1/1999" > "9/1/1966" then Respnse.Write "To działa" else Response.Write "To nie powinno być widoczne" end if %>
Data 1 grudnia 1999 jest późniejsza od 1 września 1966 roku. Spodziewasz się wobec tego, że przeglądarka wyświetli tekst To działa. Ale faktyczny wygląd ekranu przedstawia rysunek 4.13.Wyświetlony tam tekst nie jest tym, którego oczekiwałeś. Problem leży w tym, że kompilator przeprowadza operację porównania tekstu, a nie daty. Podczas porównania tekstu kolejne znaki są zestawiane ze sobą, dopóki jeden z nich nie zostanie określony jako większy. Tak więc najpierw porównywane są ze sobą pierwsze dwie cyfry: 1 i 9. Cyfra 9 jest większa od jedynki , więc całe wyrażenie zinterpretowane zostanie jako fałsz, a przy tym warunku kod przechodzi do instrukcji Else.
Rozdział 4 – Podstawy ASP
126
Rysunek 4.13. Wynik porównania tekstu Z powodu tego typu niespodziewanych błędów, czasami będziesz musiał dokonać konwersji danych. W stronach ASP możesz wykorzystać wiele funkcji konwersji. Jeśli poprzedni kod przebudujemy w następujący sposób: <% If Cdate("12/1/1999") > Cdate("9/1/1966") then Respnse.Write "To działa" else Response.Write "To nie powinno być widoczne" end if %>
to otrzymamy poprawny rezultat, pokazany na rysunku 4.14.
ASP – Kompendium programisty
127
Rysunek 4.14. Wynik poprawnej konwersji daty Różnica pomiędzy tymi dwoma blokami polega na użyciu w drugim z nich funkcji CDate, która konwertuje daną na datę. Jeśli zmienna nie jest datą, funkcja zwróci błąd. VBScript jest wyposażony w kilka funkcji podobnych do CDate. Ich nazwy rozpoczynają się od litery C, co oznacza, że ich przeznaczeniem jest konwersja. Dalsza część nazwy określa wyjściowy typ danych, na które funkcja dokonuje konwersji. Na przykład CInt zamienia daną na liczbę całkowitą, a Cbool na format boole’owski.
Funkcje daty i czasu Zapewne już zauważyłeś, analizując kilka przytoczonych w książce przykładów kodu, że często zachodzi potrzeba operowania datami. W VBScripcie masz do dyspozycji wiele odpowiednich do tego funkcji. Czasami będziesz musiał wykorzystać aktualną datę i czas. Może zajść potrzeba stworzenia zapytania wykorzystującego aktualne rekordy lub umieszczenia znacznika czasu w rekordzie bazy danych; być może będziesz również chciał wyświetlać czas i datę na twojej stronie WWW. Czynności takie mogą być zrealizowane przez trzy funkcje: Date, Time i Now. Funkcja Date zwraca aktualną datę systemową, funkcja Time aktualny czas systemowy, natomiast funkcja Now zarówno datę, jak i czas. Pamiętaj jednak, że aktualne wartości systemowe to takie, które serwer uznaje za aktualne. Składnia tych funkcji jest następująca: <% Response.Write Date & " " Response.Write Time & " " Response.Write Now %>
Metoda Response.Write (omówiona w rozdziale 6.) wpisuje tekst do przeglądarki. Funkcje nie pobierają parametrów, a ich wyjście pokazuje rysunek 4.15.
Rozdział 4 – Podstawy ASP
128
Rysunek 4.15. Wynik funkcji Date, Time i Now Często będziesz chciał korzystać jedynie z części daty. Na przykład możesz potrzebować tylko miesiąca, aby zbudować listę urodzin pracowników w bieżącym miesiącu: If Month(RS("BirthDate")) = Month(Date) then
Ten kod zrealizuje to zadanie. Funkcja Month wypisuje numer miesiąca aktualnej daty. Po znaku równości pojawia się funkcja Date, która zwraca datę systemową, a następnie funkcja Month, która wybiera z daty aktualny miesiąc. Dostępne są rozmaite funkcje, które realizują wyodrębnianie części daty lub czasu. Poniższy kod jest ich przeglądem: <% Response.Write "Rok: " & Year(Date) & " " Response.Write "Numer miesiąca: " & Month(Date) & " " Response.Write "Dzień miesiąca: " & Day(Date) & " " Response.Write "Numer dnia tygodnia: " & WeekDay(Date) & " " Response.Write "Godzina: " & Hour(Time) & " " Response.Write "Minuta: " & Minute(Time) & " " Response.Write "Sekunda: " & Second(Time) & " " %>
Rezultat widoczny jest na rysunku 4.16.
ASP – Kompendium programisty
129
Rysunek 4.16. Wynik wyodrębniania funkcji Date i Time Często chcesz znać odstęp czasu pomiędzy dwoma datami. Na przykład chcesz wiedzieć jak dawno dany klient płacił rachunek. Może będziesz chciał wyliczyć jak długo określony pracownik pracuje w twojej firmie. Może zajdzie potrzeba obliczenia czyjegoś wieku. Tego typu zadania realizuje funkcja DateDiff. Funkcja DateDiff odejmuje od siebie dwie daty i zwraca wynik w wybranych przez ciebie jednostkach czasu. Tymi jednostkami mogą być na przykład godziny czy też lata. Format funkcji jest następujący: DateDiff (UnitForResult, DateSubtracting, DateSubtractedFrom)
Możliwości wyboru pierwszego parametru prezentuje tabela 4.1. Tabela 4.1. Wyjściowe jednostki funkcji DateDiff. Jednostka Znaczenie yyyy Rok q Kwartał m Miesiąc d Dzień h Godzina n Minuta s Sekunda Jeśli więc chciałbyś wiedzieć ile miesięcy upłynęło od początku dwudziestego wieku, kod wyglądałby w ten sposób: <% Response.Write DateDiff("m", "1/1/1901", Date) %>
Jeśli chciałbyś znać ilość dni, które upłynęły od planowego terminu zapłaty należności przez klienta, kod mógłby być następujący: <% Response.Write DateDiff("d", RS("DueDate"), Date)
Rozdział 4 – Podstawy ASP
130
%>
A tak obliczyłbyś wiek pracownika: <% Response.Write DateDiff("yyyy", RS("EmpAge"), Date) %>
Czasami jednak będziesz chciał wyliczyć jedną datę na podstawie drugiej. Może to być jutrzejsza data, określająca dzień wysyłki danego produktu lub dzień zapłaty należności, obliczony jako trzydziesty dzień po dacie wystawienia rachunku. Być może będziesz również chciał zaplanować wykonanie określonych zadań w oparciu o żądania. Wszystkie te przypadki wymagają wykonania operacji dodawania bądź odejmowania dat. Temu celowi służy funkcja DateAdd. Format funkcji DateAdd jest następujący: DateAdd(Unit, Amount, DateToChange)
Pierwszy parametr Unit to jednostka operacji. Możesz dodawać lub odejmować lata, miesiące i wszystkie inne jednostki czasu wyszczególnione w tabeli 4.1. Drugi parametr, Amount, określa ilość jednostek czasu, które chcesz dodać bądź odjąć. Trzeci parametr, DateToChange, jest datą, do której będziesz dodawał lub od której będziesz odejmował określoną wcześniej ilość jednostek. Funkcja zwraca datę w oparciu o wprowadzone parametry. Jeśli chciałbyś obliczyć jutrzejszą datę, kod mógłby być taki: <% Response.Write DateAdd("d", 1, Date) %>
Jeśli chciałbyś obliczyć datę, jaka była miesiąc temu, użyjesz jako pierwszego parametru "m" (Jednostka) oraz drugiego –1 (Ilość): <% Response.Write DateAdd("m", -1, Date) %>
Aby obliczyć, która godzina będzie za trzy godziny, kod będzie następujący: <% Response.Write DateAdd("h", 3, Time) %>
Aby osiągnąć pożądany wynik, czasami zajdzie potrzeba połączenia kilku funkcji opisanych w tym podrozdziale. Powiedzmy, że chcesz wpisać do przeglądarki zakres dni, które upłynęły od początku roku: <% Response.Write "1/1/" & Year(Date) & " do " & Date %>
Jeśli chcesz poznać ostatni dzień bieżącego miesiąca, możesz napisać taki kod: <% Response.Write DateAdd("d", -1, Month(DateAdd("m", 1, Date)) _ & "/1/" & Year(DateAdd("m", 1, Date)))
ASP – Kompendium programisty
131 %>
Najlepszą metodą na odczytanie takich kodów jest przechodzenie od środka kodu na zewnątrz. Metoda ta świetnie sprawdza się również podczas tworzenia logicznej konstrukcji kodu. Na najniższym poziomie ostatniego przykładu kodu znajduje się funkcja Date, która zwraca aktualną datę. Pierwsze jej wystąpienie jest wykorzystywane przez funkcję DateAdd do określenia daty późniejszej o miesiąc od aktualnej. Z tej wartości wyodrębniany jest miesiąc. Jest on składany z tekstem "/1/". Mamy więc już miesiąc i dzień. Następnie dołączamy do tego rok kolejnego miesiąca po bieżącym. W tym momencie cały ciąg Month(DateAdd("m", 1, Date)) & "/1/" & Year(DateAdd("m", 1, Date))
jest interpretowany jako pierwszy dzień kolejnego miesiąca. Ta wartość z kolei wykorzystywana jest jako trzeci parametr funkcji DateAdd, która odejmuje od tej daty jeden dzień, otrzymując w wyniku ostatni dzień bieżącego miesiąca.
Zatwierdzanie obecności i typów danych Jeśli umożliwiasz odwiedzającym wejście na twoją witrynę, czasami będziesz musiał zatwierdzać dane, które oni wprowadzają. Będziesz musiał wiedzieć, czy wprowadzona dana jest datą, czy liczbą. Możesz sprawdzać, czy określone pole zostało wypełnione lub czy dana należy do poprawnego zakresu. W tym podrozdziale przyjrzymy się funkcjom realizującym tego typu zadania. Jedną z funkcji, z którą często już się spotykaliśmy, jest funkcja IsEmpty, która sprawdza obecność danego elementu. Często korzysta się z niej do sprawdzenia, czy pole formularza HTML zostało wypełnione. Taki mechanizm tekstowy jest w tym względzie bardzo pomocny. Często będziesz chciał ująć wszystkie możliwości formularza w jedną stronę ASP. W jednym stanie strona mogłaby wyświetlać formularz z polami, które odwiedzający musiałby wypełnić. W stanie kolejnym odwiedzający przesyłałby formularz naciskając przycisk lub grafikę. Następnie kod strony ASP podejmowałby odpowiednią akcję przetworzenia danych. Sposobem na określenie stanu strony jest sprawdzenie, czy przycisk przesłania formularza został naciśnięty. Robi się to przy użyciu funkcji IsEmpty. Zwróć uwagę na formularz pokazany na rysunku 4.17.
Rysunek 4.17. Przykładowy formularz określający stan przy użyciu funkcji IsEmpty
Rozdział 4 – Podstawy ASP
132
Kiedy odwiedzający wywołają tą stronę, powinni ujrzeć formularz. Gdy następnie nacisną przycisk Logowanie, zobaczą inną stronę, którą przestawia rysunek 4.18.
Rysunek 4.18. Widok strony po przesłaniu formularza Jeśli obydwie strony mają być wykonane w ramach jednej strony ASP, musisz użyć funkcji IsEmpty do określenia stanu przycisku Logowanie, a następnie podjąć odpowiednią akcję w oparciu o wynik funkcji: <% if not isempty(Request.Form("LogIn")) then set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" set RSUser = conn.Execute("select UserName from C1Login " _ & "where UserName = '" & Request.Form("UserName") _ & "' and Password = '" & Request.Form("Password") _ & "'") if RSUser.EOF then TheMessage = "Wprowadziłeś niewłaściwe dane. " _ & "Spróbuj jeszcze raz" else TheMessage = "Jesteś zalogowany!" end if else TheMessage = "Poniżej wpisz nazwę i hasło" end if %>
Funkcja IsEmpty zwraca prawdę, jeśli testowany element jest pusty lub nie jest obecny. Zwraca natomiast fałsz, jeśli element posiada wartość. W ten sposób przez instrukcję If: if not isempty(Request.Form("LogIn")) then
ASP – Kompendium programisty
133
oraz przy użyciu operatora Not sprawdzamy, czy przycisk Logowanie jest obecny i przyciśnięty. Jeśli tak jest, wykonywany jest kod przetwarzający zawartość pól formularza. Kiedy uzupełniasz bazę o nowe dane lub kiedy musisz wykonać obliczenia na pewnych danych (w obydwu z tych przypadków operacje te dokonywane są poprzez wejście użytkownika), musisz rozpoznawać, czy typ wprowadzonej wartości jest poprawny. Musisz wiedzieć, czy wprowadzana data jest faktycznie datą, a liczba liczbą. Aby sprawdzić, czy dana jest datą, możesz skorzystać z funkcji IsDate. Zwraca ona prawdę wtedy, gdy przekazana wartość jest datą, w przeciwnym razie zwracany jest fałsz. Jeśli miałbyś formularz HTML, mógłbyś użyć funkcji IsDate w celu przetestowania wartości wprowadzonej przez odwiedzającego do formularza: <% Option Explicit Dim TheMessage If IsDate(Request.Form("BirthDate")) then TheMessage = "Wprowadziłeś datę!" Else TheMessage = "Wprowadziłeś niewłaściwą wartość w pole daty urodzenia!" End If %>
W tym przykładzie funkcja IsDate testuje pole formularza HTML o nazwie BirthDate. Następnie kod generuje wiadomość, która będzie wyświetlana w HTML-u, której treść będzie zależała od danych wprowadzonych przez użytkownika. Aby sprawdzić, czy zmienna, właściwość czy pole bazy danych jest liczbą, możesz użyć funkcji IsNumeric. Podobnie jak w wypadku funkcji IsDate, IsNumeric zwraca prawdę bądź fałsz. Prawda zwracana jest wtedy, gdy przekazana funkcji wartość jest liczbą, w przeciwnym razie wartością wyjściową będzie fałsz. Jeśli chciałbyś wykorzystać funkcję do testowania wejścia użytkownika w polu formularza HTML, kod mógłby wyglądać tak: <% Option Explicit Dim TheMessage If IsNumeric(Request.Form("Quantity")) then TheMessage = "Wprowadziłeś poprawną ilość!" Else TheMessage = "Wprowadziłeś niewłaściwą wartość w polu ilości!" End If %>
Kod wyświetli tekst wiadomości, której treść będzie zależała od wartości wprowadzonej przez odwiedzającego.
Techniki zatwierdzania danych Często będzie zachodziła potrzeba zatwierdzania zakresu liczby czy daty. Na przykład data urodzenia powinna być datą, a oprócz tego nie może być datą przyszłą; podobnie ilość produktu nie może być liczbą ujemną ani nie może przekraczać ustalonej górnej granicy. W tym podrozdziale poznamy kody, które pomagają rozwiązywać takie kwestie związane z zatwierdzaniem. Jeśli musisz stwierdzić, czy podana data urodzenia nie jest datą przyszłą, twój kod mógłby wyglądać tak: <% Option Explicit Dim TheMessage If IsDate(Request.Form("BirthDate")) then If Cdate(Request.Form("BirthDate")) <= Date then
Rozdział 4 – Podstawy ASP
134
TheMessage = "Wartość poprawna" Else TheMessage = "Data urodzenia nie może być datą przyszłą!" End If Else TheMessage = "Wartość, którą wprowadziłeś, nie jest datą" End If %>
Zauważ, w jaki sposób zastosowanie akapitów poprawiło czytelność struktur instrukcji If. Ponadto zwróć uwagę na funkcję Date, która użyta została do porównania daty wprowadzonej z datą systemową. Jak już się dowiedziałeś z treści tego rozdziału, zastosowanie funkcji CDate było konieczne, aby porównanie w instrukcji If było porównaniem daty, a nie tekstu. Możesz również ustalić dolną granicę dla wprowadzanej daty urodzenia, na przykład 150 lat wstecz. Poniższy kod zawiera to dodatkowe sprawdzanie daty: <% Option Explicit Dim TheMessage If IsDate(Request.Form("BirthDate")) then If Cdate(Request.Form("BirthDate")) > Date then TheMessage = "Data urodzenia nie może być datą przyszłą!" ElseIf DateDiff("yyyy", Request.Form("BirthDate"), Date) > 150 TheMessage = "Poprawna data urodzenia nie została wprowadzona!" Else TheMessage = "Wartość poprawna" End If Else TheMessage = "Wartość, którą wprowadziłeś, nie jest datą" End If %>
Dodatkowa instrukcja ElseIf używa funkcji DateDiff w celu określenia ilości lat pomiędzy aktualną datą a datą urodzenia wprowadzoną przez odwiedzającego. Jeśli różnica ta wynosi więcej niż 150 lat, wyświetlana jest wiadomość o błędzie. Kiedy dana jest liczbą, często występuje potrzeba ustalenia dla niej dolnej i górnej granicy. Jeśli dysponujesz polem ilości wypełnianym przez gości witryny, to chciałbyś, aby podana wartość nie przekraczała pewnych rozsądnych granic. Taką możliwość zapewnia poniższy kod: <% Option Explicit Dim TheMessage If IsNumeric(Request.Form("Quantity")) then If CInt(Request.Form("Quantity")) < 1 then TheMessage = "Musisz zamówić przynajmniej jedną rzecz!" ElseIf CInt(Request.Form("Quantity")) > 250 then TheMessage = "Ilość nie może być większa od 250!" Else TheMessage = "Zamówienie przyjęte" End If Else TheMessage = "Ilość musi być liczbą!"
ASP – Kompendium programisty
135 End If %>
W tym kodzie użyto funkcji CInt. Dzięki niej dokonujemy konwersji podanej wartości na wartość całkowitą, tak więc realizujemy porównanie liczbowe, a nie porównanie tekstu.
Formatowanie liczb, dat i kwot pieniężnych Umieszczając na swojej stronie ASP informacje o liczbach, datach oraz kwotach chciałbyś, aby były one wyświetlane wspólnie z odpowiednimi znakami interpunkcyjnymi. Na przykład chcesz, aby liczby miały przecinki we właściwym miejscu lub dzień, miesiąc i rok były oddzielone od siebie znakiem /. W tym podrozdziale omówimy funkcje wspomagające takie zadania. Funkcja FormatDateTime pozwala na formatowanie daty lub czasu, lub obu tych wartości jednocześnie. Funkcja ta ma następującą składnię: FormatDateTime(DateToFormat, HowToFormat)
Pierwszy parametr to data lub czas, którą chcesz sformatować. W drugim parametrze określasz sposób, w jaki chcesz wyświetlać datę lub czas. Poniższy kod prezentuje przegląd różnych dostępnych formatów wyjściowych: <% Response.Write "Format ogólny (Domyślny): " Response.Write FormatDateTime(Now,0) & "
Wynik użycia różnych formatów wyświetlania czasu prezentuje rysunek 4.19.
Rozdział 4 – Podstawy ASP
136
Rysunek 4.19. Wyjście funkcji FormatDateTime Zauważ, że Format ogólny jest wartością domyślną, dlatego jeśli nie określisz żadnych parametrów, wyświetlony zostanie właśnie ten format. Poza tym w wywołaniu zastosowano funkcję Now. Z wyniku tej funkcji podczas formatowania wyodrębniana jest, w zależności od potrzeb, data lub czas. Funkcja FormatCurrency pozwala na formatowanie wartości pieniężnych. Pamiętaj, że sformatowana kwota zostanie opatrzona oznaczeniem tej waluty, która zdefiniowana została na komputerze gościa. Funkcja ma następującą postać: FormatCurrency(ValueToConvert, NumDecimalPlaces, LeadingZero, _ NegsInParans, GroupNumbers)
Funkcja zwraca kwotę pieniężną sformatowaną jako ciąg. Wszystkie parametry, oprócz pierwszego, są fakultatywne. Domyślne wartości parametrów są zależne od domyślnych ustawień systemu operacyjnego gościa. Zwykle więc funkcję tą wywołuje się bez określania dodatkowych parametrów. Pierwszy parametr, ValueToConvert, jest wartością, którą chcesz sformatować. Drugi, NumDecimalPlaces, określa ilość wyświetlanych miejsc po przecinku. Trzeci parametr, LeadingZero, pozwala na włączenie lub wyłączenie zera wiodącego dla liczb, których wartość bezwzględna jest mniejsza od 1. Parametr NegsInParans pozwala na wyświetlanie liczb ujemnych albo ze znakiem, albo w nawiasie. Dzięki ostatniemu parametrowi, GroupNumbers, możesz wyświetlić dużą kwotę pieniężną jako jedną grupę cyfr, bez przecinków oddzielających od siebie setki, tysiące, miliony itd. Kilka wywołań funkcji przedstawiono poniżej: <% Response.Write FormatCurrency(12345.67) & "
Zauważ, że jeśli chcesz w wywołaniu pominąć niektóre parametry, a niektóre określić, musisz zastosować odpowiednią ilość dodatkowych przecinków. Wyjście kodu pokazuje rysunek 4.20.
ASP – Kompendium programisty
137
Rysunek 4.20. Wyjście funkcji FormatCurrency Funkcja FormatNumber jest bardzo podobna do FormatCurrency z tą tylko różnicą, że nie wyświetla ona symbolu waluty. Ma ona następujący format: FormatNumber(ValueToConvert, NumDecimalPlaces, LeadingZero, _ NegsInParans, GroupNumbers)
Podobnie jak poprzednio, również funkcja FormatNumber posiada parametry określające ilość miejsc po przecinku, obecność zera wiodącego, wyświetlanie minusa dla liczb ujemnych oraz grupowanie cyfr części całkowitej. Przykłady użycia funkcji wyszczególniono poniżej: <% Response.Write FormatNumber(.67) & "
Rysunek 4.21. Wyjście funkcji FormatNumber Inną funkcją formatującą, o której należy wspomnieć w tym podrozdziale jest FormatPercent. Jest ona podobna do dwóch poprzednich z tą tylko różnicą, że przekazaną wartość funkcja mnoży przez 100, a następnie dodaje do wyniku symbol procentów. Przyjmuje ona następującą postać: FormatPercent(ValueToConvert, NumDecimalPlaces, LeadingZero, _ NegsInParans, GroupNumbers)
Pierwszy parametr jest formatowaną liczbą i to ta właśnie wartość jest mnożona razy 100. Reszta parametrów jest fakultatywna, a ich domyślne ustawienia zależą od ustawień systemu. Wywołania funkcji FormatPercent mogą być następujące: <% Response.Write FormatPercent(.67) & "
" Response.Write FormatPercent(-.67) & "
" Response.Write FormatPercent(23.67) & "
" Response.Write FormatPercent(23.67, 0) & "
" %>
Wyjście tych wywołań prezentuje rysunek 4.22.
ASP – Kompendium programisty
139
Rysunek 4.22. Wyjście funkcji FormatPercent Czasami jednak same wywołania nie wystarczają. Szczególnie w wypadku dat przekonasz się, że musisz wyjść poza gotowe formaty i tworzyć swoje własne. Używając funkcji daty (omówionych wcześniej w tym rozdziale) do wyodrębniania bądź łączenia ze sobą części daty, możesz znaleźć rozwiązanie odpowiadające twoim potrzebom.
Operowanie ciągami Przy wyświetlaniu informacji lub przy uzyskiwaniu ich od odwiedzających stronę często będziesz musiał operować ciągami. Być może zajdzie potrzeba zmiany ich wielkości liter, podzielenia, zmiany bądź wyszukania ciągów. Niniejszy podrozdział omawia funkcje realizujące takie zadania. Na początku przyjrzymy się dwóm funkcjom zmieniającym wielkość liter w ciągu — LCase i UCase. Funkcja LCase zamienia wszystkie litery ciągu na małe, natomiast funkcja UCase — dokonuje konwersji na duże litery. Oto przykład użycia funkcji LCase: <% Option Explicit Dim StringToConvert StringToConvert = "HELLO" Response.Write LCase(StringToConvert) %>
Do przeglądarki wysłany zostanie ciąg "hello". A teraz przykład użycia funkcji UCase: <% Option Explicit Dim StringToConvert StringToConvert = "hello" Response.Write UCase(StringToConvert) %>
Tym razem w przeglądarce pojawi się ciąg "HELLO".
Rozdział 4 – Podstawy ASP
140
Funkcje te okażą się użyteczne podczas pracy ze starszymi systemami baz danych, które nie tolerują małych liter. Kolejnym zastosowaniem powyższych funkcji jest konwersja danych na potrzeby tych systemów baz danych, które uwzględniają wielkość liter. Możliwość wydzielenia części z ciągu znaków w stronach ASP dają funkcje Left, Right oraz Mid. Wydzielenie ciągu czasami jest konieczne podczas obsługi danych przekazywanych twojemu kodowi, choćby wtedy, gdy części jednego ciągu muszą być wyświetlone w osobnych polach. Funkcje Left, Right oraz Mid pomogą w realizacji tego typu zadań, ale jak się zaraz przekonasz, często podczas dzielenia ciągu będzie trzeba wykorzystywać funkcje Instr i Len. Funkcja Left pozwala na wydzielenie części ciągu patrząc od lewej jego strony. Składnia funkcji jest następująca: Left(StringToChop, NumCharacters)
Pierwszy parametr jest ciągiem, z którego będziesz wycinał znaki. Drugi parametr zawiera ilość znaków, które chcesz wydzielić. Na przykład: <% Option Explicit Dim StringToChop StringToChop = "New Mexico" Response.Write Left(StringToChop, 3) %>
Do przeglądarki wpisany zostanie tekst "New". Funkcja Right wydziela znaki ciągu patrząc od jego prawej strony. Składnia funkcji: Right(StringToChop, NumCharacters)
Pierwszy parametr jest ciągiem, z którego chcesz wydzielić znaki. Drugi parametr określa ilość wydzielanych znaków, co pokazano poniżej: <% Option Explicit Dim StringToChop StringToChop = "New Mexico" Response.Write Right(StringToChop, 6) %>
Tym razem do przeglądarki wysłana zostanie tekst "Mexico". Funkcja Mid zwraca znaki wydzielone ze środka ciągu. Jej składnia jest nieco inna niż w przypadku dwóch pozostałych funkcji: Mid(StringToChop, StartPosition, NumCharacters)
Pierwszy parametr jest ciągiem znaków, z którego chcesz wydzielać znaki. Drugi parametr określa pozycję pierwszego znaku wydzielanego ciągu. Trzeci parametr, opcjonalny, określa ilość znaków, które chcesz wyciąć. Jeśli nie określisz tego parametru, funkcja zwróci wszystkie znaki od pozycji początkowej (określonej przez drugi parametr) do końca ciągu. Poniższy kod prezentuje wykorzystanie funkcji Mid: <% Option Explicit Dim StringToChop
Pierwszym tekstem wpisanym do przeglądarki byłby "Mex", ponieważ parametry określają piąty znak ciągu jako początkowy oraz ilość wydzielanych znaków — trzy. Jednak kolejny wiersz wpisze do przeglądarki tekst "Mexico". Pozycja początkowa w obu instrukcjach jest ta sama, ale brak trzeciego parametru w drugiej instrukcji Response.Write powoduje, że wszystkie znaki począwszy od piątego, a skończywszy na ostatnim, znajdą się w przeglądarce. Jak wspomniano wcześniej, podczas dzielenia ciągów przy użyciu wyżej opisanych funkcji, będziesz musiał wykorzystać funkcje Instr i Len. Funkcja Len zwraca ilość znaków w ciągu. Ma następującą składnię: Len(StringToMeasure)
Zmienną przekazywaną funkcji jest nazwa ciągu, którego długość chcesz sprawdzić. Ta długość jest zwracana przez funkcję. Przykładowo: <% Option Explicit Dim StringToMeasure StringToMeasure = "New Mexico" Response.Write Len(StringToMeasure) %>
Do przeglądarki wpisana zostaje liczba 10. Funkcja Instr sprawdza obecność określonego ciągu znaków w innym ciągu. Gdy zostaje znaleziony, funkcja zwraca pozycję znaku, gdzie ciąg został znaleziony. Jeśli poszukiwany ciąg nie jest częścią testowanego ciągu, funkcja zwraca wartość zero. Składnia funkcji jest następująca: Instr(StartingPosition, String2Search, SearchString, ComparisonType)
Parametr drugi i trzeci muszą być podane. Drugi parametr jest ciągiem, który przeszukujesz. Trzeci parametr reprezentuje ciąg lub znak, którego szukasz. Parametr pierwszy, fakultatywny, określa pozycję, od której chcesz rozpocząć przeszukiwanie. Jeśli nie zostanie określony, pozycją startową będzie początek ciągu. Czwarty parametr określa, czy typ porównania ma być binarny czy tekstowy. Podczas porównania na poziomie binarnym rozpoznawana jest wielkość liter; nie znalazłbyś na przykład litery „D” w słowie „duży”. Natomiast podczas porównania tekstu wielkość liter nie jest ważna, tak więc wynik poszukiwania litery „D” w słowie „duży” byłby pozytywny. Domyślną wartością parametru jest porównanie binarne. Jeśli chciałbyś określić typ porównania własnoręcznie, dla binarnego wpisz 0, a dla tekstowego 1. Kilka przykładów pomoże wytłumaczyć sposób wykorzystania tej funkcji. <% Option Explicit Dim String2Search Dim SearchString String2Search = "Mississippi" SearchString = "s" Response.Write Instr(String2Search, SearchString) '3 jest wpisywane do przeglądarki Response.Write Instr(3, String2Search, SearchString) '3 jest wpisywane do przeglądarki w dalszym ciągu _
Rozdział 4 – Podstawy ASP
142
ponieważ 3 pozycja jest punktem startowym Response.Write Instr(5, String2Search, SearchString) '6 jest wpisywane do przeglądarki SearchString = "Z" Response.Write Instr(String2Search, SearchString) '0 jest wpisywane do przeglądarki, ponieważ ciąg nie został znaleziony SearchString = "P" Response.Write Instr(String2Search, SearchString) 'znowu 0, ponieważ ważna jest wielkość liter Response.Write Instr(1 ,String2Search, SearchString, 1) 'Porównanie tekstu, więc wynikiem będzie 9 %>
Kolejną funkcją, bardzo podobną do Instr, jest funkcja InstrRev. Różnica pomiędzy tymi dwoma funkcjami polega na tym, że funkcja InstrRev zaczyna przeszukiwanie ciągu od jego końca, podając jednak pozycję znalezionego znaku licząc od przodu. Składnia funkcji jest następująca: InstrRev(StartingPosition, String2Search, SearchString,
ComparisonType)
Drugi parametr określa ciąg, który przeszukujesz, trzeci jest szukanym ciągiem. Pozostałe dwa parametry są fakultatywne. Pierwszy z nich to pozycja startowa, od której należ zacząć przeszukiwanie. Przez określenia ostatniego parametru wybierasz binarny bądź tekstowy typ porównania. Poniższy blok kodu demonstruje sposób wykorzystania funkcji: <% Option Explicit Dim String2Search Dim SearchString String2Search = "Mississippi" SearchString = "s" Response.Write InstrRev(String2Search, SearchString) %>
Wynikiem wykonania kodu będzie wysłanie do przeglądarki liczby 7, jest to bowiem pozycja pierwszego wystąpienia litery „s” w słowie Mississippi, patrząc od końca ciągu. Jednak naprawdę użyteczne stają się te funkcje dopiero wtedy, gdy się je połączy. Zwróćmy uwagę na przykład procedury zatwierdzającej wprowadzony przez użytkownika adres poczty elektronicznej. Poniższy kod pokazuje, jak to można zrobić: <% Option Explicit Dim TheAt Dim TheDot Dim FieldToTest FieldToTest = "[email protected]" If Len(FieldToTest) < 6 then Response.Write "Adres e-mail jest nieprawidłowy!" Else TheAt = InStr(2, FieldToTest, "@") If TheAt = 0 Then Response.Write "Adres e-mail jest nieprawidłowy!" Else
ASP – Kompendium programisty
143 TheDot = InStr(cint(TheAt) + 2, FieldToTest, ".") If TheDot = 0 Then Response.Write "Adres e-mail jest nieprawidłowy!" ElseIf cint(TheDot) + 1 > Len(FieldToTest) Then Response.Write "Adres e-mail jest nieprawidłowy!" Else Response.Write "Adres e-mail jest prawidłowy!" End If End If End If %>
Na wstępie użyto funkcji Len w celu sprawdzenia, czy wprowadzony adres ma długość przynajmniej sześciu znaków: If Len(FieldToTest) < 6 then
Adres poczty musi zawierać symbol małpy „@”. Kod to sprawdza: TheAt = InStr(2, FieldToTest, "@") If TheAt = 0 Then
Funkcja Instr sprawdza, czy w ciągu wystąpił symbol „@”. Jeśli nie, funkcja zwraca zero. Następnie w podobny sposób sprawdzana jest obecność kropki w podanym adresie e-mail: TheDot = InStr(cint(TheAt) + 2, FieldToTest, ".") If TheDot = 0 Then Response.Write "Adres e-mail jest nieprawidłowy!"
Zauważ, że startową pozycją, od której zaczyna się poszukiwanie kropki, jest drugi znak za symbolem małpy. Tak więc adres e-mail nie tylko musi zawierać kropkę, ale również musi ona znaleźć się na właściwej pozycji. Następnie kod sprawdza znaki po kropce: ElseIf cint(TheDot) + 1 > Len(FieldToTest) Then
Będzie to część com adresu e-mail. Teraz przyjrzyjmy się kodowi wypisującemu samo nazwisko z pola bazy danych mogącego zawierać zarówno imię, jak i nazwisko. <% Option Explicit 'Tutaj jest kod łączący się z bazą danych If Instr(RS("FullName"), " ") then Response.Write Mid(RS("FullName"), Instr(RS("FullName"), " ") + 1) Else Response.Write RS("FullName") End If %>
Pole FullName może zawierać imię i nazwisko lub po prostu samo nazwisko. Aby sprawdzić, co zostało wpisane w pole, kod sprawdza na początku, czy zawiera ono znak spacji:
Rozdział 4 – Podstawy ASP
144
If Instr(RS("FullName"), " ") then
Jeśli spacja się pojawiła, to kod zakłada, że ciąg znaków po spacji jest nazwiskiem. Funkcja Mid zwraca wszystkie znaki po znaku spacji: Response.Write Mid(RS("FullName"), Instr(RS("FullName"), " ") + 1)
Zapamiętaj sobie tych kilka funkcji. Rozwiązanie wielu problemów związanych z kodowaniem będzie możliwe dzięki ich zastosowaniu. Czasami będziesz chciał stworzyć ciąg, który zawierałby jakieś znaki niewidoczne, takie jak znak tabulacji czy pusty wiersz. Jeśli na przykład chciałbyś wysłać adres e-mail poprzez swój kod, potrzebowałbyś nowego wiersza w celu rozmieszczenia tekstu. W takich wypadkach możesz użyć funkcji Chr: TheText = "Hello" & Chr(13) & "World"
Zmienna TheText będzie teraz zawierała pusty wiersz pomiędzy dwoma słowami. Funkcja Replace pozwala na zastąpienia jednego ciągu znaków innym. Ma ona następujący format: Replace(String2Change, SearchString, ReplaceString, _ StartPosition, NumberOfChanges, ComparisonType)
Pierwszy parametr określa ciąg, w którym chcesz dokonać zmian. Drugi jest ciągiem lub znakiem, który będzie zastępowany. Trzeci parametr zapamiętuje ciąg lub znak, na który ma być dokonana zmiana. Reszta to parametry opcjonalne. Czwarty określa pozycję, od której chcesz rozpocząć dokonywanie zmian (wszystkie znaki przed wyszczególnioną pozycją zostaną pominięte i nie będą wysłane do przeglądarki). Piąty definiuje maksymalną ilość zmian. Ostatni parametr precyzuje typ przeprowadzanego poszukiwania, tekstowego, bez rozpoznawania wielkości liter lub binarnego, gdzie wielkość liter jest identyfikowana. Kilka przykładów zastosowania funkcji Replace ukazano poniżej: <% 'zwykła zamiana Response.Write Replace("Mississippi", "s", "x") & "
" 'początek przeszukiwania od pozycji 5 Response.Write Replace("Mississippi", "s", "x", 5) & "
" 'początek przeszukiwania od pozycji 1 i dwie zamiany Response.Write Replace("Mississippi", "s", "x", 1, 2) & "
" 'początek przeszukiwania od pozycji 4 i dwie zamiany Response.Write Replace("Mississippi", "s", "x", 4, 2) & "
" 'zwykła zamiana, ale znak nie został znaleziony Response.Write Replace("Mississippi", "S", "x") & "
" 'to samo, ale teraz porównywany jest tekst Response.Write Replace("Mississippi", "S", "x", 1, 4, 1) %>
Wyniki kodu są pokazane na rysunku 4.23.
ASP – Kompendium programisty
145
Rysunek 4.23. Wyniki funkcji Replace
Liczby losowe Jeśli twoja strona ASP ma przenosić cię do królestwa gier, będziesz potrzebował liczb losowych. Czasami liczby losowe wykorzystuje się przy tworzeniu tożsamości. Dwie instrukcje służą do generowania liczb losowych: Randomize i Rnd. Randomize jest jedynie instrukcją uruchamiającą generator liczb losowych; Rnd generuje liczbę losową z zakresu od 0 do 1, niezbyt przydatną. Możesz jednak używać jej w wyrażeniach algebraicznych do wygenerowania liczb losowych należących do określonego zakresu. Wtedy formuła jest następująca: Int((Rnd * TopValue) + LowValue)
W tym wyrażeniu LowValue oznacza najmniejszą oczekiwaną liczbą, a TopValue największą dopuszczalną liczbę zakresu. Poniższy kod generuje 10 liczb losowych z zakresu od 20 do 50. <% Option Explicit Randomize Dim I For I = 1 to 10 Response.Write Int((Rnd * 30) + 20) & " " Next %>
Wyniki działania tego kodu pokazano na rysunku 4.24.
+ LowValue
reprezentuje
Rozdział 4 – Podstawy ASP
146
Rysunek 4.24. Wyniki generowania liczb losowych
Procedury Dowiedziałeś się już, jak tworzyć bloki kodu, które radzą sobie z różnego rodzaju problemami. Teraz możesz zamknąć stworzony blok w procedurze, dzięki czemu oddzielisz te części kodu, których używasz wielokrotnie w twojej stronie ASP, a następnie będziesz wywoływał je tam, gdzie są aktualnie potrzebne. Na przykład wcześniej stworzyliśmy kod zatwierdzający poprawność wprowadzonego adresu e-mail. Moglibyśmy umieścić ten kod w procedurze, a następnie wywoływać tą procedurę w miejscach, gdzie byłaby potrzebna. Istnieją dwa typy procedur: sub i function. Główna różnica pomiędzy nimi polega na tym, że function zwraca jakąś wartość, kiedy jest wywoływana, a sub tego nie robi. Weźmy przykładowy blok kodu: <% WriteMessage %> <% Sub WriteMessage() Response.Write "TheStuff" end Sub %>
Kod wywołuje procedurę typu sub o nazwie WriteMessage, która wysyła wiadomość do przeglądarki. Żadna wartość nie jest tutaj zwracana. Zwróć uwagę na strukturę procedury sub. Zaczyna się słowem Sub, po którym pojawia się nazwa, a następnie dowolne parametry. Procedura zakończona jest instrukcją End Sub. Procedura function (lub po prostu funkcja) mogłaby wyglądać następująco: <% Response.Write WriteMessage %> <% Function WriteMessage() WriteMessage = "TheStuff" End Function
ASP – Kompendium programisty
147 %>
Zauważ, że w tym przypadku wywołując WriteMessage oczekuje się jakiejś wartości, która mogłaby zostać wysłana do przeglądarki przy użyciu metody Write obiektu Response. Funkcja ma podobną strukturę do procedury sub. Rozpoczyna się kluczowym słowem Function, po którym określona zostaje nazwa funkcji. Następnie gdzieś w kodzie ustalasz zwracaną wartość funkcji poprzez umieszczenie w jakimś równaniu jej nazwy. Funkcja kończy się instrukcją End Function. Twoje procedury mogą również zawierać parametry. Przyjrzyj się poniższemu blokowi kodu, który zamienia blok zatwierdzający poprawność wprowadzonego adresu e-mail na funkcję. <% Option Explicit Dim LocalTest LocalTest = "[email protected]" Response.Write ValidateEmailAddress(LocalTest) %> <% Function ValidateEmailAddress(FieldToTest) Dim TheAt Dim TheDot If Len(FieldToTest) < 6 then ValidateEmailAddress = "Adres e-mail jest nieprawidłowy!" Else TheAt = InStr(2, FieldToTest, "@") If TheAt = 0 Then ValidateEmailAddress = "Adres e-mail jest nieprawidłowy!" Else TheDot = InStr(cint(TheAt) + 2, FieldToTest, ".") If TheDot = 0 Then ValidateEmailAddress = "Adres e-mail jest _ nieprawidłowy!" ElseIf cint(TheDot) + 1 > Len(FieldToTest) Then ValidateEmailAddress = "Adres e-mail jest _ nieprawidłowy!" Else ValidateEmailAddress = "Adres e-mail jest _ prawidłowy!" End If End If End If End Function %>
Zauważ, że teraz funkcji przekazywany jest parametr w głównym bloku kodu: Response.Write ValidateEmailAddress(LocalTest)
Ponadto zwróć uwagę na to, że funkcja wysyła wiadomość poprzez przypisanie jej nazwie zwracanej wartości.
Rozdział 5. Obiekt Request Hierarchia i modele obiektów ASP Czym są hierarchie obiektów? Aby zapewnić logiczną konsekwencję podczas programowania w środowisku Windows, Microsoft wprowadził hierarchie obiektów i inne firmy zaczęły się do tego stosować. Hierarchie ułatwiają programowanie różnych obiektów aplikacji w twoim kodzie, ponieważ muszą one być zgodne z określonym wcześniej stylem. Po pierwsze, czym są obiekty? W świecie rzeczywistym obiekty są przedmiotami takimi jak rower, biurko czy krzesło. To obiekty, rzeczy. W technice komputerowej mianem obiektów określa się na przykład arkusze kalkulacyjne, dokumenty lub koszyki. Większość z nas wie, czym jest hierarchia. Przykładem może być tutaj hierarchia w firmie, w której skład wchodzą dyrektorowie, menedżerowie, pracownicy i inni. Tak więc hierarchie obiektów są zbiorem obiektów ułożonych zgodnie z jakąś logiką. W świecie komputerów przykładem hierarchii obiektu jest zbiór obiektów Excela. Na szczycie hierarchii mamy obiekt aplikacji, którym jest sam Excel. Poniżej znajduje się skoroszyt, a jeszcze niżej w hierarchii jest arkusz roboczy. W ten sposób zbiór obiektów jest zorganizowany w porządku logicznym, lub inaczej mówiąc w hierarchii obiektów. Obiekty mają właściwości, metody, zdarzenia i zbiory. Właściwości są atrybutami opisującymi obiekt. Metody to działania podejmowane przez obiekt. Zdarzenia są zawiadomieniami, które otrzymujemy po wystąpieniu działań. Zbiory to grupy podobiektów. Jak wspomniano wcześniej, rower jest obiektem i ma swoje właściwości, metody, zdarzenia i zbiory. Właściwości to atrybuty roweru takie jak kolor, rozmiar opony, typ opon oraz wysokość siodełka. Metodami roweru będą działania z nim związane, takie jak pedałowanie, kierowanie lub malowanie roweru. Zdarzenia będą w tym wypadku informacjami o zmianach stanu: rower zatrzymał się, teraz jedzie itd. W oparciu o takie zawiadomienia możemy następnie podjąć odpowiednie działania. Zbiorami w odniesieniu do roweru są takie jego elementy jak szprychy czy szczęki hamulcowe. Wszystkie składniki zbioru są również obiektami i tak samo mogą charakteryzować się określonymi właściwościami, metodami, zdarzeniami i zbiorami. Pamiętaj, że metoda może zmienić właściwość, a zdarzenie może się ukazać, kiedy metoda zostanie wywołana lub zmieni się właściwość. Jeśli pomalujemy rower, zmienimy właściwości koloru. Arkusz w Excelu jest również obiektem i posiada swoje właściwości, metody, zdarzenia i zbiory. Arkusz charakteryzuje się kolorem tła, typem czcionki oraz domyślnie ustawioną szerokością kolumny — wszystko to są właściwości. Metody arkusza łączą w sobie kopiowanie tekstu do schowka, tworzenia pola formuły oraz generowanie wykresów w oparciu o dane arkusza. Zdarzenia w arkuszu roboczym to na przykład powiadomienia o aktywacji i dezaktywacji arkusza czy o zmianie jego zawartości. Arkusz posiada również zbiory komórek, kolumn, rzędów i komentarzy. Ponieważ każdy z tych zbiorów zawiera podzbiór obiektów, wszystkie elementy podzbioru posiadają właściwości, metody, zdarzenia i zbiory. Dostęp do właściwości, metody czy zbioru uzyskujemy dzięki składni kropki. Jeśli więc chcielibyśmy odnieść się właściwości koloru naszego roweru, kod byłby taki: If Bicycle.Color = "Czerwony" then Response.Write "Twój rower jest czerwony."
ASP – Kompendium programisty
149 End if
W drugiej linii tego przykładowego kodu używamy składni kropki do wywołania metody Write (wypisywanie tekstu) obiektu Response (odpowiedź). Tekst Twój rower jest czerwony to parametr, który jest informacją dostarczaną metodzie w celu szczegółowego określenia podejmowanego działania. Poniżej przedstawiony jest kolejny przykład użycia właściwości i metody przy wykorzystaniu składni kropki. Server.ScriptTimeOut = 90 Response.Write Request.Form("NameOfPicture") Response.BinaryWrite ThePicture
Na początku ustalamy wartość właściwości ScriptTimeOut obiektu Server, która określa w sekundach maksymalny czas, w którym skrypt musi zakończyć swe działanie. Następnie wykorzystujemy zbiór Form, który jest zespołem pól obecnych na wywoływanej stronie. Wartość dla pozycji NameOfPicture w zbiorze Form jest przekazywana jako parametr do metody Write obiektu Response, który zwraca tekst do przeglądarki odwiedzającego stronę. W następnej kolejności wywołujemy metodę BinaryWrite obiektu Response i przekazujemy jej parametr o nazwie ThePicture. Metoda BinaryWrite pozwala nam wysyłać do przeglądarki dane nietekstowe, na przykład obrazki. Ponownie więc obiekt posiada właściwości, metody i zbiory, które możemy wywołać i którymi możemy operować przy użyciu składni kropki. Do zdarzeń nie odnosimy się tak bezpośrednio jak do właściwości, metod i zbiorów. Piszemy cały kod dla zdarzenia, który zostanie uruchomiony podczas jego wystąpienia. Na przykład jeśli chciałbyś uruchomić kod zapamiętujący czas odwiedzenia naszej witryny WWW przez gościa, moglibyśmy użyć zdarzenia Session_OnStart. Zostało ono omówione bardziej szczegółowo w rozdziale 8., teraz pamiętaj jedynie o tym, że za każdym razem, kiedy gość odwiedza witrynę i uruchamia stronę ASP, każdy kod objęty zdarzeniem Session_OnStart będzie wykonany. Aby zapamiętać czas odwiedzin witryny, należy stworzyć następujący kod: Sub Session_OnStart Session("StartTime") = Now End Sub
Hierarchie obiektów są ich zgrupowaniem w porządku logicznym. Strony ASP mają bogatą kolekcję obiektów z licznymi właściwościami, metodami, zbiorami i zdarzeniami, które zostaną omówione zarówno w tym rozdziale, jak i w pozostałych częściach książki.
Model obiektów ASP Model obiektów ASP definiuje pięć głównych obiektów: Request, Response, Application, Server i Session. Obiekty te zostały omówione poniżej, a ich streszczenie zawiera tabela 5.1. Tabela 5.1. Podsumowanie modelu obiektów ASP. Obiekt Przeznaczenie Request Odbiera informacje od odwiedzających stronę. Response Metody i właściwości do tworzenia odpowiedzi wysyłanej odwiedzającemu stronę. Application Zajmuje się właściwościami, które zarządzają grupowaniem stron WWW w tak zwane aplikacje. Session Metody i właściwości odnoszące się do poszczególnych gości strony. Server Zajmuje się tworzeniem składników i ustawień serwera.
Rozdział 5 – Obiekt Request
150
Bezpośrednio przez HTML możemy wysyłać dane do serwera w formie dwóch metod: Post i Get. Uzyskiwanie informacji leży w gestii obiektu Request, który umożliwia nam grupowanie właściwości w zbiory, co pozwala odbierać przesyłane informacje. Na przykład, jeśli mamy formularz HTML na naszym serwerze, który zawiera pole Login, moglibyśmy otrzymywać daną logowania poprzez następujący kod: Response.Write "Cześć, witamy:" & Request.Form("Login")
Przy użyciu obiektu Request, możemy również otrzymać informacje o przeglądarce odwiedzającego stronę w następujący sposób: Request.ServerVariables("REMOTE_HOST")
Ta metoda zwraca nazwę internetową lub adres IP komputera odwiedzającego. Obiekt Request jest omówiony w tym rozdziale. Obiekt Response, jak to już mogliśmy zaobserwować, jest używany do wysyłania informacji do przeglądarki gościa. Na przykład użytkownicy korzystać ze strony opatrzonej formularzem quizu, będącej częścią naszej witryny. Użytkownicy wybierają odpowiedź na pytanie, która znajduje się na rozwijanej liście opcji. Lista opcji nosi nazwę Odpowiedź. Kiedy goście wybiorą już swoją odpowiedź naciskają przycisk Prześlij (Submit).To działanie pociąga za sobą wysłanie odpowiedzi do naszej strony .asp, która zareaguje na ten wybór wykonaniem poniższego kodu: If Request.Form("Answer") = "42" then Response.Write "Właściwa Odpowiedź!" Else Response.Write "Błąd! Spróbuj ponownie..." End If
Ponownie więc wyświetlamy dynamiczną zawartość, bazując przy tym na dokonanym przez użytkownika wyborze. Możemy również ustawić inne właściwości przeglądarki, które określają sposób wyświetlania odpowiedzi. Obiekt Response omówiono w rozdziale 6. Kiedy grupujemy strony ASP, które są połączone w zbiór, tworzymy w ten sposób aplikację ASP. Jeśli przykładowo dysponujemy zbiorem stron, które realizują dodawanie, edytowanie, kasowanie i przeglądanie kontaktów naszej firmy, możemy zgrupować je ze sobą w jedną aplikację ASP. Obiekt Application łączy w sobie właściwości dla tego poziomu. Posiadamy również możliwość tworzenia kodów lub procedur zdarzeń, które uruchamiane są wtedy, gdy ktoś przegląda strony aplikacji po raz pierwszy, co pozwala na inicjację zmiennych; kod jest uruchamiany również wtedy, gdy aplikacja kończy swe działanie. Goście witryny mogą odwiedzić więcej niż jedną stronę. Mogą na przykład przeglądnąć twój katalog, wyszukać określoną pozycję, przejrzeć informacje o sprzedaży, zamówić parę rzeczy, a następnie zweryfikować zamówienie. Przechodzenie gościa przez kolejne strony nosi nazwę sesji. Obiekt Session zawiera metody i właściwości pozwalające na stwierdzenie, kim jest odwiedzający. Ponieważ strony ASP są jednostkami oddzielnymi, potrzebujemy sposobu na ich powiązanie. Nie chcielibyśmy, aby gość musiał logować się na każdej stronie witryny z osobna, więc musimy zachować pewien porządek — korzystamy wtedy z obiektu Session. Na przykład w większości naszych stron sklepowych ecommerce będziemy wymagali od użytkowników zalogowania się przed dokonaniem jakichkolwiek zakupów. Pozwoli to na dostosowanie wyglądu strony do typu produktu, którego najczęściej poszukują. Dlatego najpierw uruchomimy poniższy kod, zanim jakakolwiek zawartość pojawi się na naszych stronach: If IsEmpty(Session("UserName")) then Response.Redirect "http://www.whatever.com/login.asp" Else 'pokaż zwykła stronę End If
ASP – Kompendium programisty
151
W pierwszym wierszu kodu sprawdzamy, czy użytkownik się zalogował. Jeśli nie, właściwość UserName obiektu Session nie będzie miała żadnej zawartości. Jeśli tak będzie, wysyłamy użytkownika na stronę logowania. Obiekty Application i Session omówiono w rozdziale 8. Głównym przeznaczeniem obiektu Server jest umożliwianie połączeń z innymi składnikami, które stworzyliśmy lub zainstalowaliśmy w naszym systemie. Na przykład jednym ze składników serwera IIS są obiekty danych współpracujących (CDO — Collaborative Data Objects). Wysyłając e-mail przy użyciu obiektów CDO ze strony ASP, potrzebujemy kilku wierszy kodu: Set TheMail = Server.CreateObject("CDONTS.NewMail") TheMail.Send "[email protected]", "[email protected]", "Co jest?",
"Tekst wiadomości..."
Set TheMail = Nothing
Tutaj używamy metody CreateObject obiektu Server w celu wykorzystania składnika CDO. Ponieważ składnik CDO podlega standardowemu modelowi obiektów, który omawialiśmy, korzystamy ze składni kropki, aby wysłać e-mail przy użyciu metody Send. Metoda ta ma cztery parametry, oddzielone od siebie przecinkami. Pierwszy z nich jest adresem wysyłającego, drugi adresem docelowym, trzeci to temat wiadomości, czwarty natomiast to jej treść. Obiekt Server omówiono w rozdziale 7.
Odbieranie informacji od odwiedzającego W tym podrozdziale omówimy obiekt Request. Jak wspomniano wcześniej, obiekt ten służy odbieraniu informacji od gościa, który uzyskuje dostęp do twojej strony ASP. Kiedy goście wypełnią pola formularza, który stworzyłeś, zazwyczaj naciskają przycisk Prześlij (Submit). Te dane są przesyłane do serwera, a później są dla ciebie dostępne poprzez obiekt Request. Przez ten obiekt możesz otrzymać również znacznik cookie od użytkownika. Obiekt Request może dostarczyć ci również informacji nagłówka, jak również certyfikaty bezpieczeństwa klienta.
Zbiory obiektu Request Obiekt Request zawiera pięć zbiorów, które zostały omówione poniżej, a których krótki opis zawarty jest w tabeli 5.2. Tabela 5.2. Zbiory obiektu Request. Zbiór Przeznaczenie Form Pola przesyłane z formularza poprzez metodę Post. QueryString Pola przesyłane z formularza poprzez metodę Get. ServerVariables Pola nagłówka dostępne w chwili, kiedy strona jest wywoływana przez przeglądarkę odwiedzającego. Cookies Odbiera cookie od odwiedzającego. ClientCertificate Odbiera pola certyfikatu klienta od przeglądarki odwiedzającego. Zbiór Form Większość witryn WWW posiada formularze. Jeśli chcesz dodać gości do listy pocztowej, przedstawiasz im formularz, w który wpisują swój adres poczty elektronicznej. Jeśli masz witrynę e-commerce, będziesz potrzebował formularza odbierającego informacje o fakturach i wysyłce; być może masz witrynę zawierającą ankietę na temat aktualnych wydarzeń, zbierającą opinie gości poprzez formularz. Odwiedzający następnie przekazują informacje do formularza poprzez kliknięcie przycisku, grafiki lub po prostu klawisza Enter. Dane wpisane przez gości w polach formularza są przesyłane do strony określonej w znaczniku Form. Na przykład:
Formularz korzysta z metody Post, więc pola dostępne są poprzez zbiór Form. Formularz jest wysyłany do strony processform.asp, jak to zostało określone w parametrze Action znacznika Form. Na stronie processform.asp możemy odnieść się do dowolnego elementu formularza, który został przesłany poprzez zbiór Form. Jeśli więc będziemy chcieli uzyskać dostęp do pola Name, kod byłby następujący: TheName = Request.Form("Name")
Zmienna TheName niesie w sobie zawartość, którą użytkownik wprowadził w pole tekstowe, tak więc w celu odniesienia się do pola w zbiorze Form określamy jego nazwę, a zwracana jest wartość tego pola. W podobny sposób uzyskalibyśmy dostęp do pola EmailAddress: SendToAddress = Request.Form("EmailAddress")
Możesz wykorzystać tą samą procedurę, aby uzyskać dostęp do ukrytych pól. Nawet przycisk jest częścią formularza i jest przesyłany wraz z nim. Tak więc poniższy kod: ButtonValue = Request.Form("SubmitButton")
zapamięta wartość "OK" w zmiennej ButtonValue. Zauważ, że pole wyboru o nazwie Zainteresowania pozwala odwiedzającemu na wybranie więcej niż jednej wartości, ponieważ w znaczniku znajduje się słowo kluczowe Multiple. Wartości dostarczane są w postaci listy oddzielonej przecinkami. Jeśli więc nasza strona processform.asp zawierałaby taki kod: response.write request.form("Interests")
a odwiedzający wybrałby Sport, przeglądarka wyświetliłaby: Sport
Jeśli odwiedzający zaznaczyłby Sport i Nowości, w przeglądarce ukazałby się ten tekst: Sport, Nowości
Kiedy pole formularza zawiera wiele wartości, tak jak w tym przypadku, możesz zaznaczyć każdą pozycję indywidualnie, tak więc w polu może się znaleźć zbiór zaznaczeń. Liczbę zaznaczeń możesz poznać przy użyciu właściwości Count. Wyjściem tego kodu: response.write request.form("Interests").count
Rozdział 5 – Obiekt Request
154
byłaby liczba 2, ponieważ dokonano dwóch zaznaczeń. Możemy odnieść się do każdego elementu w tablicy zaznaczeń w następujący sposób: response.write request.form("Interests")(1) & "
" response.write request.form("Interests")(2)
Tym razem wyjściowa wartość dla przeglądarki byłaby taka: Sport Nowości
Jeśli odwiedzający dokonał tylko jednego zaznaczenia, drugi wiersz ostatniego kodu wywołałby stan błędu, najlepiej więc używać właściwości Count podczas odnoszenia się do dowolnej zaznaczonej pozycji. Możemy również odnieść się do dowolnej pozycji zbioru poprzez użycie bloku For Each: For Each TheStuff in Request.Form("Interests") 'insert code that would process each item response.write TheStuff & " " Next
Blok For Each przechodzi kolejno przez każdą pozycję zbioru. Zmiennej TheStuff przypisywana jest wartość dowolnego elementu zbioru Zainteresowania. Jeśli więc odwiedzający wybierze Sport i Nowości, to podczas pierwszego przejścia przez blok kodu do zmiennej TheStuff zostanie wpisany ciąg Sport, a za następnym przejściem — Nowości. Po dwóch iteracjach skończą się pozycje w zbiorze i kod bloku nie będzie już wykonywany. Zbiór QueryString Jak wspomniano wcześniej, podczas przesyłania pól formularza korzystamy z metody Get lub Post. Poprzedni podrozdział ukazywał metodę Post, która była wykorzystywana przez zbiór Form. W tej części zwrócimy uwagę na zbiór QueryString, który używa metody Get. Wcześniej również mogłeś używać metody Get, ale w formularzach ogólnie rzecz biorąc używa się metody Post, aby nie martwić się o ograniczenia dotyczące długości ciągów. Zbiór QueryString jest tak naprawdę używany wtedy, gdy musisz przekazać parametry poprzez łącze. Przypuśćmy, że masz stronę, która pokazuje listę sprzedanych produktów. Kiedy goście klikną dany produkt, powinni ujrzeć szczegóły z nim związane. Mógłbyś mieć setki stron wyświetlających każdy produkt lub tylko jedną stronę ASP wyświetlającą dowolny z nich. Wymagałoby to zastosowania numeru identyfikacyjnego produktów (ProductID) i odwołań do bazy danych, w której umieszczone byłyby szczegóły. Aby przekazywać ProductID do strony poprzez łącze, mógłbyś korzystać ze zbioru QueryString. Mógłbyś wyświetlać nazwę produktu jako łącze do strony ze szczegółami za pomocą następującego kodu: Pasta
Gość, który kliknął słowo Pasta zostaje połączony ze stroną productdetails.asp. Numer identyfikacyjny pasty do zębów (2355) jest wysyłany do tej strony. Zwróć uwagę na strukturę łącza. Po rozszerzeniu .asp następuje znak zapytania oznaczający, że teraz pojawi się parametr. Każdy parametr jest parą nazwa-wartość. Jeśli przekazywany jest więcej niż jeden parametr, każdy kolejny oddzielony jest od siebie ampersandem (&). Jeśli więc kolejnym naszym parametrem będzie typ klienta (CustomerType), łącze będzie wyglądało następująco: http://www.somewhere.com/productdetails.asp?ProductID=2355& CustomerType=Normal
ASP – Kompendium programisty
155
Kod strony productdetails.asp jest odpowiedzialny za wykorzystanie przekazanego numeru ProductID w celu określenia, który produkt powinien być wyświetlony. Aby wyszukać ProductID, wykorzystany zostanie zbiór QueryString: TheStuff = Request.QueryString("NameOfField")
Pole NameOfField zawiera wartość, którą chcesz przypisać zmiennej TheStuff. W stronie productdetails.asp wykorzystuje się numer ProductID w następujący sposób: <% Option Explicit Dim conn Dim RSProduct set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" set RSProduct = conn.Execute("select * from Products where " _ & "ProductID = " & Request.QueryString("ProductID")) %>
Kod łącząc się z bazą danych, wykorzystuje ADO (omówimy ADO w rozdziale 14.). Zauważ jednak, że QueryString jest wykorzystywany do wyszukiwania określonego numeru ProductID, który z kolei jest używany przez instrukcję SQL do znalezienia w bazie danych rekordu zawierającego informacje o odpowiednim produkcie. Jeśli przesyłasz formularz przy użyciu metody Get, możesz użyć zbioru QueryString w celu wyszukania wartości przesłanych formularzy. Te same zasady, które obowiązywały dla zbioru Form, obowiązują również dla tego zbioru. Po prostu używasz nazwy pola formularza, aby uzyskać wartość przesłaną: TheName = Request.QueryString("Name")
Jeśli pole zawiera wiele wartości jak pole wyboru, możesz odnieść się do wybranego elementu określając jego numer: response.write request.querystring("Interests")(2)
Możemy również odnieść się do każdej pozycji zbioru QueryString w podobny sposób. Jeśli więc użyjemy metody Get dla znacznika Form, formularz będzie wyglądał tak, jak to prezentuje rysunek 5.2.
Rozdział 5 – Obiekt Request
Rysunek 5.2. Przykład formularza używającego metody Get Moglibyśmy stworzyć w naszej stronie productdetails.asp kod przechodzący kolejno przez każde pole formularza: For Each TheStuff in Request.QueryString Response.Write TheStuff & ": " & Request.QueryString(TheStuff) & "
" Next
Wynik wykonania tego kodu prezentuje rysunek 5.3.
Rysunek 5.3. Wynik przetworzenia strony
156
ASP – Kompendium programisty
157
Zwróć uwagę na parę rzeczy na stronie wyjściowej. Spójrz na adres strony. Ponieważ użyto metody Get, pola formularza są częścią łącza. Ponadto znajduje się tam również przycisk przesyłania, ponieważ jest on częścią formularza HTML. Możesz to wykorzystać w celu umożliwienia twoim gościom dokonania wyboru rodzaju działania przy pomocy większej ilości przycisków. Jedynie ten przycisk, który jest naciśnięty, jest przekazywany. W bloku kodu wykorzystujemy instrukcję For Each, aby przejść kolejno przez zbiór QueryString. Zmiennej TheStuff przypisywane są wszystkie elementy formularza po kolei w czasie przechodzenia kodu przez strukturę pętli For Each. Zmienna TheStuff zawiera w rzeczywistości nazwę pola, dlatego jest używana do wyszukania poprawnej wartości określonego pola. Zbiór ServerVariables Zbiór ServerVariables wyszukuje liczne nagłówki pól oraz zmienne środowiskowe. Możesz na przykład użyć zbioru ServerVariables do wyszukania typu przesłania formularza, nazwy ostatnio przeglądanej strony, ścieżki do aktualnej strony, adresu IP gościa lub typu serwera internetowego. Wyszukanie jednej z tych pozycji w zbiorze ServerVariables jest proste — określ po prostu nazwę zmiennej serwera, którą chcesz otrzymać. Jeśli na przykład chciałbyś poznać ścieżkę do bieżącej strony, kod byłby taki: ThePath = Request.ServerVariables("PATH_INFO")
A poniższy kod wyświetla w przeglądarce nazwę strony poprzednio przeglądanej: Response.Write Request.ServerVariables("HTTP_REFERER")
Niektóre pola nagłówków i zmienne środowiskowe powinne być dostępne przez cały czas. Wyszczególniono je w tabeli 5.3. Pozostałe zmienne serwera, które nie są osiągalne przez cały czas, ale mogą mieć duże znaczenie, pokazuje tabela 5.4. Tabela 5.3. Standardowe zmienne serwera. Zmienna serwera Przeznaczenie ALL_HTTP Zawiera pełną listę niestandardowych nagłówków w formie HTTP_NAME: wartość. ALL_RAW Podobna do ALL_HTTP z tą różnicą, że nagłówki są ukazywane dokładnie tak, jak są odbierane, bez przedrostka HTTP i innego formatowania. APPL_MD_PATH Zawiera logiczną ścieżkę do metabazy. APPL_PHYSICAL_PATH Zawiera fizyczną ścieżkę do metabazy. AUTH_PASSWORD Hasło wprowadzone podczas używania podstawowego uwierzytelniania. AUTH_TYPE Typ używanego uwierzytelniania, przeprowadzanego w celach bezpieczeństwa. AUTH_USER Nazwa uwierzytelnianego użytkownika. CERT_COOKIE Ciąg zawierający unikalny identyfikator certyfikatu klienta. CERT_FLAG Pierwsza flaga jest ustawiana, kiedy obecny jest certyfikat klienta. Druga flaga jest ustawiana, jeśli Wydawca Certyfikatu zostaje uznany za wiarogodne źródło. CERT_ISSUER Wydawca certyfikatu klienta. CERT_KEYSIZE Liczba bitów klucza bezpieczeństwa SSL. CERT_SECRETKEYSIZE Liczba bitów klucza bezpieczeństwa SSL dla serwera. CERT_SERIALNUMBER Numer seryjny certyfikatu klienta. CERT_SERVER_ISSUER Wydawca Certyfikatu serwera. CERT_SERVER_SUBJECT Pole tematu certyfikatu serwera. CERT_SUBJECT Pole tematu certyfikatu klienta.
Liczba bitów zgłaszanych przez klienta serwerowi wraz z żądaniem. Typ żądania. Wersja CGI w formie numeru CGI. Zawiera ciąg on, gdy żądanie jest bezpieczne, jeśli nie — ciąg off. Liczba bitów SSL używanych przy żądaniu. Liczba bitów używana na serwerze. Wydawca certyfikatu dla serwera. Pole tematu certyfikatu serwera. Numer identyfikacyjny egzemplarza serwera WWW. Ścieżka do metabazy dla tego określonego egzemplarza. Adres IP serwera. Jeśli użytkownik jest zalogowany w systemie NT, to pole zawiera nazwę tego użytkownika. Ścieżka dostępu do żądanej strony poza katalogiem macierzystym nazwy domeny. Fizyczna ścieżka żądania. Dowolna dana przekazana metodą Get lub występująca po znaku zapytania w łączu. Adres IP komputera, który wystosował żądanie. Tłumaczona nazwa komputera wystosowującego żądanie, jeśli takowa istnieje. Jeśli nie, pole zawiera adres IP. Nazwa użytkownika, jeśli takowa została wysłana przez gościa. Wykorzystana metoda żądania, Post lub Get. Położenie pliku wirtualnego wywoływanego skryptu. Nazwa serwera. Port używany podczas żądania. Jeśli żądanie było wystosowane przez bezpieczne połączenie, pole to będzie zawierało wartość 1; jeśli nie, wartością będzie 0. Używany protokół z numerem wersji, to znaczy HTTP/1.1. Nazwa i wersja oprogramowania uruchamianego przez serwer. Ścieżka do wywoływanej strony.
Tabela 5.4. Niestandardowe zmienne serwera. Zmienna serwera Przeznaczenie HTTP_CONNECTION Typ połączenia pomiędzy klientem a serwerem. HTTP_REFERER Strona, którą gość odwiedzał bezpośrednio przed bieżącą stroną, jeśli przejścia dokonano poprzez łącze. HTTP_USER_AGENT Typ przeglądarki i jej wersja wraz z systemem operacyjnym gościa. Aby przejrzeć wartości wszystkich zmiennych serwera i dostępnych typów, mógłbyś umieścić w stronie ASP następujący kod: For Each TheStuff in Request.ServerVariables Response.Write TheStuff & ": " _ & Request.ServerVariables(TheStuff) & "
" Next
ASP – Kompendium programisty
159
Kod ten wyszczególni listę wszystkich zmiennych serwera wraz z ich wartościami w następującej formie: Zmienna serwera: Wartość
Zbiór Cookies Znaczniki cookie są wykorzystywane do zapamiętywania informacji na komputerze odwiedzającego. Możesz użyć swojego kodu do odzyskania wartości zapisanych na komputerze gościa. Mógłbyś na przykład zapamiętać nazwę użytkownika odwiedzającego w znaczniku cookie. Gdyby goście odwiedzili twoją witrynę ponownie, wiedziałbyś kim byli. W znaczniku cookie możesz również zapamiętać preferencje gościa, takie jak ulubione typy produktów lub ich położenie. Ponieważ jednak dane przechowywane są w systemie gościa, nie możesz używać jedynie cookie do identyfikacji odwiedzającego. Problem polega na tym, że użytkownicy mogą usunąć cookies ze swojego komputera; mogą mieć również zainstalowany program usuwający cookies; mogą również odwiedzać twoją witrynę korzystając z komputera innego niż ich własny, wtedy cookie znajduje się gdzie indziej. Znaczniki możesz odebrać poprzez zbiór Cookies. Jeśli zapamiętałeś cookie o nazwie UserName na komputerze gościa, odzyskasz ten znacznik w następujący sposób: TheValue = request.cookies("UserName")
Zmienna TheValue będzie zawierała wartość cookie o nazwie UserName. Jeśli takowe nie istnieje, zmienna TheValue pozostanie pusta. Cookies mogą być również złożone. Jeden znacznik może zawierać więcej niż jedna wartość. Jeśli więc chciałbyś odczytać nazwę gościa oraz ulubioną kategorię produktów, podczas gdy obie te wartości znajdowałyby się w tym samym cookie o nazwie Preferences, kod byłby następujący: TheValue = Request.Cookies("Preferences")("UserName") FavCategory = Request.Cookies("Preferences")("FavCategory")
Możesz sprawdzić, czy znacznik cookie jest prosty, czy złożony poprzez właściwość znacznika zwaną HasKeys. Jeśli cookie jest złożony, zawiera więcej niż jedną wartość. W tym przypadku wartością właściwości HasKeys jest prawda. Jeśli znacznik cookie jest prosty, wartość HasKeys to fałsz. Odwołanie do właściwości wygląda tak: If Request.Cookies("Preferences").HasKeys then Response.Write "Złożony cookie" Else Response.Write "Prosty cookie" End if
W poniższym kodzie wyświetlamy zawartość dwóch cookies: jednego prostego, drugiego złożonego. Wyświetlana jest również zawartość właściwości HasKeys: response.write "Simple Cookie: " _ & request.cookies("SampleCookie1") & "
Rysunek 5.4. Wynik przykładowego kodu ze znacznikami cookie Zbiór ClientCertificate Coraz bardziej rośnie zapotrzebowanie na pozytywną identyfikację gości, w szczególności jeśli chodzi o obszar e-commerce. Jednym ze sposobów identyfikacji są certyfikaty klienta. Użytkownicy mogą kupić certyfikat klienta od organizacji określanej mianem Wydawcy Certyfikatu (CA — Certificate Authority), która jest firmą wydającą certyfikaty dla indywidualnych osób. Certyfikat jest zwykle związany z adresem poczty elektronicznej i hasłem. Normalnie podczas pracy z certyfikatem decydujesz, jakim organizacjom CA ufasz. Przez zaufanie do CA rozumiemy akceptację certyfikatów przez nią wydanych. Dwie najsłynniejsze organizacje wydającego certyfikaty to Thawte (http://www.thawte.com) i Verisign (http://www.verisign.com). Zbioru ClientCertificate obiektu Request używasz do kwestionowania wartości certyfikatu gościa. Powiedzmy, że chciałbyś poznać datę wygaśnięcia ważności certyfikatu. Kod byłby taki: ExpDate = Request.ClientCertificate("ValidUntil")
Niektóre obiekty zbioru ClientCertificate zawierają klucze podrzędne. Na przykład jednym z elementów zbioru jest wydawca certyfikatu, organizacja CA. Jeśli chciałbyś poznać określoną nazwę CA, kod wyglądałby tak: CAName = Request.ClientCertificate("Issuer0")
Poniższy kod przechodzi kolejno przez wartości zbioru ClientCertificate: For Each CCValue in Request.ClientCertificate Response.Write CCValue & ": " & Request.ClientCertificate(CCValue) & "
" Next
ASP – Kompendium programisty
161 Bardziej czytelne wyjście tego kodu zaprezentowano na rysunku 5.5.
Rysunek 5.5. Wyjście strony ClientCertificate W dalszej części tego rozdziału przyjrzymy się przykładowi praktycznego wykorzystania zbioru ClientCertificate, a także krokom jakie należy podjąć, aby wyszukiwać certyfikaty oraz żądać dostępu do nich poprzez serwer IIS.
Właściwość obiektu Request Obiekt Request ma tylko jedną właściwość, którą omówiono poniżej i podsumowano w tabeli 5.5. Tabela 5.5. Właściwość TotalBytes
Przeznaczenie Liczba bajtów wysłanych podczas wywoływania strony.
Właściwość TotalBytes Właściwość TotalBytes zawiera liczbę bajtów w parametrze wywołania strony ASP. Jeśli masz stronę z następującym formularzem:
i gość wpisał Dave w pole Name, zostawił puste pole adresu e-mail oraz zaznaczył News w polu Interests, to poniższy kod zwróci wartość 54: Response.Write Request.TotalBytes
Liczba 54 jest ilością bajtów lub znaków w żądaniu, która jest sumą znaków pól przesłanych i nazw pól formularza: Nazwa pola: Name = 4 bajty Nazwa pola: EmailAddress = 12 Nazwa pola: Interests = 9 Nazwa pola: Submit Button = 12 Dana wprowadzona: Dave = 4 Dana wprowadzona: Email (NA) = 0 Dana wprowadzona: News = 4 Dana wprowadzona: OK. (Submit Button) = 2 Ampersandy: 3 Znaki równości = 4 Ogólnie = 54
Jeśli używałeś metody Get przy przesyłaniu formularza, właściwość TotalBytes zwróci wartość 0. Właściwość ta dostępna jest jedynie podczas przesyłania formularza przy użyciu metody Post.
Metoda obiektu Request Obiekt Request ma tylko jedną metodę, którą omówiono poniżej i podsumowano w tabeli 5.6. Tabela 5.6. Właściwość BinaryRead
Przeznaczenie Zwraca nieprzetworzoną daną przesłaną poprzez formularz.
Metoda BinaryRead Metoda BinaryRead zwraca daną przekazaną poprzez formularz w niskopoziomowej, nieprzetworzonej formie. Bajty zwracane są w takiej postaci, w jakiej zostały przesłane bez przetworzenia ich przy użyciu zbioru Form. Metoda przybiera następującą formę: TheStuff = Request.BinaryRead(NumberOfBytesToRetrieve)
NumberOfBytesToRetrieve reprezentuje liczbę bajtów, którą chcesz wydobyć z danej przesłanej. TheStuff jest tablicą tych bajtów. Po wywołaniu NumberOfBytesToRetrieve zawiera liczbę bajtów, które zostały odebrane. Jeśli chcesz odebrać wszystkie przesłane bajty, kod byłby taki: TheStuff = Request.BinaryRead(Request.TotalBytes)
163
ASP – Kompendium programisty
Prawie zawsze o wiele łatwiej jest pracować z danymi przesłanymi poprzez formularz używając zbioru Form. Ta metoda odbierania danych przesłanych jest naprawdę odpowiednia tylko wtedy, gdy istnieje niskopoziomowego dostępu do przesłania formularza, któremu towarzyszy plik binarny.
Obiekt Request w działaniu W tym podrozdziale zwrócimy uwagę na liczne przykłady stron i rozwiązań wykorzystujących obiekt Request. Po pierwsze poznamy kroki, jakie należy podjąć, aby używać certyfikatów klienta. W odpowiednim przykładzie zobaczysz, jak skonfigurować serwer IIS do odbierania certyfikatów klienta oraz w jaki sposób klient może taki certyfikat otrzymać. Następnie przyjrzymy się programowi usługowemu, który przesyła pocztą elektroniczną zawartość formularza osobom wyszczególnionym w tym formularzu. Podobna strona ASP jest wykorzystywana do zapamiętywania danych w tabeli bazy danych. Zwrócimy również uwagę na przykład formularza logowania gości na witrynie. Formularz ten będzie wykorzystywał cookies w celu rozpoznania użytkowników. Użytkownikom nie rozpoznanym lub nie posiadającym odpowiedniego cookie będzie umożliwiał logowanie się.
Przykład certyfikatu klienta Jednym ze sposobów identyfikacji użytkowników twojej witryny są certyfikaty klienta, które informują cię o tym, czy osoby odwiedzające witrynę są faktycznie tymi, za które się podają. Użytkownicy otrzymują certyfikat od Wydawcy Certyfikatu. Ponieważ każdy może być wydawcą, ty sam decydujesz, któremu z nich chcesz zaufać. W ten sposób Wydawca Certyfikatu pełni rolę pośrednika pomiędzy tobą a gośćmi twojej witryny. Aby skonfigurować stronę jako używającą certyfikatów klienta, musisz skorzystać z Konsoli Zarządzania Microsoftu serwera IIS. Wyszukaj stronę, którą chcesz zabezpieczyć certyfikatami klienta i kliknij ją prawym przyciskiem myszy; następnie wybierz Właściwości (Properties). Powinieneś zobaczyć dialog pokazany na rysunku 5.6.
Rysunek 5.6. Dialog Właściwości pliku serwera IIS Przejdź do zakładki Bezpieczeństwo pliku (File Security) i naciśnij przycisk Edytuj (Edit) w części Zabezpieczenie komunikacji (Secure Communications). Powinieneś ujrzeć dialog z rysunku 5.7.
Rozdział 5 – Obiekt Request
164
Rysunek 5.7. Dialog Zabezpieczenie komunikacji Aby zabezpieczyć kanał podczas dostępu do strony musisz zaznaczyć kratkę Wymagaj bezpiecznego kanału podczas dostępu do zasobu (Require Secure Channel when accessing this resource). Kiedy to zrobisz, w następnej kolejności możesz zaznaczyć opcję Wymagaj certyfikatu klienta (Require Client Certificate). Możesz również użyć certyfikatów klienta w celu mapowania dostępu użytkowników do określonych kont NT. Realizujesz to przez zaznaczenie kratki Uaktywnij mapowanie certyfikatu klienta (Enable Client Certificate Mapping) i naciskając przycisk Edytuj (Edit). Kiedy to zrobisz, zobaczysz dialog pokazany na rysunku 5.8.
Rysunek 5.8. Dialog Mapowanie kont, zakładka Podstawowe W zakładce Podstawowe (Basic) możesz przydzielić określony certyfikat klienta do określonego konta klikając przycisk Dodaj (Add). Większe możliwości prezentuje zakładka Zaawansowane (Advanced), która pozwala na użycie wieloznaczników do mapowania dostępu grup osób do określonych kont NT. Mógłbyś na przykład mapować dostęp do określonego konta każdej osoby z certyfikatem pochodzącym od jednego wydawcy; mógłbyś również mapować opierając się na organizacji związanej z właścicielem certyfikatu. Aby przydzielić wiele certyfikatów do jednego konta NT, kliknij przycisk Dodaj (Add) w zakładce Zaawansowane (Advanced). Wyświetli się pierwsze okno kreatora, pokazane na rysunku 5.9.
165
ASP – Kompendium programisty
Rysunek 5.9. Dodawanie mapowania zaawansowanego, krok pierwszy Po pierwsze, wpisujesz jakąś nazwę dla twojej reguły, która służy jedynie temu, abyś rozpoznawał ta regułę. W pierwszym filtrowaniu określasz, czy chcesz mapować wszystkich Wydawców Certyfikatu, czy tylko wybranych. Aby ograniczyć ich liczbę, naciśnij przycisk Wybierz (Select), a wtedy zobaczysz listę wydawców. Po wybraniu opcji Wydawcy (Issuers), naciśnij przycisk Dalej (Next), a zobaczysz dialog pokazany na rysunku 5.10.
Rysunek 5.10. Reguły mapowania W dialogu reguł możesz dodawać, edytować oraz usuwać określone reguły filtrowania dla tego mapowania. Naciskając przycisk Nowy (New), wyświetlisz okno pokazane na rysunku 5.11., w którym stworzysz regułę w oparciu o testowane pola i kryteria, które muszą one spełniać. Reguła na rysunku 5.11. wyszukuje te firmy, których nazwa rozpoczyna się od liter ABC w podrzędnym kluczu Organizacja (Organization) klucza Temat (Subject). Naciśnij OK w celu potwierdzenia reguły, a następnie kliknij przycisk Dalej (Next). Ukaże się wtedy trzecie okno kreatora, pokazane na rysunku 5.12.
Rysunek 5.11. Przykładowa reguła
Rozdział 5 – Obiekt Request
166
Rysunek 5.12. Przydzielanie reguły do określonego konta W kroku trzecim wybierasz konto, które chcesz mapować zgodnie z odpowiednią regułą lub określasz, którym certyfikatom odmówić dostępu. Naciśnij następnie przycisk Zakończ (Finish), a konfiguracja twojego zaawansowanego mapowania zostanie zakończona. Drugą stroną zapewnienia bezpieczeństwa jest otrzymanie przez gościa certyfikatu klienta. Wymaga to od użytkownika wejścia na którąś z witryn WWW Wydawców Certyfikatu, na przykład Verisign lub Thawte, gdzie generalnie mogą skorzystać z kreatorów certyfikatu klienta, różniących się między sobą w zależności od witryny. Większość znaczących Wydawców Certyfikatu pobiera opłatę za tę usługę. Kiedy te dwie strony bezpieczeństwa zostaną zrealizowane, twoi goście mogą już odwiedzać twoją zabezpieczoną witrynę, a podawane informacje dotyczące ich tożsamości, mogą być uznane za godne zaufania. Strona zabezpieczona winna być adresowana poprzez https:// zamiast http://. Jeśli użytkownicy próbowaliby wejść na witrynę bez certyfikatu, zobaczą ostrzeżenie podobne do tego pokazanego na rysunku 5.13, pochodzące od przeglądarki Netscape Navigator. Następnie ujrzą wiadomość przeglądarki, informującą o konieczności posiadania certyfikatu klienta umożliwiającego przeglądanie strony.
Rysunek 5.13. Ostrzeżenie wyświetlane przez przeglądarkę Netscape Navigator
ASP – Kompendium programisty
167
Rysunek 5.14. Wiadomość informująca o konieczności przedstawienia certyfikatu Goście posiadający certyfikat otrzymają wiadomość przeglądarki, która powiadomi ich o konieczności przedstawienia certyfikatu oraz poprosi o wybranie któregoś. Ten dialog pokazano na rysunku 5.14. Następnie ujrzą zabezpieczoną stronę. Na stronie możesz użyć zbioru Request.ClientCertificate w celu zatwierdzenia dostępu gościa. Kod mógłby używać pola numeru seryjnego w celu wyszukania w twojej bazie danych informacji o tożsamości gościa. Wtedy mógłbyś wykorzystać dane zapamiętane w bazie w celu wyświetlenia widoku strony zgodnego z preferencjami twojego użytkownika. Taki kod mógłby wyglądać następująco: <% Option Explicit Dim conn Dim RSVisitor set conn = server.createobject ("adodb.connection") conn.open "DBName", "sa", "yourpassword" set RSVisitor = conn.Execute("select * from Visitors where SerialNumber = " _ & Request.ClientCertificate("SerialNumber")) If RSVisitor.EOF Then conn.execute "insert into Visitors (SerialNumber) values " _ & Request.ClientCertificate("SerialNumber") Response.Redirect "./config.asp?User=" _ & Request.ClientCertificate("SerialNumber") & "&Type=New" Else Layout = RSVisitor("Layout") FavCat = RSVisitor("FavCat") End If %>
Kod bazy danych został omówiony bardziej szczegółowo w rozdziałach 13. i 14. Na początku kod łączy się z bazą danych: set conn = server.createobject ("adodb.connection") conn.open "DBName", "sa", "yourpassword"
Kod korzysta z numeru seryjnego pochodzącego z certyfikatu gościa w celu znalezienia jego rekordu w bazie danych: set RSVisitor = conn.Execute("select * from Visitors where SerialNumber = " _ & Request.ClientCertificate("SerialNumber"))
Rozdział 5 – Obiekt Request
168
Jeśli gościa nie ma w bazie danych, ustawiana jest następująca flaga: If RSVisitor.EOF Then
W tym przypadku jest on dodawany do bazy danych: conn.execute "insert into Visitors (SerialNumber) values " _ & Request.ClientCertificate("SerialNumber")
i jest wysyłany do kolejnej strony w celu określenia swoich preferencji: Response.Redirect "./config.asp?User=" _ & Request.ClientCertificate("SerialNumber") & "&Type=New"
W przeciwnym wypadku dane znajdujące się w bazie są wykorzystane do ustawienia aspektów wyświetlania strony: Layout = RSVisitor("Layout") FavCat = RSVisitor("FavCat")
Procesor e-mail dla formularza Jedna ze stron każdej praktycznie witryny posiada formularz informacji dodatkowych. Taka strona zazwyczaj prosi gości o podanie informacji o sobie oraz pozwala na zadanie pytania. Następnie zawartość formularza jest wysyłana do wyznaczonej osoby. Poniżej zaprezentowano przykład takiej witryny. Co ważniejsze, wykorzystuje ona kod do przetworzenia formularza. Kod jest sposobem na przedłożenie formularza i wysłanie jego zawartości pocztą elektroniczną do kogokolwiek, kto wyszczególniony został w specjalnym polu. Pierwszą stroną jest strona żądania informacji dodatkowych, pokazana na rysunku 5.15. Formularz strony może zawierać elementy o dowolnych typach i w dowolnej ilości, musi jednak zawierać dwa specjalne, ukryte elementy formularza:
ASP – Kompendium programisty
169
Rysunek 5.15. Formularz informacji dodatkowych Pole SendTo zapamiętuje adres e-mail tej osoby, do której należy wysłać zawartość formularza. Innym polem specjalnym jest CompleteMessage, które zawiera tekst ukazujący się gościowi po przesłaniu formularza. Kolejnym interesującym elementem jest przycisk typu Submit:
Pamiętaj o tym, co powiedzieliśmy wcześniej — przycisk jest wysyłany wraz ze wszystkimi innymi polami formularza. Jeśli jednak przycisk jest określany mianem SubmitButton, nie jest wysyłany z resztą pól. Będziesz mógł to stwierdzić przeglądając kod. Rysunek 5.16. pokazuje stronę, która wyświetlana jest po naciśnięciu przycisku Wyślij. Zwróć uwagę na wiadomość ukazaną na tej stronie. Jest to tekst wysłany do formularza poprzez pole CompleteMessage.
Rozdział 5 – Obiekt Request
170
Rysunek 5.16. Strona ukazująca się po przesłaniu formularza informacji dodatkowych Następnie kod wysyła e-mail do osoby wskazanej w polu SendTo. Jego tekst oparty jest na wprowadzonych wcześniej danych, a przedstawia się w ten sposób: Imię i nazwisko: Dave Smith Adres e-mail: [email protected] Telefon: 111-111-1111 Dział(3): Sprzedaż, Zatrudnienie, Zwroty Wiadomość: Przykładowa wiadomość
Zawartość formularza jest wysyłana do strony ASP, która tworzy odpowiedni e-mail. Główny blok kodu tej strony wygląda następująco: <% Option Explicit Dim TheMessage Dim TheFormField For Each TheFormField in Request.Form If TheFormField <> "SendTo" and
TheFormField <>
"CompleteMessage" _ and TheFormField <> "SubmitButton" Then If Request.Form(TheFormField).Count > 1 Then TheMessage = TheMessage & TheFormField & "(" _ & Request.Form(TheFormField).Count & "): " _ & Request.Form(TheFormField) & chr(13) else TheMessage = TheMessage & TheFormField & ": " _ & Request.Form(TheFormField) & chr(13) end if end if Next
ASP – Kompendium programisty
171 Dim ObjMail Set objMail = CreateObject("CDONTS.NewMail") objMail.Send "[email protected]", cstr(Request.Form("SendTo")), _ "New More Info Request", cstr(TheMessage) Set objMail = Nothing %>
Przypis
Powyższy kod używa kilku obiektów, których do tej pory nie omówiliśmy, a których zastosowanie było niezbędne w tym przykładzie.
Kod posiada pętlę, która przejdzie kolejno przez każde przesłane pole. W pętli do zmiennej TheFormField wpisywany jest każdy punkt zbioru Form: For Each TheFormField in Request.Form
Wysłany e-mail nie powinien zawierać treści pól specjalnych, określających adresata wiadomości, informacji wyświetlanej gościowi oraz przycisku typu Submit: If TheFormField <> "SendTo" and
TheFormField <> "CompleteMessage" _
and TheFormField <> "SubmitButton" Then
Jeśli element jest częścią pola złożonego, wskazywana jest liczba elementów: If Request.Form(TheFormField).Count > 1 Then TheMessage = TheMessage & TheFormField & "(" _ & Request.Form(TheFormField).Count & "): " _ & Request.Form(TheFormField) & chr(13)
W przeciwnym wypadku w zmiennej tekstowej wiadomości e-mail zapamiętywana jest tylko nazwa pola i jego wartość: TheMessage = TheMessage & TheFormField & ": " _ & Request.Form(TheFormField) & chr(13)
Następnie pętla kodu przechodzi do następnego pola: Next
Dalsza część kodu korzysta obiektu danych współpracujących (omówionego w rozdziale 9.) w celu wysłania wiadomości e-mail do osoby określonej w polu SendTo: Dim ObjMail Set objMail = CreateObject("CDONTS.NewMail") objMail.Send "[email protected]", cstr(Request.Form("SendTo")), _ "New More Info Request", cstr(TheMessage) Set objMail = Nothing
Rozdział 5 – Obiekt Request
172
Procesor bazy danych dla formularza Kolejnym zadaniem, często wykonywanym przy użyciu formularzy, jest zapamiętywanie przesłanych informacji w tabeli bazy danych. Obiekt Request po raz kolejny użyty jest tutaj przy przekazywaniu do formularza przetwarzającego pól ukrytych i tych wypełnianych przez odwiedzającego. Tym razem przyjrzymy się przykładowej ankiecie. Gość odwiedza naszą witrynę i wypełnia ankietę. Jej zawartość jest wpisywana w tabelę bazy danych, a do zapisywania jakichkolwiek danych formularza w bazie wykorzystujemy kod. Kod używa obiektu Request w celu wyszukania nazw pól i ich wartości, nazwy tabeli oraz wiadomości prezentowanej gościowi. Strona ankiety pokazana jest na rysunku 5.17. Może ona zawierać rozmaite pola formularza. Nazwa każdego elementu formularza musi być taka sama jak nazwa pola w tabeli docelowej, do której zostanie dodany rekord. Na przykład użycie takiego pola formularza:
wymaga zastosowania dla pola tabeli nazwy Service. Formularz HTML zawiera również następujące pola ukryte:
Rysunek 5.17. Strona ankiety Ukryte pole CompleteMessage zapamiętuje wiadomość, która będzie wyświetlana po przesłaniu formularza. Pole TableName przechowuje nazwę tabeli, w której dane mają być zapisane. Kiedy goście nacisną przycisk Wyślij, ujrzą stronę pokazaną na rysunku 5.18. Kod strony process_form.asp odbiera przesłane dane i dodaje je do bazy. Główny blok kodowy jest następujący: <% Option Explicit Dim TheFields Dim TheValues Dim TheFormField
ASP – Kompendium programisty
173 Dim TheQuery For Each TheFormField in Request.Form If TheFormField <> "TableName" and
TheFormField <> "CompleteMessage" _
and TheFormField <> "SubmitButton" Then TheFields = TheFields & TheFormField & ", " TheValues = TheValues & "'" & Request.Form(TheFormField) & "', " end if Next TheFields = left(TheFields, Len(TheFields) - 2) TheValues = left(TheValues, Len(TheValues) - 2) Dim conn set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" conn.execute "insert into " & Request.Form("TableName") _ & " (" & TheFields & ") values (" & TheValues & ")" %>
Rysunek 5.18. Strona wyświetlana po przesłaniu ankiety przez gościa Kod przechodzi kolejno przez wszystkie przesłane pola, które są dostępne poprzez zbiór Form: For Each TheFormField in Request.Form
Kod nie przetwarza poniższych pól, ponieważ nie mają one być dodane do bazy danych: If TheFormField <> "TableName" and
TheFormField <>
"CompleteMessage" _ and TheFormField <> "SubmitButton" Then
Wszystkie inne pola i ich wartości łączone razem, ponieważ będą potrzebne do stworzenia właściwego zapytania:
Następnie kod przechodzi w pętli do kolejnej pozycji zbioru Form: Next
Każdy ciąg znaków stworzony wcześniej będzie w tym momencie posiadał dodatkowy przecinek i spację na końcu. Ten fragment kodu usuwa niepotrzebne znaki: TheFields = left(TheFields, Len(TheFields) - 2) TheValues = left(TheValues, Len(TheValues) - 2)
W końcu kod bazy danych (omówiony gruntownie w rozdziałach 13. i 14.) dodaje przesłane dane do danych przekazanych poprzez pole TableField w zbiorze Form: Dim conn set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" conn.execute "insert into " & Request.Form("TableName") _ & " (" & TheFields & ") values (" & TheValues & ")"
Witryna logowania Wiele witryn posiada obszary poufne, przed dostępem do których goście muszą się najpierw zalogować. Czasami spotyka się całe witryny tego typu. Kolejny przykład pokaże w jaki sposób stworzyć stronę logowania korzystającą ze znacznika cookie do zapamiętania odpowiednich informacji o użytkowniku. Strona zapamiętuje również informacje o gościach w bazie danych tak, aby mogli wejść na witrynę również wtedy, gdy ich cookie nie jest dostępny. Narzędzie to pokazuje sposób wykorzystania obiektu Request w celu gromadzenia informacji pochodzących od gości. Użytkownicy otrzymują informacje ze zbioru Form, a ich komputery ze zbioru Cookie. Kiedy goście odwiedzają witrynę po raz pierwszy, ukazuje się im widok pokazany na rysunku 5.19. Ponieważ są tu po raz pierwszy, nie posiadają w swoim systemie znacznika cookie. Kod nie wie czy są oni użytkownikami, którzy już odwiedzali stronę, nie mającymi obecnie cookie, czy są całkiem nowi. Jeśli są nowymi gościami strony, mogą kliknąć łącze, po czym zostaną odesłani do strony rejestrującej nowego użytkownika, pokazanej na rysunku 5.20.
175
ASP – Kompendium programisty
Rysunek 5.19. Formularz logowania
Rysunek 5.20. Strona nowego użytkownika Tutaj użytkownicy podają swoje imię (nazwę), hasło oraz ulubioną rzecz. Kod wpisuje te informacje do bazy danych, jak również wysyła do systemu użytkownika znacznik cookie pozwalający mu odwiedzać witrynę w przyszłości. Kiedy już użytkownik zakończy procedurę logowania, ujrzy stronę pokazaną na rysunku 5.21.
Rozdział 5 – Obiekt Request
176
Rysunek 5.21. Strona witająca witryny logowania Przy następnych wizytach użytkownicy będą odsyłani wprost do tej strony, jeśli tylko cookie będzie znajdował się na ich komputerach; jeśli tak nie będzie, będą oni odesłani z powrotem do strony logowania. Tym razem jednak uzyskają dostęp do witryny zaraz po wpisaniu nazwy użytkownika i hasła, ponieważ ich dane znajdują się w bazie. Następnie te informacje zostaną zapisane w znaczniku cookie w ich komputerze i za kolejnym razem (miejmy nadzieję!) będą oni mogli przejść od razu do strony powitania. Przypis
Kod użyty w tym przykładzie zawiera pewne instrukcje, które nie zostały jeszcze omówione. Zostały one jednak zastosowane tutaj, aby przykład był kompletny.
Wejściowa strona tej przykładowej witryny jest odpowiedzialna za sprawdzanie, czy dany gość posiada nasz znacznik cookie. Jeśli tak, strona wyświetla zawartość dostosowaną do użytkownika. Jeśli nie, gość odsyłany jest do strony logowania. Główny blok kodu tej strony jest następujący: <% Option Explicit If not Len(Request.Cookies("Login")("UserName")) > 1 Then Response.Redirect "./login.asp" End If %>
Kod używa obiektu Request do sprawdzenia cookie. Znacznik jest złożony, jeśli zawiera więcej niż jedno pole. Aby się przekonać, czy cookie w ogóle istnieje, sprawdzana jest długość znacznika. If not Len(Request.Cookies("Login")("UserName")) > 1 Then
Jeśli cookie nie ma w sobie przynajmniej jednego znaku, nie jest obecny i odwiedzający odesłani zostają do strony logowania: Response.Redirect "./login.asp"
ASP – Kompendium programisty
177
W innym wypadku widok strony jest dostosowywany według nazwy odwiedzającego i jego ulubionej kategorii, w oparciu o znaleziony znacznik cookie: Witamy na witrynie użytkownika o imieniu <% Response.Write Request.Cookies("Login")("UserName")%> Kliknij tutaj aby zobaczyć wszystkie produkty z Twojej ulubionej kategorii, którą jest <% Response.Write Request.Cookies("Login")("FavCat")%>
Zauważ, że ponownie mamy do czynienia ze złożonym cookie. Główna nazwa cookie brzmi Login, a kluczami podrzędnymi są UserName i FavCat. Strona logowania pozwala gościom odwiedzać witrynę, jeśli tylko znajdują się oni w bazie danych. Jeśli tak jest, znacznik cookie jest wysyłany do ich systemu, a sami użytkownicy są odsyłani do strony witającej. <% Option Explicit Dim RSUser Dim conn If not isempty(Request.Form("Login")) Then set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" set RSUser = conn.Execute("select * from C5Login where " _ & "UserName = '" & Request.Form("UserName") & "' and " _ & "Password = '" & Request.Form("Password") & "'") If not RSUser.EOF Then response.cookies("Login")("UserName") = request.form ("username") response.cookies("Login")("FavCat") = request.form("FavCat") response.cookies("Login").Expires = "2/2/2002" response.redirect "./welcomeback.asp" end if End If %>
Strona ma dwa stany. Albo goście dopiero weszli na stronę i należy wyświetlić formularz, albo przesłali formularz i informacje muszą być skonfrontowane z bazą danych. Funkcja IsEmpty jest używana w celu sprawdzenia naciśnięcia przycisku Zaloguj. Jeśli przycisk był naciśnięty, formularz został przesłany: If not isempty(Request.Form("Login")) Then
W tym przypadku, będziemy musieli sprawdzić dane odwiedzającego w naszej bazie danych: set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" set RSUser = conn.Execute("select * from C5Login where " _ & "UserName = '" & Request.Form("UserName") & "' and " _ & "Password = '" & Request.Form("Password") & "'")
Jeśli rekord odwiedzającego został znaleziony, ustawiona zostanie flaga EOF: If not RSUser.EOF Then
Następnie musimy wysłać cookie do systemu gościa i ustalić datę wygaśnięcia ważności znacznika:
Wtedy gość odsyłany jest do strony witającej. response.redirect "./welcomeback.asp"
Kod nowej strony dodaje gości do bazy danych, zapisuje w ich systemie cookie i wysyła ich do strony powitania. Kod strony: <% Option Explicit Dim conn If not isempty(Request.Form("Add")) Then set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" conn.execute "insert into C5Login (UserName, Password, FavCat) " _ & "values (" _ & "'" & Request.Form("UserName") & "', " _ & "'" & Request.Form("Password") & "', " _ & "'" & Request.Form("FavCat") & "')" response.cookies("Login")("UserName") = request.form("username") response.cookies("Login")("FavCat") = request.form("FavCat") response.cookies("Login").Expires = "2/2/2002" response.redirect "./welcomeback.asp" End If %>
Podobnie jak strona logowania, również ta strona ma dwa stany. Albo może mieć widok formularza, albo widok przetwarzania. Widok formularza po prostu przedstawia takowy w celu wypełnienia go informacjami pochodzącymi od gości. Drugi z widoków dokonuje przetworzenia danych wprowadzonych w formularzu. Stan określany jest na podstawie sprawdzenia przycisku Dodaj: If not isempty(Request.Form("Add")) Then
Jeśli przycisk jest naciśnięty, musimy dodać nowego gościa do bazy danych: set conn = server.createobject ("adodb.connection") conn.open "ASPBook", "sa", "yourpassword" conn.execute "insert into C5Login (UserName, Password, FavCat) " _ & "values (" _ & "'" & Request.Form("UserName") & "', " _ & "'" & Request.Form("Password") & "', " _ & "'" & Request.Form("FavCat") & "')"
Następnie cookie wraz z datą ważności są wpisywane do systemu gościa: response.cookies("Login")("UserName") = request.form("username") response.cookies("Login")("FavCat") = request.form("FavCat") response.cookies("Login").Expires = "2/2/2002"
ASP – Kompendium programisty
179 a odwiedzający jest odsyłany do strony powitania. response.redirect "./welcomeback.asp"
Rozdział 6. Obiekt Response Wysyłanie informacji do gości W ostatnim rozdziale przyjrzeliśmy procesowi pozwalającemu na bezpośrednie i pośrednie dostarczanie nam informacji o żądaniu i środowisku gości. W tym rozdziale zwrócimy uwagę na drugą tego procesu — wysyłanie informacji gościom i ich systemom operacyjnym. Spójrz na rysunek 6.1. Owalna otoczka wskazuje na rolę obiektu Response, który pozwala na przekazywanie dynamicznej zawartości do przeglądarki. Korzystasz z informacji zebranych przez system gości oraz przez składniki twojego systemu w celu przygotowania tekstu, grafik i wielu innych rzeczy, które mają być wysłane do odwiedzającego. Realizuje się to poprzez obiekt Response.
Rysunek 6.1. Rola obiektu Response w procesie ASP W tym rozdziale omawiamy zbiór, właściwości i metody obiektu Response. Poznasz sposoby wpisywania cookie do przeglądarki gościa. Nauczysz się sprawować kontrolę podczas wysyłania wyników kodu do gościa. Będziesz wiedział jak wpisywać nagłówki do przeglądarki. Przyjrzymy się również wysyłaniu danych innych niż tekst, takich jak grafiki. Na końcu rozdziału przyjrzymy się kilku praktycznym przykładom użycia obiektu Response.
Zbiór obiektu Response Obiekt Response posiada jeden tylko zbiór, który omówiono poniżej i podsumowano w tabeli 6.1. Tabela 6.1. Zbiór obiektu Response Zbiór Przeznaczenie Cookies Wpisywanie znaczników cookie do przeglądarek gości.
ASP – Kompendium programisty
181
Zbiór cookie Jak wspomniano w poprzednim rozdziale, cookies są sposobem na zapisanie informacji na komputerze gościa. Później możesz wykorzystać twój kod w celu wyszukania wartości zapisanych w systemie gościa. Na przykład mógłbyś zapamiętać w cookie najczęstsze kryteria wyszukiwania użyte przez gościa na twojej witrynie WWW. Następnie kiedy odwiedzający zacząłby ponownie wyszukiwać, mógłbyś przedstawić mu ostatnie pięć kryteriów; mógłbyś również zapamiętać w cookie położenie gościa i wyświetlić taką lokalną informację, kiedy ponownie będzie odwiedzał twoją witrynę. Ponieważ jednak dane przechowywane są w systemie gościa, cookie nie może być jedynym sposobem identyfikacji gości. Zawsze powinieneś dysponować jakąś alternatywą dla cookies. Pamiętaj, że użytkownicy mogą w każdym czasie skasować kod, mogą mieć na komputerze program blokujący cookies lub mogą odwiedzać twoją witryną z innego systemu. Umieszczania cookie na komputerze gościa dokonuje się przy użyciu zbioru Cookies obiektu Response. Aby wpisać pojedynczy, prosty znacznik cookie do systemu gościa, należy stworzyć następujący kod: Response.Cookies("NameOfCookie") = "Wartość"
jest nazwą cookie zapamiętanego na systemie gościa. Wartość reprezentuje tekst zapamiętywany w cookie. Tak więc ten kod:
NameOfCookie
Response.Cookies("SearchCriteria1") = "ASP"
wpisze do systemu gościa cookie o nazwie SearchCriteria1. Znacznik będzie zawierał wartość ASP. Jeśli cookie już istnieje, stara wartość będzie zastąpiona nową. Poprzedni kod tworzy prosty cookie zawierający pojedynczą wartość. Jednak znacznik może być również złożony i może zawierać klucze podrzędne. Odniesienia to danego klucza dokonuje się poprzez określenie nazwy cookie wraz z nazwą klucza podrzędnego w następującej formie: Response.Cookies("NameOfCookie")("NameOfKey") = "Wartość"
W tym przykładzie NameOfCookie jest nazwą cookie głównego, a NameOfKey reprezentuje nazwę klucza podrzędnego, do którego się odnosimy. Wartość to tekst wpisywany do cookie. W naszym przykładzie związanym z kryteriami przeszukiwania, moglibyśmy zapamiętywać najczęściej wykorzystywane kryteria wyszukiwania w złożonym cookie. Spójrz na rysunek 6.2. To uproszczony widok naszej strony wyszukiwania, kiedy gość korzysta z niej po raz pierwszy. Pole najczęściej wykorzystywanych kryteriów jest puste. Jednak po kilku przeszukiwaniach pole zostanie zapełnione elementami do wyboru, jak to pokazano na rysunku 6.3.
Rozdział 6 – Obiekt Response
Rysunek 6.2. Pierwotny widok strony wyszukującej
Rysunek 6.3. Widok strona po zakończeniu wyszukiwania Kod realizujący to zadanie używa cookies. Blok kodowy na początku strony wpisuje znaczniki cookies: <% If Len(Request.Form("Search")) > 0 Then Response.Cookies("SearchCriteria")("5")Request.Cookies ("SearchCriteria")("4") Response.Cookies("SearchCriteria")("4")Request.Cookies ("SearchCriteria")("3") Response.Cookies("SearchCriteria")("3")Request.Cookies ("SearchCriteria")("2") Response.Cookies("SearchCriteria")("2")Request.Cookies
182
ASP – Kompendium programisty
183 ("SearchCriteria")("1") Response.Cookies("SearchCriteria")("1") = Request.Form("Search") End If %>
Po pierwsze kod upewnia się, czy gość wprowadził nowe kryterium wyszukiwania: If Len(Request.Form("Search")) > 0 Then
Jeśli tak się stało, każdy cookie przeskakuje o jeden poziom w górę. Czwarte kryterium z listy najczęściej używanych staje się piątym, trzecie czwartym i tak dalej: Response.Cookies("SearchCriteria")("5")Request.Cookies ("SearchCriteria")("4") Response.Cookies("SearchCriteria")("4")Request.Cookies ("SearchCriteria")("3") Response.Cookies("SearchCriteria")("3")Request.Cookies ("SearchCriteria")("2") Response.Cookies("SearchCriteria")("2")Request.Cookies ("SearchCriteria")("1")
Następnie nowo wprowadzone kryterium jest dokładane do listy najczęściej używanych: Response.Cookies("SearchCriteria")("1") = Request.Form("Search")
W formularzu HTML obiekt wyboru Select jest wypełniany tymi znacznikami cookie za każdym razem, kiedy strona jest ładowana: <SELECT NAME="OldSearch" SIZE=1>
