Spis Treści
SPIS TREŚCI........................................................................................................................................................ 1
ROZDZIAŁ 1. TWORZENIE DYNAMICZNYCH APLIKACJI INTERNETOWYCH............................. 6
Specyfikacja HTML 2 ..................................................................................................................................... 7
Specyfikacja HTML 3.2 .................................................................................................................................. 8
Specyfikacja HTML 4 ..................................................................................................................................... 8
AWARTOŚĆ STATYCZNA A ZAWARTOŚĆ DYNAMICZNA
...................................................................................... 8
WORZENIE SKRYPTÓW PO STRONIE KLIENTA I PO STRONIE SERWERA
............................................................... 10
Tworzenie skryptów po stronie klienta......................................................................................................... 10
Tworzenie skryptów po stronie serwera....................................................................................................... 14
KŁ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
ROZDZIAŁ 2. SERWER IIS WIDZIANY Z PERSPEKTYWY TWÓRCY STRON................................ 30
Właściwości witryny WWW .......................................................................................................................... 34
Właściwości związane z wydajnością........................................................................................................... 36
Właściwości filtrów ISAPI............................................................................................................................ 36
Właściwości katalogu macierzystego ........................................................................................................... 37
Dokumenty.................................................................................................................................................... 38
Błędy klienta ................................................................................................................................................. 39
Wiele witryn pod jednym adresem IP........................................................................................................... 45
Zakładka właściwości witryny WWW........................................................................................................... 47
Właściwości katalogu macierzystego ........................................................................................................... 48
Katalogi wirtualne........................................................................................................................................ 49
Właściwości folderu i pliku .......................................................................................................................... 51
Zmienne trwałe i zakresowe ......................................................................................................................... 52
Zdarzenia...................................................................................................................................................... 53
Tworzenie aplikacji ASP............................................................................................................................... 53
Konfigurowanie aplikacji ASP ..................................................................................................................... 55
Spis Treści
2
RZEGLĄD APLIKACJI DO TWORZENIA STRON
Środowisko pracy ......................................................................................................................................... 62
Tworzenie sieci Web..................................................................................................................................... 68
Przeglądanie strony...................................................................................................................................... 70
Dodawanie strony......................................................................................................................................... 71
Praca ze stroną............................................................................................................................................. 72
Środowisko pracy ......................................................................................................................................... 74
Tworzenie witryny WWW przy użyciu programu Fusion ............................................................................. 80
Praca ze stroną............................................................................................................................................. 80
Środowisko programowe .............................................................................................................................. 81
Praca z kodem w programie ScriptBuilder .................................................................................................. 87
Weryfikacja kodu w programie ScriptBuilder.............................................................................................. 92
Znacznik <% = X %> .................................................................................................................................. 97
<% Pojedyncza linia kodu %> .................................................................................................................... 98
<% Blok kodu %>........................................................................................................................................ 99
< Script> Kod </Script> ........................................................................................................................... 100
HTML w kodzie .......................................................................................................................................... 101
Dyrektywa przetwarzania........................................................................................................................... 105
Pliki Include ............................................................................................................................................... 106
Po co ich używać .................................................................................................................................... 106
Włączanie pliku...................................................................................................................................... 106
Plik Include — struktura i przykład ....................................................................................................... 106
Wywoływanie procedur.......................................................................................................................... 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
ASP – Kompendium programisty
3
Czym są hierarchie obiektów? ................................................................................................................... 148
Model obiektów ASP................................................................................................................................... 149
DBIERANIE INFORMACJI OD ODWIEDZAJĄCEGO
............................................................................................. 151
Zbiór Form ............................................................................................................................................. 151
Zbiór QueryString .................................................................................................................................. 154
Zbiór ServerVariables ............................................................................................................................ 157
Zbiór Cookies ......................................................................................................................................... 159
Zbiór ClientCertificate............................................................................................................................ 160
Przykład certyfikatu klienta........................................................................................................................ 163
Procesor e-mail dla formularza ................................................................................................................. 168
Procesor bazy danych dla formularza........................................................................................................ 172
Witryna logowania ..................................................................................................................................... 174
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
Metoda AddHeader .................................................................................................................................... 193
Metoda AppendToLog ................................................................................................................................ 193
Metoda BinaryWrite ................................................................................................................................... 193
Metoda Clear.............................................................................................................................................. 196
Metoda End ................................................................................................................................................ 196
Metoda Flush.............................................................................................................................................. 197
Metoda Redirect ......................................................................................................................................... 198
Metoda Write .............................................................................................................................................. 199
Readresowanie i obiekt wyboru ................................................................................................................. 199
Pasek zaawansowania................................................................................................................................ 203
Strona preferencji....................................................................................................................................... 207
Metoda CreateObject ................................................................................................................................. 215
Metoda HTMLEncode ................................................................................................................................ 218
Metoda MapPath........................................................................................................................................ 219
Spis Treści
4
ROZDZIAŁ 8. OBIEKT SESSION, OBIEKT APPLICATION ORAZ PLIK GLOBAL.ASA............... 232
Zbiór Contents........................................................................................................................................ 235
Zbiór StaticObjects................................................................................................................................. 239
Właściwość CodePage............................................................................................................................ 241
Właściwość LCID .................................................................................................................................. 242
Właściwość SessionID ........................................................................................................................... 244
Właściwość TimeOut ............................................................................................................................. 244
Zbiór Contents........................................................................................................................................ 246
Zbiór StaticObjects................................................................................................................................. 250
Metoda Lock........................................................................................................................................... 251
Metoda Unlock ....................................................................................................................................... 253
Zdarzenie Application_OnStart.............................................................................................................. 255
Zdarzenie Application_OnEnd............................................................................................................... 259
Zdarzenie Session_OnStart .................................................................................................................... 259
Zdarzenie Session_OnEnd ..................................................................................................................... 261
Deklaracje obiektów w pliku global.asa................................................................................................. 263
O FUNKCJĘ WYSYŁANIA WIADOMOŚCI E
................................................... 266
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
Metoda Send........................................................................................................................................... 281
Metoda AttachFile.................................................................................................................................. 282
Metoda AttachURL ................................................................................................................................ 284
Metoda SetLocaleID............................................................................................................................... 285
ASP – Kompendium programisty
5
BIEKTY ZWIĘKSZAJĄCE MOŻLIWOŚCI STRON
ASP......................................................................................... 287
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.
Rysunek 1.1. Pierwotna wersja HTML
ASP – Kompendium programisty
7
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.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
8
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
%>
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
10
<H1> Jest weekend idź do domu!</H1>
<%
else
%>
<H1>Rzuć surfing i do pracy!</H1>
<%
end if
%>
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"><!--
browserName = navigator.appName;
browserVer = parseInt(navigator.appVersion);
if (((navigator.appName == "Netscape") &&
(parseInt(navigator.appVersion) >= 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)
{ if (version == "ok")
{ document[imgName].src = eval(imgName + "on.src"); } }
function imgoff(imgName)
{ if (version == "ok")
{ document[imgName].src = eval(imgName + "off.src"); } }
// –></SCRIPT>
Rysunek 1.6. Ta sama strona z kursorem myszy znajdującym się nad obrazkiem
Następnie w elemencie obrazka mamy poniższy kod korzystający z poprzednich funkcji i zmiennych:
<A HREF="mailto:info@netstats2000.com"
onmouseover="imgover('img6')" onmouseout="imgoff('img6')">
<IMG HEIGHT=33 WIDTH=569 SRC="./assets/images/baroff.jpg"
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
12
BORDER=0 ALT="Click here to contact us" name=img6></A>
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">
<!--
function IsPresent(PassedValue)
{
var ReturnTest = 0;
var LocalPassedValue = PassedValue;
if (LocalPassedValue)
ASP – Kompendium programisty
13
{
for (var i=0; i<LocalPassedValue.length; i++)
{
if (LocalPassedValue.charAt(i) != " ")
{
ReturnTest = 1;
}
}
}
if (!ReturnTest)
{
return 0;
}
return 1;
}
function CheckForm()
{
var TheMessage = "";
if (!(IsPresent(document.sampleform.reqField.value)))
{
TheMessage += "Please enter a value.\n";
}
if (TheMessage != "")
{
alert(TheMessage);
}
else
{
document.location.href = "result.htm";
}
}
// -->
</SCRIPT>
Kod dla przycisku Submit Request:
<INPUT TYPE="button" NAME="submitButton" VALUE="Submit Request"
onClick="CheckForm();">
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.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
14
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 %>
<%
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
16
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.
ASP – Kompendium programisty
17
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.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
18
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:
<P><B><FONT FACE="Arial,Helvetica">
With this type of scripting, the code runs in the browser.
</B></FONT>
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" >
<OPTION VALUE="Server-Side">Server-Side</OPTION>
<OPTION VALUE="Client-Side">Client-Side</OPTION>
</SELECT>
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.
<INPUT TYPE=HIDDEN NAME="CurrentQuestion" VALUE = "1">
<INPUT TYPE=HIDDEN NAME="QuestionsTaken" VALUE = "0">
<INPUT TYPE=HIDDEN NAME="NumberCorrect" VALUE = "0">
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:
<FORM ACTION="./quiz.asp" METHOD=POST>
Tak więc wartości są wysyłane z powrotem do tej samej strony, która wcześniej stworzyła omawianą stronę —
oto w jaki sposób uzyskujemy wiele stron z jednej. Za każdym razem kiedy odwiedzający odpowiadają na
pytanie, numer pytania wraz z odpowiedzią i dwoma innymi wartościami jest wysyłany z powrotem do tej
samej strony w celu przetworzenia.
Jeszcze jedna rzecz jest przekazywana wraz ze stroną podczas jej przedkładania. Jest to nazwa naciśniętego
przycisku:
<INPUT TYPE="submit" NAME="Calculate" VALUE="Check Answer" >
Często będziesz spotykał się z tym kodem w dalszych częściach książki oraz sam będziesz używał go przy
tworzeniu twoich własnych kodów. Wykrywanie naciśnięcia tego lub jakiegokolwiek innego przycisku służy
określeniu działań, jakie należy podjąć.
Kiedy strona jest przetwarzana, na stronie znajduje się czysty HTML tuż obok jej kodu. Na przykład, na
nieprzetworzonej stronie obiekt sterujący wyborem, który został opisany wcześniej, wygląda następująco:
<SELECT NAME="Answer" ><% response.write AnswerText %></SELECT>
A HTML z kodem strony nieprzetworzonej dla elementów ukrytych przedstawia się tak:
<INPUT TYPE=HIDDEN NAME="CurrentQuestion" VALUE = "
<% Response.Write CurrentQuestion %>">
<INPUT TYPE=HIDDEN NAME="QuestionsTaken" VALUE = "
<% Response.Write QuestionsTaken %>">
<INPUT TYPE=HIDDEN NAME="NumberCorrect" VALUE = "
<% Response.Write NumberCorrect %>">
W dalszej części tego rozdziału przyjrzymy się jak kod ASP współpracuje z HTML w celu realizacji
dynamicznego wyświetlania zawartości.
Składnik bazy danych
Wiele rozwiązań internetowych i intranetowych, które stworzysz, będzie zawierało w sobie jakiś rodzaj bazy
danych. Kiedy logujesz użytkowników twojej witryny, będziesz potrzebował tabeli użytkowników, która
będzie wykorzystywana podczas zatwierdzania ich wejść. Jeśli posiadasz firmowy katalog online,
prawdopodobnie będzie on składał się z tabel zawierających informacje o produktach: ich nazwy, opis,
dostępność, ceny, zalety itd. Jeśli na twojej stronie znajdują się informacje o aktualnych warunkach
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
20
atmosferycznych w twoim miejscu zamieszkania, dane do wyszukiwania zapewne przechowywane są w bazie
danych.
Tak więc baza danych dynamicznej aplikacji internetowej często zawiera kod źródłowy dla dynamicznej
zawartości. W naszym przykładowym projekcie quizu żądania dla bazy danych pochodzą od strony ASP.
Żądanie przechodzi przez komponent serwera, który wystosowuje zapytania do bazy danych. Baza danych
zwraca żądanie do komponentu serwera, który następnie przesyła dane z powrotem do naszej strony ASP.
Jak się dowiesz dokładniej z rozdziału 13., kod żądania dostępu do danych bazy, zarówno na stronie ASP jak i
w składniku serwera, musi znać położenie bazy danych. Aby to osiągnąć, można skorzystać z Otwartego łącza
baz danych (ODBC — Open Database Connectivity). Poprzez Administratora źródeł danych ODBC (rysunek
1.16.) stworzymy Nazwę źródła danych (DSN — Data Source Name). Klikając przycisk Dodaj (Add) możemy
skonfigurować połączenie z każdą osiągalną bazą danych, dla której mamy sterownik ODBC.
Rysunek 1.16. Administrator źródeł danych ODBC
W tej przykładowej witrynie łączymy się z bazą danych SQL Server 6.5 zwaną ASPBook. Stworzona zostaje
nazwa DSN w celu zapewnienia komunikacji pomiędzy SQL Server a stroną ASP. Kiedy to połączenie jest
tworzone po raz pierwszy, zapamiętywany jest typ i nazwa bazy danych oraz adres IP serwera. Niektóre z tych
elementów widać na rysunku 1.17.
ASP – Kompendium programisty
21
Rysunek 1.17. Konfiguracja nazwy DSN ODBC.
Dane w bazie naszego przykładu z quizem zawierają tekst pytania, prawidłową odpowiedź na nie oraz
wszystkie inne możliwe odpowiedzi, które zostaną wyszczególnione w obiekcie wyboru strony WWW. Używa
się dwóch tabeli dostarczających potrzebnych danych. Pierwsza z nich zwana jest C1Questions; zawiera ona
dane samego pytania. Nazwy pól, typów i ich zastosowania pokazano w tabeli 1.1.
Tabela 1.1. Pola C1Questions
Nazwa pola
Typ pola
Przeznaczenie
QuestionID int
Klucz
główny
Question varchar
Tekst
pytania
Answer
varchar
Tekst poprawnej odpowiedzi
QuestionID jest kluczem podstawowym dla tabeli. Oznacza to, że zawiera wartość, która jest unikalna dla tego
pola. Jeśli więc któryś rekord posiada pole QuestionID o wartości 45, nie może jej mieć żaden inny rekord. Ta
niepowtarzalność daje nam możliwość odczytywania właściwych odpowiedzi w kodzie. Typ danych to int,
czyli wartość pola musi być liczbą całkowitą.
Pole Question zawiera treść samego pytania. Ta dana jest wyświetlana na stronie WWW jako pytanie. Typ
danych w tym wypadku to varchar, co znaczy, że w polu tym mogą znaleźć się litery wraz z cyframi. Długość
pola może wynosić od 0 do 255 znaków.
Pole Answer zawiera prawidłową odpowiedź na pytanie. To pole tekstowe używane jest do sprawdzania
poprawności odpowiedzi podawanej przez biorących udział w quizie. Pole może zawierać od 0 do 100 znaków.
Druga tabela, z której korzysta nasza przykładowa strona z quizem, zawiera wszystkie możliwe odpowiedzi na
zadane pytania. Nazywa się C1Answers, a jej pola opisuje tabela 1.2.
Tabela 1.2. Pola C1Answers
Nazwa pola
Typ pola
Przeznaczenie
AnswerID int
Klucz
główny i kolumna
tożsamości
QuestionID int
Klucz
obcy
Answer
varchar
Tekst poprawnej odpowiedzi
Dane w tabeli 1.2. są wykorzystywane do wypełnienia obiektu sterującego wyborem na stronie WWW. Do
każdego pytania można przyporządkować jedną lub kilka odpowiedzi znajdujących się w tabeli. W kodzie
prosimy tabelę o znalezienie odpowiedzi przyporządkowanych do aktualnego pytania, a następnie wyświetlamy
je w obiekcie wyboru.
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
22
Pole AnswerID jest kluczem głównym tabeli. Jak wspomniano wcześniej klucz główny jednoznacznie
identyfikuje każdy rekord tabeli. Pole jest również określane pojęciem kolumny tożsamości. To znaczy, że
podczas dodawania do tabeli nowego rekordu możesz zostawić to pole puste, a SQL Server wypełni je
automatycznie niepowtarzalną wartością. Jak się dowiemy z rozdziału 13., tworząc pola takie jak te w SQL
Server, możesz określić numer początkowy i sposób inkrementacji tego numeru dla kolejnych rekordów.
Pole QuestionID używane jest jako klucz obcy tabeli, to znaczy będzie wykorzystywany do połączenia
pomiędzy tabelami C1Questions i C1Answers. Kiedy wypełniamy obiekt wyboru możliwymi odpowiedziami,
nie chcemy widzieć odpowiedzi na inne pytania, interesują nas jedynie dostępne odpowiedzi na bieżące
pytanie. To pole umożliwia taką filtrację. Kiedy odpowiedź jest wprowadzana do tabeli, musi zostać również
wprowadzona wartość pola QuestionID. To ostatnie pole odnosi się do właściwego pytania związanego z tą
odpowiedzią.
Ostatnie pole tej tabeli to pole Answer, które zawiera samą treść odpowiedzi. Ta dana trafia do obiektu
sterującego wyborem.
Jeden z rekordów tabeli C1Questions pokazuje tabela 1.3.
Przykładowy rekord C1Answers prezentuje tabela 1.4.
Tabela 1.3. Przykładowy rekord tabeli C1Questions
Nazwa pola
Wartość
QuestionID 1
Question
Przy tym sposobie pisania skryptów kod uruchamiany
jest w przeglądarce.
Answer
Po stronie klienta
Tabela 1.4. Przykładowy rekord tabeli C1Answers
Nazwa pola
Wartość
AnswerID 1
QuestionID 1
Answer
Po stronie serwera
Komponenty serwera
Nie wszystkie twoje rozwiązania internetowe i intranetowe potrzebują komponentów serwera. Tak naprawdę na
samym początku możesz nie używać ich wcale. Ale z upływem czasu zorientujesz się, że niektórych rozwiązań
nie uda ci się zrealizować od ręki stosując jedynie technologię ASP; być może stwierdzisz, że kod ASP staje się
zbyt skomplikowany i należy podzielić go na obiekty; lub może rozdzielisz te różnorodne zadania pomiędzy
programistów klasy podstawowej a tych bardziej zaawansowanych.
Wykorzystanie czy utworzenie komponentu serwera często zaspokaja wiele wymagań. Komponenty serwera są
modułami kodowymi, do których uzyskujesz dostęp poprzez twój kod ASP lub z innych środowisk
programowych w celu realizacji pewnych zadań związanych z programowaniem.
Niektóre z tych składników wbudowane są w twój system. Na przykład IIS (Internet Information Server) jest
dostarczany wraz z CDO (Collaborative Data Objects) ułatwiającymi wysyłanie poczty elektronicznej poprzez
twój kod, co zostanie omówione w rozdziale 9. Kolejny składnik dostarczany wraz z IIS to Browser
Capabilities, który to komponent używany jest do określania typu przeglądarki i innych informacji dotyczących
gości strony (więcej informacji znajdziesz w rozdziale 10).
Inne składniki można zakupić lub pobrać ze stron sprzedawców. Te produkty są zazwyczaj bardziej
wyspecjalizowane w swoich zadaniach. Jeśli na przykład wystąpi potrzeba stworzenia kodu grafiki ukazującej
diagram kołowy, znajdziesz odpowiednie ku temu składniki. Często możesz oszczędzić sobie mnóstwa czasu i
pieniędzy dzięki zakupieniu składnika wspierającego programowanie.
Inną możliwością jest stworzenie własnych składników. Można w ten sposób zaspokoić różnorodne potrzeby,
w tym również wydajność. Gdy tworzysz nowy składnik zaimplementowany w postaci kompilowanego kodu,
który różni się od kodu skryptu ASP tym, że musisz go przekompilować za każdym razem, kiedy go używasz.
Innym ważnym powodem tworzenia składników jest oddzielenie od siebie części strony poświęconej sprawom
firmowym od interfejsu twoich aplikacji. Załóżmy, że musisz stworzyć witrynę, która dodawałaby informacje o
nowych pracownikach do bazy danych. Możesz tego dokonać na wiele różnych sposobów. Możesz stworzyć
ASP – Kompendium programisty
23
aplikację dostępu dla działu zasobów ludzkich twojej firmy, przez którą będzie się wprowadzać zapisy do bazy
danych. Możesz również użyć w tym celu aplikacji ASP. Baza danych prawdopodobnie jest skonfigurowana w
ten sposób, że pewne pola wymagają wypełnienia, inne muszą być określonego typu i zasięgu. Te zasady,
zasady firmowe, mogą być modyfikowane o wiele łatwiej i dokładniej, jeśli są umieszczone osobno.
Komponent serwera zazwyczaj jest implementowany w ten sposób.
Dodatkowym powodem tworzenia komponentów serwera jest pozbawienie niedoświadczonych programistów
dostępu do pewnych złożonych bloków kodu. Możesz na przykład stworzyć procedurę obliczającą pewną
przewidywaną wartość na podstawie zbioru parametrów i kalkulacji. Ten kod mógłby być umieszczony we
wszystkich miejscach, które z niego korzystają. Ale programista, który nie jest z nim odpowiednio
zaznajomiony mógłby korzystać z niego w niewłaściwy sposób. Jeśli stworzysz składnik serwera, umożliwisz
swoim programistom wykonanie obliczeń dzięki jednemu połączeniu.
W rozdziale 10. omówimy szczegółowo komponenty serwera, tutaj natomiast ograniczymy się jedynie do ich
wprowadzenia.
Na potrzeby strony z quizem, stworzony został komponent przez kompilację ActiveX DLL w Visual Basicu.
Ten składnik realizuje interfejs między bazą danych a naszym kodem podstawowym, ASP. Tworzy się go
poprzez wybranie projektu ActiveX DLL w oknie Visual Basic, co pokazano na rysunku 1.18.
Rysunek 1.18. Tworzenie ActiveX DLL w Visual Basic
Kiedy zaznaczymy ikonę ActiveX DLL, konfigurujemy szablon do tworzenia składnika serwera biblioteki
DLL. Szczególne znaczenie ma tutaj nazwa projektu, ponieważ będzie ona używana w naszym kodzie ASP w
celu wywoływania procedur komponentu serwera. Robi się to przez wybranie Właściwości projektu (Project
Properties) z menu Projekt (Project). Ukaże się okno dialogowe pokazane na rysunku 1.19, gdzie wpiszesz
nazwę projektu w pole tekstowe Nazwa projektu (Project Name).
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
24
Rysunek 1.19. Nadawanie nazwy składnikowi serwera
Wewnątrz ActiveX DLL znajdują się klasy, w których procedury faktycznie działają. Ilość klas nie jest
ograniczona. Klasy tworzy się zazwyczaj przez umieszczenie razem tych procedur, które mają wspólne
przeznaczenie. Na przykład komponent serwera naszej strony z quizem posiada jedną klasę. Klasa ta zawiera
procedury wyszukiwania pytania i sprawdzania odpowiedzi. Lecz jeśli rozszerzymy tą aplikację, będziemy
mogli dodać strony pozwalające użytkownikom na uzupełnianie quizu o własne pytania. Procedury realizujące
takie zadania znajdowałyby się prawdopodobnie w osobnej klasie. Być może chciałbyś dodać kolejną klasę,
która pozwalałaby użytkownikom logować się w aplikacji quizu w celu śledzenia jej rozwoju. Procedury
realizujące tą funkcję znajdowałyby się zapewne w osobnej klasie.
Podobnie jak w wypadku projektu, klasa również posiada swą nazwę. Nazwa klasy jest ważna, ponieważ
będzie wykorzystywana przez nasz kod ASP do wywoływania procedur znajdujących się na serwerze.
Używając Visual Basic nazwę klasy określić możesz we właściwościach klasy pokazanych na rysunku 1.20.
Rysunek 1.20. Nadawanie nazwy klasie
ASP – Kompendium programisty
25
Teraz, kiedy zdefiniowaliśmy już nasz komponent oraz klasę, jesteśmy gotowi do stworzenia procedury bądź
metody wewnątrz klasy. Metody są blokami kodu napisanymi po to, aby realizować pewne zadania
programowe. Są one wywoływane z kodu ASP, co zostanie omówione później.
Klasa o nazwie Quiz, którą stworzyliśmy poprzednio posiada trzy metody. Pierwsza z nich wyszukuje tekst
pytania w oparciu o pole
QuestionID
przekazywane przez procedurę. Kod procedury jest następujący:
Public Function GetQuestion(QuestionID)
Dim RSQuestion As ADODB.Recordset
Set RSQuestion = Conn.Execute("select Question from C1Questions " _
& "where QuestionID = " & QuestionID)
If RSQuestion.EOF Then
GetQuestion = "NA"
Else
GetQuestion = RSQuestion("Question")
End If
End Function
Zauważ, że metoda ta nosi nazwę
GetQuestion
. Tej nazwy będziemy używać w kodzie ASP do wywoływania
procedury. Kod tej funkcji łączy się z bazą danych i wyszukuje w niej tekst pytania w oparciu o pole
QuestionID
. Jeśli pole to nie jest właściwe, zwracany jest tekst
NA
; w przeciwnym wypadku zwracany jest tekst
pytania.
Kolejna procedura zwraca tekst możliwych odpowiedzi do wypełnienia obiektu wyboru w formularzu HTML.
Kod tej procedury:
Public Function GetAnswer(QuestionID)
Dim RSAnswers As ADODB.Recordset
Dim TempList As String
Set RSAnswers = Conn.Execute("select Answer from C1Answers " _
& "where QuestionID = " & QuestionID)
Do Until RSAnswers.EOF
TempList = TempList & "<OPTION VALUE=""" _
& RSAnswers("Answer") & """>" _
& RSAnswers("Answer") & "</OPTION>"
RSAnswers.MoveNext
Loop
GetAnswer = TempList
End Function
Ta metoda nosi nazwę
GetAnswer
. Kiedy jest wywoływana, przekazywane zostaje pole QuestionID. W bazie
danych wyszukiwane są wszystkie możliwe odpowiedzi na dane pytanie. Następnie kod przechodzi kolejno lub
w pętli przez każdą z opcjonalnych odpowiedzi znajdujących się w obiekcie sterującym wyborem, budując
odpowiedni tekst HTML. Formatem zwracanym przez metodę jest czysty HTML.
Ostatnią metodą klasy Quiz serwera o nazwie SampleServer jest procedura
CheckAnswer
. Sprawdza ona
poprawność udzielonej odpowiedzi. Kod procedury:
Public Function CheckAnswer(QuestionID, AnswerText)
Dim RSAnswer As ADODB.Recordset
Set RSAnswer = Conn.Execute("select Answer from C1Questions " _
& "where QuestionID = " & QuestionID)
If RSAnswer("Answer") = AnswerText Then
CheckAnswer = 1
Else
CheckAnswer = 0
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
26
End If
End Function
Procedura
CheckAnswer
korzysta z dwóch wartości: pola
QuestionID
oraz
Answer
w celu sprawdzenia
poprawności odpowiedzi. Kod łączy się z bazą danych przeszukując ją w celu odnalezienia poprawnej
odpowiedzi na konkretne pytanie. Następnie ta odpowiedź jest porównywana z odpowiedzią przekazywaną
przez procedurę. Jeśli obydwie są takie same, procedura zwraca wartość 1, jeśli tak nie jest — wartością
wyjściową jest 0. Te wartości oraz inne zwracane przez procedury będą wykorzystane przez kod ASP, co
omówiono dalej.
Klasa, którą tworzymy w Visual Basic, posiada miejsce pozwalające nam na określenie aplikacji, którą chcemy
uruchomić, kiedy po raz pierwszy klasa jest wywoływana, innymi słowy kiedy tworzona jest jej kopia. To
miejsce nazywane określane jest mianem Inicjacji zdarzenia i zawiera następujący kod:
Private Sub Class_Initialize()
Conn.Open "ASPBook", "sa", "yourpassword"
End Sub
Ten kod zapewnia nam połączenie z bazą danych. Pamiętaj o tym, że musieliśmy skonfigurować nazwę DSN,
jak to omawialiśmy w podrozdziale poświęconym bazie danych. Jedna z linii powyższego kodu korzysta z
nazwy DSN, dzięki której możliwe jest połączenie z bazą danych. Inne procedury tej klasy używają tego
połączenia podczas wyszukiwania danych.
Kod ASP (Active Server Page)
Do tej pory przyglądaliśmy się czystemu kodowi HTML wysyłanemu do przeglądarki, jak również jego
statycznemu wykorzystywaniu na naszej dynamicznej stronie. Przyjrzeliśmy się bazie danych zawierającej
pytania i odpowiedzi quizu, jak również składnikom stworzonym w Visual Basic, używanym podczas łączenia
z bazą. Teraz zwrócimy uwagę na kod ASP.
Kod ASP jest odczytywany i przetwarzany przez serwer IIS, kiedy nasi goście odwiedzają stronę. Ten kod
kompletuje wywołania potrzebne do stworzenia odpowiedniego wyjścia dla przeglądarki. W naszym
przykładzie quizu kod musi wyszukiwać pytania i odpowiedzi. Musi również obserwować aktualne pytanie
oraz liczbę poprawnych odpowiedzi oraz zadanych pytań. Kod powinien też formatować stronę w ten sposób,
aby pole odpowiedzi i przycisk nie ukazywały się po zakończeniu quizu. Szczegółowo omówimy układ tego
kodu w rozdziale 4., a na razie przyjrzymy się mu tylko pobieżnie.
Na początku strony ASP mamy następujący kod:
<%@ Language=VBScript %>
<%
set objQuiz = server.CreateObject("SampleServer.Quiz")
if isempty(Request.Form("Calculate")) then
CurrentQuestion = 1
QuestionsTaken = 0
NumberCorrect = 0
else
if objQuiz.CheckAnswer(Request.Form("CurrentQuestion"), _
Request.Form("Answer")) = 1 then
NumberCorrect = Request.Form("NumberCorrect") + 1
else
NumberCorrect = Request.Form("NumberCorrect")
end if
QuestionsTaken = Request.Form("QuestionsTaken") + 1
CurrentQuestion = Request.Form("CurrentQuestion") + 1
end if
ASP – Kompendium programisty
27
QuestionText = objQuiz.GetQuestion(CurrentQuestion)
if QuestionText = "NA" then
TheMessage = "Quiz: Complete"
else
TheMessage = "Quiz: In Progress"
AnswerText = objQuiz.GetAnswer(CurrentQuestion)
end if
%>
Pierwsza linia kodu informuje kompilator o rodzaju języka użytego podczas tworzenia skryptu, w tym
przypadku jest to VBScript.
Następnie tworzymy kopię klasy na serwerze, co opisane zostało w poprzednim podrozdziale. Innymi słowy
łączymy się ze składnikiem serwera, ponieważ chcemy wykorzystać procedury znajdujące się na nim:
set objQuiz = server.CreateObject("SampleServer.Quiz")
Zauważ, że kiedy stworzyliśmy procedurę, użyliśmy nazw projektu i klasy — SampleServer.Quiz.
Przypomnij sobie podrozdział dotyczący HTML, gdzie omawialiśmy sposób określania działań, które należy
podjąć przy użyciu przycisku Submit Request. To samo realizuje poniższy kod:
if isempty(Request.Form("Calculate")) then
Oznacza to, że jeśli odwiedzający nie nacisnął przycisku Calculate, to musiał wejść na stronę. Jeśli wystąpi taki
przypadek, będziemy musieli skonfigurować stronę pierwszego pytania:
CurrentQuestion = 1
QuestionsTaken = 0
NumberCorrect = 0
Jeśli przycisk Calculate jest naciśnięty, wtedy odwiedzającym przedstawiane są pytania, na które należy
odpowiedzieć:
Else
Następnie kod wywołuje składnik sprawdzający, czy nasi goście wpisali poprawną odpowiedź. Jeśli tak,
musimy wyświetlić potwierdzenie poprawności:
if objQuiz.CheckAnswer(Request.Form("CurrentQuestion"), _
Request.Form("Answer")) = 1 then
NumberCorrect = Request.Form("NumberCorrect") + 1
W przeciwnym razie, aktualna liczba (
NumberCorrect
) oznacza ilość udzielonych do tej pory poprawnych
odpowiedzi:
else
NumberCorrect = Request. Form("NumberCorrect")
Teraz musimy wyszukać tekst kolejnego pytania poprzez wywołanie procedury
GetQuestion
ze składnika
serwera:
QuestionText = obj.Quiz.GetQuestion(CurrentQuestion)
Rozdział 1 – Tworzenie dynamicznych aplikacji internetowych
28
Jeśli pytanie nie zostało znalezione, procedura zwraca wartość
NA
, jak to określiliśmy w poprzednim
podrozdziale.
if QuestionText = "NA" then
Oznacza to, że powinniśmy przedstawić odwiedzającym wiadomość informującą o zakończeniu quizu:
TheMessage = "Quiz: Complete"
W innym razie wyszukaliśmy odpowiednie pytanie, a odpowiedzi na nie muszą zostać znalezione przez
procedurę
GetAnswer
:
else
TheMessage = "Quiz: In Progress"
AnswerText = objQuiz.GetAnswer(CurrentQuestion)
end if
Po całym HTML rozsiane są dodatkowe linie skryptu, które wstawiają zmienne stworzone wcześniej. Na
przykład tekst pytania napisany w HTML przedstawia się następująco:
<P><B><FONT FACE="Arial,Helvetica">
<% response.write QuestionText %></B></FONT>
Odpowiedzi dla obiektu sterującego wyborem są napisane w następującej linii kodu:
<SELECT NAME="Answer" ><% response.write AnswerText %></SELECT>
A rejestr punktacji dla odwiedzającego jest napisany w HTML w następujący sposób:
<P><B><FONT FACE="Arial,Helvetica">
<% Response.Write The Message %><BR>Score
<% Response.Write NumberCorrect %> out of
<% Response.Write QuestionsTaken %></B></FONT>
Tak więc ASP realizuje naprawdę ważne zadania!
Współpraca z serwerem internetowym
Wszystkie poprzednie kody ściśle współpracują z serwerem internetowym. Serwer czeka na żądania dostępu od
przeglądarki. Serwer wyszukuje żądaną stronę. Zależnie od typu strony, serwer internetowy sprawdzi również
kod ASP. Jeśli taki kod znajduje się na stronie, serwer go przetworzy i połączy się z każdym składnikiem,
którego kod ASP potrzebuje. Kiedy przetwarzanie zostaje zakończone, serwer internetowy wyśle HTML do
przeglądarki.
W naszym przykładzie korzystaliśmy z internetowego serwera informacyjnego (IIS) Microsoftu w systemie
operacyjnym Windows NT. Kiedy ktoś w Internecie lub naszym Intranecie żąda dostępu do pliku quiz.asp,
serwer IIS wyszukuje tą stronę. IIS zauważa, że strona ma rozszerzenie .asp. W ten sposób jest informowany o
tym, że dana strona jest wykonana w technologii ASP i należy przetworzyć jej kod. Serwer IIS uruchamia ten
kod na naszej stronie quizu. Tworzy kopie klasy o nazwie Quiz z serwera SampleServer. Następnie wynik w
postaci HTML wysyła do tej przeglądarki, która żądała dostępu do strony.
W następnym rozdziale dokładniej przyjrzymy się serwerowi IIS. Dowiemy się, jak konfigurować i
wykorzystywać ten serwer z perspektywy twórcy strony.
ASP – Kompendium programisty
29
Nie tylko IIS systemu NT
Tematem głównym tej książki jest korzystanie z technologii ASP na serwerze systemu Windows NT dzięki
uruchamianiu IIS. Ale popularność ASP powoduje, że szybko wychodzi ona poza te ramy. Liczne firmy
wytwarzają narzędzia i dodatki dla innych serwerów internetowych i systemów operacyjnych, co pozwala
twórcom stron ASP pracować również poza modelem Microsoftu.
W nadchodzących latach spodziewamy się kontynuacji rozwoju technologii ASP i przejęcia zasadniczej roli w
zapewnianiu połączenia pomiędzy klientem a serwerem.
Rozdział 2.
Serwer IIS widziany z perspektywy
twórcy stron
Czym jest IIS?
Internet Information Service (IIS) firmy Microsoft jest połączeniem pomiędzy klientem a serwerem używanym
w rozwiązaniach korzystających z przeglądarek internetowych i intranetowych. W tym typie rozwiązań pojęcie
klient oznacza przeglądarkę, na przykład Microsoft Internet Explorer, Netscape Navigator czy jakąś inną.
Serwer oznacza kombinację narzędzi i aplikacji, których używamy do tworzenia zawartości strony. W
przypadku niektórych serwisów WWW zadania IIS będą ograniczały się do wysyłania statycznych bloków
HTML; gdzie indziej IIS będzie odgrywał znacznie większą rolę, ułatwiając komunikację pomiędzy mnóstwem
zasobów na twoim serwerze.
Rysunek 2.1 pokazuje kolejne kroki żądania dostępu w tym środowisku klient-serwer. Omówimy ten proces
dokładniej w rozdziale 4, teraz przyjrzyjmy się jedynie udziałowi serwera IIS. Użytkownicy wpisują w swojej
przeglądarce żądanie dostępu do strony znajdującej się na twoim serwerze. Żądanie jest przesyłane przez
Internet do twojego serwera, a następnie do IIS. IIS wyszukuje żądaną stronę, a następnie, w oparciu o nazwę
znalezionego pliku decyduje o tym, co należy z nią zrobić. Jeśli plik ma rozszerzenie oznaczające konieczność
przetworzenia go przez twój komputer, np. .asp, to IIS przetworzy kod tej strony.
Rysunek 2.1. Kolejne kroki generowania żądania przez przeglądarkę
To przetwarzanie może dotyczyć również innych składników. Jeśli kod wymaga połączenia z SQL Server w
celu wyszukania jakiejś danej, tworzona jest kopia potrzebnych składników. Kiedy kod potrzebuje jakiegoś
programu graficznego do wygenerowania wykresu, odpowiedni składnik jest uruchamiany. Kiedy kod
wywołuje jeden z twoich własnych składników, również zostanie stworzona jego kopia.
Wynik kodu i wszystkie składniki pobrane dla tej strony są wysyłane z powrotem do przeglądarki, która żądała
dostępu do strony. Następnie przeglądarka dokonuje analizy składniowej przysłanego kodu i wyświetla
zawartość strony. Jeśli strona nie ma rozszerzenia lub nazwy, która wskazywałaby na konieczność
przetworzenia jej przez IIS, jest ona po prostu wysyłana do przeglądarki bez kopii składników oraz bez
jakiegokolwiek przetworzenia.
ASP – Kompendium programisty
31
Otrzymywanie kopii IIS
Internetowy serwer informacyjny wersji 4.0 systemu Windows NT 4.0 jest dostarczany wraz z pakietem Option
Pack systemu operacyjnego. Pakiet ten możesz pobrać za darmo z witryny WWW Microsoftu. Nowe kopie płyt
CD z Windowsem NT również zawierają serwer IIS 4.0, możesz więc już mieć IIS uruchomiony na twoim
serwerze — będziesz bowiem potrzebował przynajmniej wersji 4.0. Poprzednie wersje nie pozwalały na
wykorzystanie wszystkich narzędzi i technik przedstawionych w tej książce. To, czy posiadasz zainstalowany
Pakiet opcji Windowsa NT 4.0, możesz sprawdzić przeglądając odpowiedni folder, co pokazano na rysunku
2.2.
Rysunek 2.2. Folder Pakietu opcji Windows NT 4.0
Instrukcje dotyczące pełnej instalacji IIS również znajdują się na stronie internetowej Microsoftu. Dalsza część
tego rozdziału dotyczy konfiguracji IIS z perspektywy twórcy stron. Nauczysz się pracy z Konsolą zarządzania
Microsoftu, konfiguracji usługi WWW, dodawania kolejnych witryn, współpracy z aplikacjami ASP,
stosowania i konfigurowania usługi FTP oraz monitorowania sprawności twojego internetowego serwera
informacyjnego.
Konsola zarządzania Microsoftu
Konsola zarządzania Microsoftu (MMC — Microsoft Management Console) jest narzędziem używanym do
konfiguracji IIS. MMC jest nowym elementem Windowsa NT używanym również podczas konfiguracji wielu
innych zadań administracyjnych w środowisku NT. Narzędzie to działa przy użyciu modułów dodatkowych dla
każdej aplikacji, która wykorzystuje konsolę MMC.
MMC stanowi szkielet do konfiguracji usług. Produkt wymagający od administratora użycia MMC podczas
konfiguracji, dostarcza modułu dodatkowego do MMC. Moduł dodatkowy (ang. snap-in) prezentuje
hierarchiczny widok obiektów programu usługowego wraz z działaniami, które można podjąć dla każdego z
nich.
Aby wywołać konsolę MMC dla IIS, wybierz Menedżera usług internetowych z IIS firmy Microsoft
pokazanego na rysunku 2.2, a wtedy zobaczysz konsolę zarządzania pokazaną na rysunku 2.3.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
32
Rysunek 2.3. Konsola zarządzania MMC z modułem dodatkowym IIS w użyciu
Po lewej stronie znajduje się moduł dodatkowy IIS prezentujący listę hierarchiczną obiektów. Rozwijania i
zwijania listy dokonujesz podobnie jak w oknie Eksploratora Windows, przez kliknięcie znaków plus lub
minus. Kiedy klikniesz jeden z obiektów po lewej stronie okna, po prawej ukażą się wszystkie znajdujące się w
nim pozycje.
Każdy obiekt może zawierać działania (akcje), które podejmuje się dla tego obiektu. Możesz przeglądnąć listę
działań dla obiektu wybierając go i klikając przycisk Działanie (Action) znajdujący się w pasku narzędziowym,
co pokazano na rysunku 2.4.
Rysunek 2.4. Menu Działanie w konsoli MMC
ASP – Kompendium programisty
33
Każdy obiekt posiada również Właściwości (Properties), które są atrybutami obiektu. Aby przejrzeć
właściwości obiektu, kliknij obiekt prawym przyciskiem myszy i wybierz Właściwości (Properties). Przeglądu
właściwości możesz dokonać również klikając przycisk Działanie (Action) i wybierając Właściwości
(Properties) lub naciskając ikonę Właściwości (Properties) w pasku narzędziowym.
Moduł dodatkowy w pasku narzędziowym zapewnia również realizację innych funkcji, które nie odnoszą się do
określonego obiektu. Na przykład możesz przejrzeć zawartość Monitora wydajności lub Programu przeglądu
zdarzeń, wybierając odpowiednią ikonę na pasku narzędziowym.
Właściwości usług WWW
Internetowy serwer informacyjny zawiera w sobie między innymi usługę WWW. Ta usługa ma właściwości,
które możesz modyfikować wpływając na sposób jej konfiguracji. Usługa ta zawiera wiele właściwości, które
są również właściwościami danej witryny WWW. Kiedy tworzysz nową witrynę WWW, właściwości użyte
przy jej tworzeniu są dziedziczone przez usługę WWW, tak więc konfiguracja usługi już na samym początku
oszczędzi ci mnóstwa czasu i pracy, jeśli na twoim serwerze znajduje się wiele witryn WWW.
Aby otworzyć okno właściwości Usługi WWW w konsoli MMC, kliknij prawym przyciskiem myszy nazwę
komputera zawierającego tą usługę, którą chcesz skonfigurować, a następnie wybierz Właściwości (Properties).
Zobaczysz okno dialogowe pokazane na rysunku 2.5.
Rysunek 2.5. Dialog wyboru Właściwości głównych
Zwróć uwagę na pole wyboru Umożliwiaj dławienie przepustowości (Enable Bandwidth Throttling). Jeśli
zaznaczysz to pole, udostępnione zostanie pole tekstowe znajdujące się poniżej. Możesz w nim określić wartość
przepustowości sieci, którą chcesz wykorzystać dla usługi. Ta wartość jest wartością maksymalną, a nie
zarezerwowanym poziomem przepustowości — oznacza to, że niezależnie od dostępnego aktualnie pasma
przepustowości, twoja usługa może zająć maksymalnie taką jej wartość, jaką określono w polu tekstowym.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
34
Właściwości witryny WWW
W polu Właściwości główne (Master Properties) wybierz Usługę WWW i kliknij przycisk Edytuj (Edit). Teraz
powinieneś ujrzeć okno dialogowe właściwości głównych dla Usługi WWW, jak to pokazano na rysunku 2.6.
Rysunek 2.6. Właściwości Usługi WWW
Upewnij się, czy poruszasz się po zakładce o nazwie Witryna WWW (Web Site). Pierwszą rzeczą, jaką możesz
tam wprowadzić jest opis usługi. Nie ma on wpływu na funkcjonowanie usługi, a służy jedynie twojej własnej
identyfikacji. W samym środku okna właściwości możesz skonfigurować połączenia. Tutaj możesz zezwolić na
równoczesne połączenie z twoim serwerem IIS nieograniczonej liczby odwiedzających lub możesz ją
ograniczyć. Możesz również określić Czas rozłączenia (Connection Timeout). Wartość ta określa czas (w
sekundach), przez który użytkownik może pozostawać nieaktywny przed przerwaniem połączenia z twoją
usługą WWW.
W dolnej części okna właściwości możesz zdecydować, czy chcesz umożliwić rejestrację, a jeśli tak, to jaki ma
być jej typ. Rejestracja w Usłudze WWW pozwala na śledzenie poczynań użytkownika na twojej witrynie.
Jeśli opcja rejestracji jest zaznaczona, każde żądanie dostępu od serwera WWW jest odnotowywane jako
kolejna pozycja w bazie danych lub pliku tekstowym. Wprowadzane zapisy mogą zawierać datę i czas dostępu,
adres IP komputera wysyłającego żądanie, plik będący obiektem zainteresowania i wiele więcej. Posiadasz
cztery możliwości wyboru formatu dziennika zdarzeń: format pliku dziennika serwera IIS Microsoftu, wspólny
format NCSA, rozszerzony format W3C oraz format dziennika ODBC.
Format pliku dziennika zdarzeń serwera IIS Microsoftu jest specyficznym formatem używanym jedynie przez
IIS. Plik dziennika jest tekstowym plikiem ASCII. Kiedy klikniesz właściwości pliku tego typu, możesz wybrać
jego lokalizację i określić częstość generowania nowego pliku.
Wspólny format pliku dziennika NCSA jest spotykany na serwerach internetowych, które nie należą do świata
Microsoftu. Możesz potrzebować tego typu formatu podczas korzystania z niezależnego narzędzia analizy pliku
dziennika.
Rozszerzony format pliku dziennika zdarzeń W3C jest podobny do poprzedniego formatu NCSA, ale posiada
dodatkowe pola wykorzystywane podczas śledzenia. Możesz również wybrać, w których polach chcesz
gromadzić informacje, a w których nie. Jeśli naciśniesz przycisk Właściwości (Properties) dla tego typu
ASP – Kompendium programisty
35
dziennika, ujrzysz okno Rozszerzonych właściwości rejestracji (Extended Logging Properties), pokazane na
rysunku 2.7.
Rysunek 2.7. Okno dialogowe Rozszerzonych właściwości rejestracji
Klikając zakładkę Rozszerzone właściwości (Extended Properties) zobaczysz różne pola z nazwami zdarzeń,
które możesz obserwować. Pole Nazwa użytkownika (User Name) jest prezentowane tylko wtedy, gdy dana
osoba aktualnie jest zarejestrowana na twoim serwerze. Jeśli stroną odwiedzoną przez użytkownika na twojej
witrynie była http://www.somewhere.com/search.asp?query=VB, adresem URL byłaby tutaj część
www.somewhere.com/search.asp, a query=VB — polem zapytania URI. Pole Agent użytkownika (User Agent)
zawiera informacje o przeglądarce, która wystosowała żądanie dostępu. Pole Odsyłacz (Referrer) zawiera
nazwę strony, którą poprzednio odwiedził użytkownik, jeśli posiadała ona łącze ze stroną aktualnie
odwiedzaną, z którego skorzystał użytkownik oraz jeśli przeglądarka obsługuje to pole. Jeśli żądany element
strony to grafika, wtedy pole odsyłacza będzie obejmowało nazwę strony, na której ta grafika się znajduje.
Czwartym typem rejestracji jest rejestracja ODBC, która najbardziej obciąża zasoby, ale daje ci wspaniałe
możliwości analizy. Podczas rejestracji ODBC każde żądanie dostępu do twojego serwera jest odnotowywane
w bazie danych. Korzystasz z właściwości dla tego typu rejestracji w celu określenia nazwy DSN bazy danej,
której będziesz używał. Musisz najpierw stworzyć tabelę, w której będą umieszczane zapisy żądań. Tabela ta
musi być określonego formatu, jak to opisano dla SQL Server w tabeli 2.1.
Tabela 2.1. Definicje pól tabeli rejestracji ODBC
Nazwa pola
Wartość
ClientHost varchar(255)
Username varchar(255)
LogTime datetime
Service varchar(255)
Machine varchar(255)
ServerIP varchar(50)
ProcessingTime int
BytesRecvd int
BytesSent int
ServerStatus int
Win32Status int
Operation
varchar(255)
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
36
Target varchar(255)
Parameters varchar(255)
Po stworzeniu tabeli, będziesz musiał określić nazwę DSN poprzez Administratora źródeł danych ODBC, do
którego następnie stworzysz odniesienie w oknie dialogowym rejestracji ODBC. Zobacz rozdział 13, w którym
znajdziesz dodatkowe informacje na temat tworzenia nazw DSN.
Przypis
Ponieważ rejestracja wymaga się zapisywania żądań do pliku lub bazy danych, korzysta się z zasobów. Jeśli nie używasz
rejestracji, zasoby te możesz wyłączyć.
Właściwości związane z wydajnością
Wybierz zakładkę Wydajność (Performance) w oknie Właściwości usługi WWW (WWW Service Properties), a
zobaczysz okno przedstawione na rysunku 2.8.
Rysunek 2.8. Właściwości wydajności usługi WWW
Dostrajanie wydajności (Performance Tunning) określa szacunkową liczbę połączeń w ciągu dnia. Nie musisz
ustalać maksymalnego poziomu przewidywanych połączeń, jeśli nie jest ich zbyt wiele, ponieważ wtedy nie
wykorzystasz odpowiednio twoich zasobów.
Zauważ, że pole wyboru Umożliwiaj dławienie przepustowości (Enable Bandwidth Throttling) jest niedostępne.
Ta właściwość może być ustawiona jedynie dla konkretnej witryny WWW. Omówimy tą właściwość później,
w podrozdziale „Właściwości witryny WWW”.
Kiedy zaznaczone jest pole Umożliwiaj sprawdzenie aktywności HTTP (HTTP Keep-Alive Enable),
przeglądarka może podtrzymywać połączenie przez kolejne żądania dostępu do strony zamiast zestawiać
połączenie za każdym razem, kiedy pojawia się nowe żądanie dostępu. To pole jest zaznaczone domyślnie.
Właściwości filtrów ISAPI
Jedną z najbardziej zaawansowanych funkcji IIS jest tworzenie filtrów ISAPI (ISAPI Filters), które pozwalają
na podjęcie własnych, dostowanych do twoich potrzeb działań podczas wystąpienia niektórych zdarzeń
ASP – Kompendium programisty
37
związanych z IIS. Zamiast zwykłego przetworzenia zdarzenia przez serwer IIS, możesz wybrać inny program,
który zajmie się tym zdarzeniem. Takie programy często napisane są w Visual C++ i również często
umożliwiają dostosowanie procesu rejestracji. Jeśli więc nie odpowiadają ci formaty rejestracji omówione we
wcześniejszym podrozdziale, możesz stworzyć swój własny.
Aby to uczynić musisz dodać filtr ISAPI w odpowiednim oknie zakładki. pokazanym na rysunku 2.9. Kliknij
przycisk Dodaj (Add) i przeglądnij pliki biblioteki. Kolejność pojawiania się tych filtrów jest znacząca,
ponieważ pierwszy znaleziony filtr zajmujący się zdarzeniem jest uruchamiany przed wszystkimi innymi.
Kiedy pliki te zostaną załadowane, pozostają w pamięci, uważaj więc, aby nie zostały nadużyte.
Rysunek 2.9. Okno dialogowe filtrów ISAPI
Właściwości katalogu macierzystego
Następnie przeanalizujmy właściwości Katalogu macierzystego (Home Directory), które pokazane zostały na
rysunku 2.10.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
38
Rysunek 2.10. Właściwości katalogu macierzystego usługi WWW
Zauważ, że niektóre punkty okna są niedostępne, ponieważ nie mają one zastosowania w odniesieniu do usługi
WWW, są natomiast omówione nieco dalej w tym rozdziale podczas analizy właściwości witryn WWW oraz
aplikacji ASP.
Kiedy ustawiasz właściwości usługi WWW pamiętaj, że tworzone przez ciebie witryny WWW będą
dziedziczyć te właściwości — bądź więc ostrożny.
Uprawnienia dostępu (Access permissions) określają, co anonimowy użytkownik może zrobić z plikami. Kiedy
wybrano pole Odczyt (Read), może on jedynie przeglądać pliki. Jeśli zaznaczono kratkę Zapis (Write),
odwiedzający mogą przekazywać pliki do serwera.
Możesz zaznaczyć pole wyboru Dostęp do pliku dziennika zdarzeń (Log access), aby włączyć plik lub katalog
do pliku dziennika. Jeśli zaznaczono Przeglądanie katalogu (Directory browsing), odwiedzający mogą
zobaczyć zawartość katalogu w celu stwierdzenia, czy nie znajduje się w nim domyślna strona. Zazwyczaj nie
będziesz chciał wybrać tej opcji, ponieważ odwiedzający mogą znaleźć stronę na twojej witrynie posługując się
łączami zamiast przeglądać listę stron twojej witryny.
Jeśli zaznaczysz pole wyboru Indeksuj bieżący katalog (Index this directory), strony w witrynie lub katalogu
będą podlegały automatycznego indeksowaniu, co spowoduje stworzenie bazy danych, która pozwoli
użytkownikom przeszukać zawartość strony.
Reszta właściwości w tej zakładce zostanie omówiona w tym rozdziale nieco później.
Dokumenty
Zakładka właściwości Dokumentów (Documents) usługi WWW ukazano na rysunku 2.11.
ASP – Kompendium programisty
39
Rysunek 2.11. Zakładka właściwości dokumentów
Kiedy wpisujesz adres sieciowy taki jak http://www.something.com, faktycznie jesteś odsyłany do konkretnej
strony na witrynie, przykładowo http://www.something.com/index.html lub
http://www.something.com/default.asp. Te strony nazywane są stronami domyślnymi. Jeśli nie określisz strony,
do której chcesz się dostać, serwer zakłada, że żądasz dostępu do domyślnej strony w witrynie lub katalogu; na
wielu serwerach istnieje taka ustalona nazwa, jak index.html.
W serwerze IIS możesz określić nawet kilka nazw stron domyślnych. Robi się to przy użyciu przycisku Dodaj
(Add) w zakładce Dokumenty (Documents). Gdy tylko nazwy zostaną określone, możesz ustalić kolejność, w
której IIS powinien przeglądać strony domyślne. Na przykład ustalając kolejność taką jak na rysunku 2.11, IIS
najpierw odszuka stronę default.htm. Jeśli jej nie znajdzie, w drugiej kolejności postara się odszukać stronę
default.asp.
Jeśli zaznaczysz pole Udostępnij stopkę dokumentu (Enable document footer) i określisz nazwę strony, IIS
wstawi tą stronę na dole każdej innej wywoływanej strony. Mógłbyś użyć tej funkcji do automatycznego
dodawania informacji o prawach autorskich do zawartości wszystkich stron bez konieczności ich modyfikacji,
określając jedynie w polu stopki dokumentu nazwę strony, w której taka informacja się znajduje.
Błędy klienta
Zakładka właściwości Błędów klienta (Customer Errors) pokazana została na rysunku 2.12.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
40
Rysunek 2.12. Zakładka właściwości Błędów klienta
Kiedy próbujesz uzyskać dostęp do strony, która nie istnieje, otrzymasz wiadomość, która poinformuje cię o
tym fakcie. Większość witryn WWW wyświetla tą wiadomość o błędzie w bardzo surowym formacie,
ukazującym jedynie numer błędu i jego opis. Inne witryny natomiast prezentują bogatszą informację o błędzie,
która nie daje ci odczuć, że nagle utknąłeś nie posiadając możliwości wyjścia z sytuacji. IIS daje możliwość
powrotu do dowolnej, określonej strony, kiedy wystąpi jakiś błąd.
Na przykład zamiast prezentować odwiedzającemu sztywną wiadomość, że strona nie została odnaleziona, być
może zechcesz dać im możliwość poszukania tej strony na twojej witrynie, lub udostępnisz im kontakt, przez
który będą mogli poinformować cię o martwym łączu.
Możesz określić nazwę strony, którą chcesz wyświetlać, dokonujesz naciskając przycisk Edytuj właściwości
(Edit Properties), podświetlając najpierw ten numer błędu, przy wystąpieniu którego strona ma być
wyświetlona.
Witryny WWW w serwerze IIS
Jak widać na rysunku 2.13, na serwerze IIS możesz mieć wiele witryn WWW. Witryny na IIS są zaznaczone
ikoną, która przedstawia dłoń trzymającą glob ziemski. W poprzednim przykładzie zainstalowanych było
siedem witryn WWW: Default Web Site, Administration Web Site, NetStats2000, Travel Science,
WindowsNTExpert, NationsInstitute oraz Invitations4Less.
ASP – Kompendium programisty
41
Rysunek 2.13. Witryny WWW w serwerze IIS
Zauważ, że następna kolumna po opisie witryny nosi nazwę stanu. Ta kolumna zawiera informacje o tym, czy
dana witryna aktualnie jest uruchomiona, spauzowana lub zatrzymana. Witryna uruchomiona jest osiągalna dla
obecnych i nowych połączeń; spauzowaną mogą obejrzeć tylko ci, którzy już są połączeni; zatrzymana witryna
jest wyłączona i niedostępna dla żadnych połączeń.
Aby uruchomić, zatrzymać bądź spauzować witrynę WWW, kliknij prawym przyciskiem myszy witrynę w
prawej połowie konsoli MMC, a następnie wybierz Uruchom (Start), Zatrzymaj (Stop) bądź Przerwij (Pause),
jak pokazano na rysunku 2.14. Tego samego dokonać można w menu Działanie (Action) lub w pasku
narzędziowym, wybierając odpowiednią ikonę.
Rysunek 2.14. Uruchamianie, zatrzymywanie i pauzowanie witryny WWW
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
42
Dodawanie witryny WWW
Możesz dodać witrynę WWW do serwera IIS przy użyciu Kreatora nowych witryn WWW. Dostęp do kreatora
uzyskuje się klikając prawym przyciskiem myszy ten komputer z listy, na którym chcesz umieścić witrynę, a
następnie wybierając pozycję Nowy (New) i Witryna WWW (Web Site), tak jak pokazano na rysunku 2.15.
Rysunek 2.15. Wybór Kreatora nowych witryn WWW
Kreator przeprowadzi cię przez proces dodawania nowej strony do serwera IIS. Pierwszym krokiem będzie
wpisanie nazwy witryny (Rysunek 2.16). Ta nazwa będzie służyła identyfikacji witryny. W drugim kroku
dokonasz konfiguracji adresu IP oraz numeru portu dla tej witryny WWW (Rysunek 2.17).
Rysunek 2.16. Pierwszy krok Kreatora nowych witryn WWW
ASP – Kompendium programisty
43
Rysunek 2.17. Drugi krok Kreatora nowych witryn WWW
Po pierwsze należy wybrać adres IP dla twojego serwera. Jeśli serwer posiada pojedynczy adres IP, możesz
jego wartość wybrać z listy. Jeśli serwer posiada więcej niż jeden adres IP, będziesz musiał wiedzieć, pod
którym z nich zarejestrowana jest twoja nazwa domeny. Jeśli tego nie wiesz, skontaktuj się z twoim dostawcą
Internetu bądź administratorem sieci w celu zasięgnięcia takich informacji.
Jak się przekonasz później, jedną z najbardziej znaczących zmian dokonanych w IIS wersji 4 jest możliwość
umieszczenia wielu witryn WWW pod jednym adresem IP — tak więc rzeczywiście będziesz potrzebował
tylko jednego adresu IP.
Numery portów powinny być pozostawione bez zmian. Znajdują się tam domyślne wartości, które wysyła
przeglądarka. Jeśli wpiszesz inne numery portów, odwiedzający witrynę będą musieli znać te wartości, aby
uzyskać do niej dostęp. Jeśli przykładowo nie zmienisz numeru portu TCP, goście mogliby odwiedzać stronę
http://www.somewhere.com. Jeśli zmienisz ten numer na 9269, to goście będą musieli dodawać ten numer do
adresu. Będzie on wyglądał następująco: http://www.somewhere.com:9269.
Zazwyczaj nie dokonuje się zmiany numeru, ponieważ byłoby to kłopotliwe dla twoich gości, którzy rzadko
wprowadzaliby ten numer. Jest to jednak technika pozwalająca na zróżnicowanie sposobów dostępu do serwera
sieciowego bez konieczności posiadania dodatkowej domeny. W ten sposób można na przykład administrować
serwerem IIS zdalnie poprzez sieć WWW. Robi się to przy użyciu zwykłej nazwy domeny uzupełnionej
odpowiednim numerem portu.
W trzecim kroku kreatora określasz fizyczne położenie plików witryny na twoim serwerze, co pokazano na
rysunku 2.18.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
44
Rysunek 2.18. Trzeci krok Kreatora nowych witryn WWW
Naciśnij przycisk Przeglądaj (Browse) aby wybrać katalog, który zawiera najwyższy poziom witryny WWW.
Wszystkie pliki witryny muszą być umieszczone w tym katalogu i jego podkatalogach, chyba że stworzysz
katalog wirtualny, omówiony dalej w tym rozdziale. Katalogiem najwyższego poziomu może być każdy
katalog na twoim serwerze. Jeśli zaznaczysz pole Zezwól na dostęp anonimowy (Allow anonymous access),
każdy gość będzie mógł dostać się do plików tej witryny; w innym wypadku gość będzie musiał posiadać
konieczne uprawnienia dostępu do tego katalogu.
Przypis
Możesz modyfikować wartości ustawione podczas pracy kreatora również później, przeglądając właściwości danej witryny.
W ostatnim kroku kreatora dokonujesz wyboru uprawnień dostępu do witryny WWW. (Rysunek 2.19). Jeśli
zaznaczysz pole Zezwól na odczyt (Allow Read Access), odwiedzający będą mogli przeglądać zawartość
witryny. Kiedy zaznaczysz pole Zezwól na dostęp do skryptu (Allow Script Access), wtedy skrypty takie jak
ASP mogą być uruchamiane na tej witrynie. Zauważ jednak, że możesz umieścić twoje skrypty w jednym
folderze, a następnie zezwolić na ich uruchamianie jedynie w tym folderze, nie na całej stronie.
ASP – Kompendium programisty
45
Rysunek 2.19. Czwarty krok Kreatora nowych witryn WWW
Zaznaczenie pola Zezwól na uruchamianie (Allow Execute Access) umożliwi aktywację plików
wykonywalnych poprzez witrynę WWW. To pole nie jest zaznaczane zbyt często, ponieważ możesz nie chcieć,
aby twoi goście uruchamiali aplikacje przez Internet.
Jeśli zaznaczysz pole Zezwól na zapis (Allow Write Access), odwiedzający będą mogli przekazywać pliki do
witryny. Zaznaczenie pola wyboru Zezwól na przeglądanie katalogu (Allow Directory Browsing) umożliwi
gościom zobaczenie listy nazw wszystkich plików w każdym z katalogów witryny WWW.
Kiedy klikniesz przycisk Zakończ (Finish) strona, którą utworzyłeś, jest dodawana do serwera IIS i powinna
być widoczna w oknie konsoli MMC. Zauważ jednak, że po dodaniu witryny jest ona wyłączona. Będziesz
musiał ją uaktywnić klikając jej ikonę prawym przyciskiem myszy i wybierając Uruchom (Start). Po tej
ostatniej operacji, twoja witryna powinna być już dostępna.
Właściwości witryny WWW
Wiele właściwości witryny WWW jest dziedziczonych przez właściwości, które ustawiłeś w usłudze WWW
opisanej wcześniej. Jeśli zmodyfikujesz je na poziomie witryny, wtedy właściwości witryny zastąpią
właściwości dziedziczone.
W tym podrozdziale dokonamy przeglądu niektórych właściwości witryn WWW, a część nie podanych tutaj
informacji znajdziesz nieco wcześniej.
Wiele witryn pod jednym adresem IP
Nową funkcją serwera IIS wersji 4.0 jest zdolność odwzorowywania więcej niż jednej witryny od jednym
adresem IP. Aby to zrealizować, należy wykonać czynności przedstawione poniżej dla wszystkich witryn
umiejscowionych pod jednym adresem IP. Kliknij prawym przyciskiem myszy witrynę w oknie konsoli MMC i
wybierz Właściwości (Properties). Wybierz zakładkę Witryna WWW (Web Site), a wtedy pokaże się
odpowiedni arkusz przedstawiony na rysunku 2.20.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
46
Rysunek 2.20. Właściwości witryny WWW
Teraz naciśnij przycisk Zaawansowane (Advanced). Zobaczysz okno dialogowe, takie jak na rysunku 2.21.
Zauważ, że zapis znajdujący się pod hasłem Wielorakie tożsamości dla witryny WWW (Multiple identities for
this Web Site) wyszczególnia adres IP oraz numer portu, nie zawiera natomiast Nazwy nagłówka komputera
macierzystego (Host Header Name), która jest nazwą domeny tej witryny. W to pole musimy wpisać
odpowiednią wartość. Naciśnij Przycisk Edytuj (Edit) w celu wyświetlenia tego zapisu, a wtedy zobaczysz
kolejne okno dialogowe pokazane na rysunku 2.22.
ASP – Kompendium programisty
47
Rysunek 2.21. Zaawansowane właściwości witryny WWW
Rysunek 2.22. Okno dialogowe zaawansowanej identyfikacji witryny WWW
Wprowadź nazwę domeny w pole tekstowe Nazwy nagłówka komputera macierzystego (Host Header Name) i
naciśnij OK. Teraz kiedy serwer IIS otrzyma żądanie dostępu do tej domeny, skieruje żądanie do właściwej
witryny, pomimo że wiele witryn WWW jest umieszczonych pod jednym adresem IP.
Zakładka właściwości witryny WWW
Zwróć uwagę na inne właściwości przedstawione w oknie na rysunku 2.20. Możesz zmodyfikować nazwę
witryny WWW, której używasz do jej identyfikacji.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
48
Możesz również określić maksymalną liczbę połączeń z witryną w danym czasie. Jest to użyteczne w
scenariuszu wielorakich domen, w którym możesz pobierać opłaty za umieszczenie witryny WWW na
podstawie maksymalnej ilości dopuszczalnych połączeń.
Możesz również wybrać sposób rejestrowania żądań witryny. Pamiętaj o tym, że domyślnie ustawiana jest tutaj
ta wartość, którą wprowadziłeś we właściwościach usługi WWW.
Właściwości katalogu macierzystego
Teraz wybierz zakładkę Katalog macierzysty (Home Directory), jak to pokazano na rysunku 2.23. Pierwszym
ustawieniem, jakiego możesz dokonać tutaj, jest położenie plików danej witryny. Zależnie od tego, na co się
zdecydujesz, tak zmieni się część zakładki poniżej.
Rysunek 2.23. Właściwości katalogu macierzystego
Jeśli zdecydujesz się na umieszczenie witryny na tym komputerze, na którym aktualnie pracujesz, będziesz
mógł wybrać lokalną ścieżkę oraz dowolną z poniżej wyszczególnionych właściwości. Jeśli wybierzesz katalog
współdzielony, zostaniesz zapytany o podanie nazwy serwera oraz folderu współdzielonego w postaci
\\[serwer]\[udział]
.
Możesz również wybrać readresowanie (redirection), co spowoduje, że podczas próby dostępu odwiedzającego
do twojej witryny, zostanie on odesłany do jakiegoś innego miejsca w Internecie. Kiedy zdecydujesz się na tą
opcję, zostaniesz poproszony o podanie adresu URL, do którego nastąpi przekierowanie. Nie możesz wtedy
jednak ustawić innych właściwości w tej zakładce.
Ustawienia aplikacji (Applications Settings) zostały omówione w podrozdziale „Właściwości aplikacji” w
dalszej części tego rozdziału.
Eksploracja witryny
Teraz, kiedy już dodałeś i skonfigurowałeś witrynę WWW, możesz przeglądać zawartość strony w podobny
sposób, jak robi się to przy użyciu Eksploratora Windows. Możesz rozwijać listę katalogów, jak to pokazano na
rysunku 2.24.
ASP – Kompendium programisty
49
Rysunek 2.24. Eksploracja witryny WWW
Katalogi wirtualne
Możesz przejrzeć zawartość każdego folderu twojej witryny. Te pliki i foldery odpowiadają plikom i folderom
logicznym, które znajdują się w strukturze katalogu macierzystego tej witryny. Możesz również stworzyć
katalogi wirtualne.
Katalogi wirtualne są folderami, które znajdują się poza fizyczną strukturą katalogów witryny WWW, ale
chcesz je włączyć do witryny. Przypuśćmy na przykład, że masz witrynę zawierającą podkatalogi html i script.
Adresujesz te katalogi poprzez określenie nazwy domeny, po której następuje nazwa odpowiedniego
podkatalogu: http://www.somewhere.com/html/welcome.html. Posiadasz jednak na serwerze inny katalog
zawierający pliki video, które chcesz udostępnić poprzez witrynę WWW w katalogu o nazwie avi. W bieżącej
konfiguracji pliki te nie są dostępne dla twojej witryny, ponieważ znajdują się poza jej fizyczną strukturą
katalogów. Możesz jednak stworzyć katalog wirtualny wskazujący katalog avi, który w ten sposób zostanie
włączony w logiczną strukturę twojej witryny.
Aby stworzyć katalog wirtualny, kliknij prawym przyciskiem myszy ikonę witryny bądź folderu, gdzie katalog
wirtualny ma być dodany i wybierz Nowy (New), a następnie Katalog wirtualny (Virtual Directory), jak to
pokazano na rysunku 2.25. W ten sposób uruchomisz Kreatora nowego katalogu wirtualnego (New Virtual
Directory Wizard). Jego pierwsze okno prezentuje rysunek 2.26.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
50
Rysunek 2.25. Dodawanie katalogu wirtualnego
Rysunek 2.26. Kreator nowego katalogu wirtualnego — krok pierwszy
Pierwszą rzeczą, jaką należy wprowadzić jest nazwa dla katalogu wirtualnego, która będzie widoczna na twojej
witrynie WWW. Innymi słowy, jeśli katalog fizyczny nosi nazwę PublicVideos, ale ty chcesz aby nazwa ta
podczas dostępu do strony brzmiała Videos, taką właśnie nazwę wpiszesz w polu tekstowym pierwszego okna
kreatora.
W drugim kroku kreatora określisz fizyczne położenie katalogu wirtualnego (Rysunek 2.27). Naciśnij przycisk
Przeglądaj (Browse) i ustal lokalizację katalogu fizycznego.
ASP – Kompendium programisty
51
Rysunek 2.27. Kreator nowego katalogu wirtualnego — krok drugi
W kroku trzecim (Rysunek 2.28) możesz określić uprawnienia dostępu do katalogu wirtualnego. Następnie
naciśnij przycisk Zakończ (Finish). Od tej pory nowy katalog wirtualny, fizycznie umiejscowiony poza twoją
witryną, staje się dostępny dla odwiedzających.
Rysunek 2.28. Kreator nowego katalogu wirtualnego — krok trzeci
Właściwości folderu i pliku
Dowiedziałeś się już, w jaki sposób ustawiać właściwości dla samej usługi WWW. Wiesz również, jak to samo
zrobić z poszczególnymi witrynami, których właściwości są dziedziczone z usługi WWW. Teraz dowiemy się
jak ustawiać właściwości konkretnych folderów i plików witryny. Dostęp do właściwości uzyskuje się klikając
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
52
dany folder prawym przyciskiem i wybierając Właściwości (Properties). Powinieneś wtedy ujrzeć okno
dialogowe pokazane na rysunku 2.29.
Rysunek 2.29. Właściwości folderu
Właściwości folderu są dziedziczone przez właściwości witryny WWW, dlatego zwykle nie trzeba ich
ustawiać. Dzięki nim jednak masz możliwość precyzyjnej konfiguracji twojej witryny. Możesz na przykład
przeznaczyć jeden folder na przechowywanie skryptów. W takim wypadku ustalisz dla niego uprawnienia
skryptu. Jeśli chcesz rejestrować dostęp do pojedynczego folderu, zrobisz to poprzez Właściwości folderu.
Każdy plik folderu również posiada swoje właściwości. Są one pokazane na rysunku 2.30. Właściwości pliku
są dziedziczone z właściwości folderu, tak więc hierarchia dziedziczenia przedstawia się następująco: usługa
WWW, witryna WWW, folder, a na końcu plik.
Aplikacje ASP
Zmienne trwałe i zakresowe
Aplikacja ASP to wymyślna nazwa, która określa po prostu grupę stron ASP ulokowanych w jednej strukturze
katalogu, z którymi pracować możesz podobnie jak z aplikacją.
Sama strona ASP jest jednostką oddzielną, podobną do wyspy, która nie dzieli się informacjami zapamiętanymi
w zmiennych z innymi stronami ASP. Strona będąca częścią aplikacji ASP może współużytkować i
przetrzymywać zmienne trwałe poza pojedynczą stroną oraz zapamiętywać dane zakresowe poza nią. Przez
zmienne trwałe rozumiemy takie zmienne, które pozostają dostępne po wyłączeniu strony. Zmienne zakresowe
to takie zmienne, które są widoczne również poza tą stroną, która z nich korzysta. Tak więc przy użyciu
aplikacji ASP możesz stworzyć zmienne, które będą istniały po opuszczeniu strony przez odwiedzającego oraz
zmienne widoczne dla innych stron aplikacji.
Załóżmy, że masz dobrze zabezpieczoną stronę i chcesz, aby odwiedzający logowali się na witrynie, zanim
będą mogli zobaczyć którąkolwiek ze stron. Mają logować się na pojedynczej stronie, a ty musisz być
powiadomiony przez inne strony o fakcie logowania. Zrealizujesz to przy użyciu aplikacji ASP, ponieważ
ASP – Kompendium programisty
53
możesz w niej stworzyć zmienną
UserID
zapamiętującą numer identyfikacyjny użytkownika. Jeśli numer
znajdzie się w zmiennej, będziesz wiedział jaki użytkownik logował się na witrynie.
W rozdziale pierwszym przyjrzeliśmy się stronie quizu. Strona pozwalała gościom odpowiadać na kolejne
pytania, a my otrzymywaliśmy ich wyniki. Było to realizowane przez pojedynczą stronę. Jeśli chcielibyśmy
rozwinąć to narzędzie, potrzebowalibyśmy dodatkowych stron w celu ewentualnego formatowania pytania. Być
może pozwolilibyśmy przeglądać odpowiedzi na innej stronie. Strony musiałyby wtedy przekazywać sobie
informacje dotyczące testu, jego wyników itd. Aby to osiągnąć, potrzebujemy aplikacji ASP.
Może chcesz stworzyć program usługowy, który pozwalałby na śledzenie poczynań odwiedzającego witrynę,
jego przejścia pomiędzy stronami. Będziesz wtedy musiał w jakiś sposób identyfikować danego
odwiedzającego, aby odpowiedni zapis umieścić w jakiejś tabeli wykorzystania witryny. Taka zmienna
identyfikacji, która mogłaby się nazywać
ConnectionID
, byłaby przekazywana pomiędzy stronami. Aplikacja
ASP pozwoli na realizację tego typu zadania.
Zdarzenia
Zdarzeniami nazywa się kody, które stanowią odpowiedź na podejmowane na stronie działania. Na przykład, w
Visual Basic kliknięciu przycisku odpowiada zdarzenie Click; kiedy użytkownik nie wypełni pola tekstowego,
uruchamiane jest zdarzenie Lost Focus. Konkretne działanie użytkownika pociąga za sobą wystąpienie
zdarzenia.
Możesz napisać kod, który zostanie uruchomiony po wywołaniu zdarzenia. Kiedy odwiedzający kliknie
przycisk, być może zamknie się formularz lub kiedy zostawi puste pole tekstowe, możliwe, że wtedy zostanie
uruchomiony kod zatwierdzający jego wejście.
Jak się dowiemy szerzej z rozdziału ósmego przy okazji omawiania pliku global.asa, używając aplikacji ASP
dysponujesz czterema zdarzeniami, po wystąpieniu których możesz uruchomić napisany przez siebie kod.
Możesz napisać kod dla zdarzenia Application_OnStart. Kod tej procedury działa za każdym razem, kiedy
twoja aplikacja ASP jest uruchamiana. Uruchomienie aplikacji następuje w chwili, kiedy pierwszy
odwiedzający uzyskuje dostęp do strony ASP.
Możesz stworzyć kod dla zdarzenia Session_OnStart. To zdarzenie działa, kiedy odwiedzający przegląda
pierwszą stronę ASP. Różni się ono tym od Application_OnStart, że jest uruchamiane dla wszystkich gości
strony, a nie jedynie dla pierwszego z nich.
Kolejnym zdarzeniem jest Session_OnEnd. Uruchamiane jest w chwili, gdy połączenie odwiedzającego z twoją
witryną kończy się. Zdarza się to szczególnie wtedy, gdy czas sesji odwiedzającego upływa lub kiedy ustawiłeś
koniec sesji programowo.
Ostatnim zdarzeniem dostępnym w aplikacji ASP to zdarzenie Application_OnEnd. Kod procedury
uruchamiany jest w chwili, kiedy praca witryny WWW, której część stanowi aplikacja ASP, zostaje
zatrzymana.
Tworzenie aplikacji ASP
Teraz, kiedy już wiesz po co tworzy się aplikacje ASP, przyjrzyjmy się jak zrealizować to zadanie przy użyciu
serwera IIS. Jak wspomniano wcześniej, aplikacje ASP składają się z katalogów oraz wszystkich znajdujących
się w nich podkatalogów. Katalog może być częścią jednej tylko aplikacji ASP, tak więc jeśli katalog główny
jest składnikiem innej aplikacji, a ty tworzysz nową aplikację przy użyciu tego katalogu, staje się on jej częścią.
Używając konsoli MMC, kliknij prawym przyciskiem myszy katalog zawierający pliki, które mają stanowić
aplikację ASP i wybierz Właściwości (Properties). Upewnij się, czy poruszasz się po zakładce Katalogi
(Directories), powinna ona wyglądać tak jak ta na rysunku 2.31.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
54
Rysunek 2.31. Właściwości katalogu
Obszarem, który będziemy wykorzystywać znajduje się w dolnej części okna pod nazwą Ustawienia aplikacji
(Application Settings). Kliknij przycisk Utwórz (Create), a wtedy uaktywnione zostanie pole nazwy aplikacji
(Rysunek 2.32).
Rysunek 2.32. Okno właściwości katalogu z uaktywnionym polem nazwy
ASP – Kompendium programisty
55
Wpisz nazwę twojej aplikacji ASP w polu tekstowym Nazwa (Name). Podana nazwa będzie służyła twojej
własnej identyfikacji. Po naciśnięciu OK aplikacja ASP zostaje stworzona. Zauważ, że ikona katalogu zmieniła
się z folderu na pole z małym, zielonym iksem w środku.
Aby usunąć aplikację ASP, po prostu wróć do właściwości katalogu i naciśnij przycisk Usuń (Remove).
Konfigurowanie aplikacji ASP
Zwróć uwagę na pole wyboru Uruchom w osobnej przestrzeni pamięci (proces izolowany) (Run in separate
memory space (isolated process)). Jeśli jest ono zaznaczone, twoja aplikacja ASP będzie działała poza
serwerem IIS. Kiedy więc twoja aplikacja spowoduje jakiś poważny problem i będzie musiała być zamknięta,
nie spowoduje to zawieszenia działania innych aplikacji czy samego serwera IIS. Negatywnym aspektem
zaznaczenia tego pola jest konieczność wykorzystania dodatkowych zasobów.
Aby przejrzeć inne opcje konfiguracyjne dla aplikacji, kliknij przycisk Konfiguracja (Configuration)
znajdujący się we właściwościach katalogu, a wtedy zobaczysz okno dialogowe, które prezentuje rysunek 2.33.
Rysunek 2.33. Odwzorowania aplikacji
Pierwsza zakładka zawiera Odwzorowania aplikacji (App Mappings). Te odwzorowania informują IIS o tym,
jakie programy wspierające uruchomić, kiedy strona o określonym rozszerzeniu zostaje wywoływana. Kliknij
na przykład rozszerzenie .asp znajdujące się na liście i wybierz Edytuj (Edit). Powinieneś wtedy ujrzeć okno
ustawień pokazane na rysunku 2.34.
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
56
Rysunek 2.34. Odwzorowanie rozszerzenia aplikacji
Pierwsze pole okna zawiera nazwę programu, który będzie przetwarzał stronę. W drugim polu znajduje się
rozszerzenie, które musi mieć strona, aby mogła zostać przetworzona przez określony program wykonywalny.
W trzecim polu możesz wpisać dowolną metodę HTTP, której nie chcesz uruchamiać wraz z programem
wykonywalnym. Dla ASP będziesz mógł zaznaczyć w polu wyboru, że jest to moduł skryptu. Pole wyboru
Sprawdź czy plik istnieje (Check that file exist) nie jest potrzebna przy ASP.
Przypis
Jeśli kiedykolwiek znajdziesz się w takiej sytuacji, że podczas próby wyświetlenia strony ASP ujrzysz jedynie sam kod ASP,
prawdopodobnie brak jest odpowiedniego zapisu w oknie pokazanym na rysunku 2.34. Musisz go dodać do twoich Odwzorowań
aplikacji.
Przejdź teraz do drugiej zakładki okna — Opcji aplikacji (App Options), pokazanego na rysunku 2.35.
Rysunek 2.35. Opcje aplikacji
Pierwszą rzeczą, jaką możesz zrobić w tej zakładce to uaktywnienie stanu sesji. Jak wspomniano we
wcześniejszym podrozdziale, pojęcie stanu odnosi się do możliwości zapamiętywania zmiennych, które są
ASP – Kompendium programisty
57
widoczne dla wszystkich stron poza bieżącą stroną aplikacji. Aby na to zezwolić, musisz uaktywnić stan sesji.
Wtedy będziesz mógł ustalić czas trwania sesji. Ta wartość przedstawia w minutach czas, po upłynięciu
którego sesja odwiedzającego uważana jest za zakończoną. Jeśli wartość ta będzie wynosić 20 minut, to przed
upływem tego czasu odwiedzający będzie musiał przejść do następnej strony. W przeciwnym razie wszystkie
informacje sesji zostaną utracone.
Jeśli zaznaczono pole Uaktywnij buforowanie (Enable buffering), strona ASP będzie musiała zakończyć całe
przetwarzanie przed wysłaniem wyniku w postaci HTML do przeglądarki. Zaznaczenie pola wyboru Uaktywnij
ścieżki nadrzędne (Enable parent paths) pozwala na adresowanie względne katalogu nadrzędnego. Pole
Domyślnego języka ASP (Default ASP language) określa skrypt, z którego korzysta twoja strona ASP. Pole
Czas trwania skryptu ASP (ASP Script timeout) zapamiętuje czas w sekundach, w którym strona musi wykonać
cały swój kod, inaczej nastąpi jej wyłączenie. Może tak się zdarzyć z wielu powodów: serwer może być zbyt
zajęty, ilość danych zwracanych jest zbyt duża lub kod natrafił na nie kończącą się pętlę.
Trzecia zakładka zawiera opcje usuwania błędów (Rysunek 2.36).
Rysunek 2.36. Opcje usuwania błędów aplikacji ASP
Jeśli zaznaczysz opcję Usuwanie błędów skryptu po stronie serwera (Server-Side Script Debugging), możesz
ustawić punkty kontrolne dla twojego kodu i zatrzymać jego wykonywanie, a wtedy debugger przystąpi do jego
analizy. Usuwanie błędów zostało omówione szerzej w rozdziale 12. Opcja Usuwanie błędów skryptu po
stronie klienta (Client-Side Script Debugging) nie ma w tej chwili znaczenia. Późniejsze wersje serwera IIS
mogą korzystać z tej opcji.
Kiedy w twoim kodzie pojawi się błąd, przeglądarce wysyłana jest wiadomość. Może ona zawierać dokładne
informacje obejmujące numer błędu, opis oraz linię kodu, w której wystąpił. Aby skorzystać z tej funkcji,
zaznacz pole Szczegółowa wiadomość o błędzie (Detailed error message). Drugą możliwością jest tutaj
wyświetlenie ogólnej wiadomości tekstowej.
Witryny FTP
Oprócz witryn WWW, na serwerze IIS mogą również znajdować się witryny FTP, które umożliwiają łatwe
pobieranie i przekazywanie plików serwera. Domyślna witryna FTP jest instalowana wraz z serwerem IIS. Aby
Rozdział 2 – Serwer IIS widziany z perspektywy twórcy stron
58
zainstalować nową witrynę FTP kliknij prawym przyciskiem myszy ikonę komputera, na którym ma się ona
znaleźć, a następnie wybierz Nowy (New) i Witryna FTP (FTP Site).
Konfiguracji nowej witryny FTP dokonuje się poprzez okno Właściwości (Properties), które pojawi się, kiedy
klikniesz ikonę witryny prawym przyciskiem myszy. Wygląd okna prezentuje rysunek 2.37.
Rysunek 2.37. Właściwości witryny FTP
Zauważ, że podobnie jak to było w wypadku właściwości usługi WWW, również właściwości usługi FTP są
dziedziczone przez witryny FTP. W tej pierwszej zakładce ustalasz informacje służące identyfikacji witryny.
Możesz ustalić również maksymalną liczbę połączeń, a także czas rozłączenia. Czas rozłączenia (Timeout)
określa w sekundach, kiedy nastąpi rozłączenie użytkownika, który pozostaje nieaktywny.
Tak jak w wypadku witryn WWW, możesz monitorować korzystanie z witryny FTP. Jeśli klikniesz przycisk
Bieżące sesje (Current Sessions), ujrzysz listę aktualnych użytkowników witryny. W zakładce Konta
bezpieczeństwa (Security Accounts), pokazanej na rysunku 2.38 określisz, kto będzie mógł uzyskiwać dostęp do
witryny FTP.
ASP – Kompendium programisty
59
Rysunek 2.38. Konta bezpieczeństwa FTP
Jeśli wybierzesz Dostęp anonimowy (Anonymous Access), każdy będzie mógł korzystać z twojej witryny FTP.
Prawdopodobnie zezwolisz na dostęp do witryny jedynie niektórym odwiedzającym. Możesz to zrobić w dolnej
części zakładki.
Inne właściwości witryny FTP pozwalają na określenie powitania i pożegnania, które będą widoczne dla
odwiedzających witrynę. Możesz również określić nazwę fizycznego katalogu, który będzie pełnił rolę punktu
wejścia. Ponadto możesz odrzucić bądź zaakceptować niektóre adresy IP.
Rozdział 3.
Narzędzia pracy
Przegląd aplikacji do tworzenia stron
W tym rozdziale przyjrzymy się narzędziom, z których możesz skorzystać podczas tworzenia witryn WWW,
kodu HTML, formularzy, a w szczególności stron ASP. Nasze rozważania rozpoczniemy od omówienia
najbardziej podstawowego narzędzia, które powinieneś już posiadać, Notatnika. Przekonasz się, że przy użyciu
jedynie Notatnika możesz stworzyć swoją własną stronę ASP.
Następnie zwrócimy uwagę na parę innych narzędzi, których możesz użyć do tworzenia stron WWW. Te
narzędzia, FrontPage 2000 i NetObjects Fusion, posiadają szybki i intuicyjny interfejs do budowania witryn i
stron. Przyjrzymy się również dodawaniu elementów do stron przy użyciu tych narzędzi oraz tworzeniu
formularzy.
Potem skupimy się na narzędziach używanych do tworzenia kodu stron ASP, a na samym początku będzie to
NetObjects ScriptBuilder 3.0. To narzędzie tworzenia zawiera wspaniały interfejs, który powoduje, że
tworzenie bloków kodu jest niesamowicie proste. Przyjrzymy się również Visual InterDev Microsoftu. Jeśli
jesteś zaznajomiony z jakimkolwiek produktem serii Visual Studio, przyjemnie zaskoczy cię jego podobny
układ i funkcjonalność.
Notatnik
Jeśli masz komputer z zainstalowanym systemem Windows jakiejkolwiek wersji, to już posiadasz narzędzie do
tworzenia stron ASP i pracy z nimi — to narzędzie to Notatnik.
Strony WWW i ASP są stworzone po prostu przy użyciu tekstu, dlatego jedyną rzeczą, której potrzeba do ich
tworzenia i pracy z nimi jest edytor tekstu. Notatnik lub jakikolwiek inny edytor tekstu, świetnie będzie
wspomagał tworzenie i edycję stron HTML i ASP.
Naprawdę, czasami to wszystko czego potrzebujesz. Osobiście posiadam duży wybór narzędzi do tworzenia
stron WWW, witryn oraz stron ASP, ale w dalszym ciągu od czasu do czasu używam Notatnika. Jednym z
powodów jest tutaj prostota ładowania tego edytora tekstu przy jego olbrzymich możliwościach twórczych.
Kolejnym powodem do rozważenia możliwości użycia edytora tekstu jest fakt, że jest on dostępny nawet na
mniej zaawansowanych technologicznie komputerach. Zawsze powinieneś znaleźć na nich edytor tekstu, a jeśli
istnieje możliwość połączenia z twoim serwerem internetowym, na bieżąco możesz dokonywać modyfikacji
stron.
Ponadto w przypadku prostego HTML, to bardzo ważne, aby okresowo przeglądać swój naturalny kod.
Przekonasz się, że wiele narzędzi używanych do tworzenia stron i witryn WWW dodaje liczne linie kodu
układu tabeli, które mogą być swobodnie usunięte co spowoduje, że twoja strona stanie się dużo mniejsza i
będzie się ładowała dużo szybciej.
Spójrzmy na przykład poniższego kodu HTML, który został wygenerowany przez narzędzie tworzenia witryn,
zwane NetObjects Fusion, które omówimy później:
<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 WIDTH=570>
<TR VALIGN="top" ALIGN="left">
<TD WIDTH=68 HEIGHT =7><IMG SRC="./assets/images/dot_clear.gif"
WIDTH =68 HEIGHT =1 BORDER=0></TD>
ASP – Kompendium programisty
61
<TD WIDTH=27><IMG SRC="./assets/images/dot_clear.gif" WIDTH =27
HEIGHT =1 BORDER=0></TD>
<TD WIDTH=95><IMG SRC="./assets/images/dot_clear.gif" WIDTH =95
HEIGHT =1 BORDER=0></TD>
<TD WIDTH=95><IMG SRC="./assets/images/dot_clear.gif" WIDTH =95
HEIGHT =1 BORDER=0></TD>
<TD WIDTH=95><IMG SRC="./assets/images/dot_clear.gif" WIDTH =95
HEIGHT =1 BORDER=0></TD>
<TD WIDTH=95><IMG SRC="./assets/images/dot_clear.gif" WIDTH =95
HEIGHT =1 BORDER=0></TD>
<TD WIDTH=61><IMG SRC="./assets/images/dot_clear.gif" WIDTH =61
HEIGHT =1 BORDER=0></TD>
<TD WIDTH=34><IMG SRC="./assets/images/dot_clear.gif" WIDTH =34
HEIGHT =1 BORDER=0></TD>
</TR>
<TR VALIGN="top" ALIGN="left">
<TD></TD>
<TD WIDTH=468 COLSPAN=6><P ALIGN="center"><B>
<FONT COLOR="#800000" SIZE="+2" FACE="Arial,Helvetica">
All invitations and accessories priced at a 25% discount!</B>
</FONT></P></TD>
<TD></TD>
</TR>
<TR VALIGN="top" ALIGN="left">
<TD COLSPAN=8 HEIGHT =39></TD>
</TR>
</TABLE>
Prawie identyczne wyjście można uzyskać z następującego kodu HTML:
<p ALIGN="center"><b><font SIZE="+2" FACE="Arial,Helvetica">
All invitations and accessories priced at a 25% discount!
</b></font></p>
Ten kod jest objętościowo jedynie ułamkiem tego poprzedniego, tak więc strona będzie wyświetlana znacznie
szybciej.
Jedyną rzeczą, o której należy pamiętać używając Notatnika jako edytora stron ASP jest nadanie plikowi
odpowiedniego rozszerzenia. Notatnik domyślnie przydziela rozszerzenie .txt. Kiedy więc zapisujesz plik
napisany w Notatniku, upewnij się, czy przydzieliłeś mu właściwe rozszerzenie, jak to pokazano na rysunku
3.1.
Rozdział 3 – Narzędzia pracy
62
Rysunek 3.1. Przydzielanie właściwego rozszerzenia w Notatniku
FrontPage 2000
FrontPage 2000 jest narzędziem Microsoftu, które możesz wykorzystać do tworzenia pojedynczych stron i
witryn WWW. Ponieważ FrontPage jest produktem Microsoftu, jest zaprojektowany tak, aby współpracował z
serwerem IIS, umożliwiając natychmiastową modyfikację witryny WWW; używając innych narzędzi musisz w
zasadzie załadować stronę na serwer.
Środowisko pracy
Rysunek 3.2 pokazuje środowisko, w którym strona WWW jest przeglądana. Widok pokazany na tym rysunku
jest widokiem strony, którą przejrzeć można naciskając przycisk Strona (Page) w pasku narzędziowym
znajdującym się po lewej stronie ekranu. Kiedy przycisk zostanie naciśnięty, w środku okna ukaże się panel
prezentujący zawartość bieżącego folderu. W tym przypadku katalog macierzysty FrontPage nazywa się
fpsample.
ASP – Kompendium programisty
63
Rysunek 3.2. Środowisko pracy FrontPage w czasie przeglądania strony WWW
W prawym panelu okna FrontPage prezentowana jest zawartość aktualnie wybranej strony WWW. Klikając
dowolną stronę w panelu środkowym, uaktywniamy ją w prawym panelu. W prawym panelu dostępne są trzy
rodzaje widoków strony. Pierwszy z nich, pokazany na rysunku 3.2, to widok normalny, gdzie możliwe jest
graficzne dodawanie i edycja elementów strony. Jeśli zmienisz widok na HTML, ujrzysz sam kod HTML
(Rysunek 3.3.). W widoku normalnym możesz edytować kod HTML, aby dodać skrypty lub kod ASP. Możesz
go użyć również jako narzędzia szkoleniowego, pokazującego co dzieje się ze stroną, gdy dodajesz do niej
różne elementy.
Rysunek 3.3. Widok HTML strony WWW w programie FrontPage
Rozdział 3 – Narzędzia pracy
64
Trzecim widokiem jest podgląd. Dzięki temu widokowi pokazanemu na rysunku 3.3 sprawdzisz, jak strona
będzie wyglądała w przeglądarce. Ta prosta opcja pozwala na szybki podgląd wyjściowej postaci strony.
Rysunek 3.4. Podgląd strony
Przypis
Podgląd jest uruchamiany po stronie klienta. Oznacza to, że każdy kod po stronie klienta również będzie widoczny, ale żadna z
twoich stron ASP nie zostanie przetworzona.
Kolejnym widokiem głównym (dostępnym w lewym panelu okna) jest widok Foldery (Folders), co pokazano
na rysunku 3.5. Widok ten pozwala na zarządzanie plikami i folderami twojej witryny. Ze środkowego panelu
korzystasz w celu wyszukiwania katalogów. W tym samym czasie panel prawy pokazuje zawartość wybranego
folderu. Rozszerzona informacja o każdym z nich zawierająca nazwę, tytuł, datę modyfikacji oraz komentarze,
jest prezentowana w prawym panelu. Tak więc korzystając z tego widoku w prosty sposób możesz
zlokalizować pliki, dodawać do nich zadania, przeglądać ich strukturę oraz sortować je po którymkolwiek z
pól.
ASP – Kompendium programisty
65
Rysunek 3.5. Widok Foldery w programie FrontPage
Aby dodać komentarz do pliku, kliknij jego ikonę prawym przyciskiem myszy i wybierz Właściwości
(Properties). Następnie kliknij zakładkę Skrót (Summary) i wpisz swój komentarz (Rysunek 3.6.). Komentarz
możesz dodać do każdego pliku witryny.
Rysunek 3.6. Okno dialogowe wykorzystywane w celu dodawania komentarza do pliku
Kolejny widok — Raporty (Reports) — pozwala na przejrzenie rozmaitych raportów dotyczących twojej
witryny WWW. Krótki raport domyślny jest pokazany na rysunku 3.7.
Rozdział 3 – Narzędzia pracy
66
Rysunek 3.7. Widok Raporty
Przeglądu dodatkowych raportów możesz dokonać wybierając Raporty (Reports) z menu Widok (View). Dzięki
temu wygenerujesz listę wolnych stron, starych plików, dodanych ostatnio plików, przerwanych łącz i wielu
innych. Niektóre z tych raportów można nawet skonfigurować wybierając Narzędzia (Tools), Opcje (Options),
a następnie przeglądając zakładkę Widok raportów (Reports View). Tutaj możesz określić, ile maksymalnie dni
ma mieć plik, aby był zakwalifikowany jako nowy. Tak samo zakwalifikować możesz plik jako stary, ustalając
minimalną liczbę dni. Możesz również ustalić liczbę sekund, która musi upłynąć podczas ładowania strony, aby
uznać ją za wolną.
Następnym widokiem, pokazanym na rysunku 3.8, jest Nawigacja (Navigation). Ten widok pozwala na
projektowanie logicznego układu witryny. Tutaj możesz dodawać strony do schematu poprzez przeciągnięcie
ich z listy folderów do prawego panelu. Tam strony mogą zostać połączone w układ logiczny. W widoku
nawigacji możesz usunąć dowolną stronę z witryny bez obawy o to, że plik zostanie usunięty z sieci.
ASP – Kompendium programisty
67
Rysunek 3.8. Widok Nawigacji w programie FrontPage 2000
Przycisk Hiperłącza (Hyperlinks) uruchamia kolejny graficzny widok twojej witryny WWW. Wybierając daną
stronę z listy folderów, w prawym panelu ujrzysz jej wszystkie łącza.
Ostatnim z widoków są Zadania (Tasks), co pokazano na rysunku 3.9. Prezentuje on działania, które należy
podjąć podczas tworzenia witryny WWW. Zadania przydzielane są osobom — mają swój priorytet, status, datę
i opis.
Rysunek 3.9. Widok Zadań w programie FrontPage 2000
Możesz mieć przydzielone zadanie ogólne, nie odnoszące się do żadnego szczególnego zadania z listy. Na
przykład możesz przydzielić zadanie rejestracji witryny w wyszukiwarce; być może zadaniem będzie
ukończenie schematu strony. Aby dodać zadanie ogólne, najpierw upewnij się, czy znajdujesz się w widoku
Rozdział 3 – Narzędzia pracy
68
zadań. Następnie wybierz z menu Edycja (Edit) Zadania (Tasks) i Dodaj zadanie (Add Task). Powinieneś
zobaczyć okno pokazane na rysunku 3.10.
Rysunek 3.10. Dodawanie zadania w oknie dialogowym Nowe zadanie
W oknie dialogowym Nowe zadanie (New Task) przydzielasz zadanie określonej osobie. Możesz również
ustalić priorytet zadania oraz podać jego opis. Kiedy naciśniesz przycisk OK, nowe zadanie zostanie dodane do
listy w widoku Zadania.
Możesz również przydzielić zadania plikom i folderom w witrynie WWW. Robi się to poprzez wybranie strony
z listy folderów, a następnie kliknięcie jej prawym przyciskiem myszy oraz wybranie pozycji Dodaj zadanie
(Add Task). Kolejne kroki są takie same jak przy dodawaniu zadania ogólnego.
Widok Zadania jest wykorzystywany do zarządzania. Kiedy klikniesz dowolne zadanie prawym przyciskiem,
możesz wybrać Rozpocznij zadanie (Start Task), co spowoduje, że przeniesiesz się do pliku związanego z tym
zadaniem. Możesz również oznaczyć zadanie jako zakończone klikając je prawym przyciskiem. Zadanie
zakończone ma inną ikonę, co ułatwia jego rozpoznanie spośród zadań niezakończonych.
Tworzenie sieci Web
W programie FrontPage termin sieć Web odnosi się do nazwy domeny lub podkatalogu, gdzie witryna WWW
będzie umieszczona. FrontPage dysponuje kreatorem, którego możesz użyć do stworzenia nowej sieci Web.
Aby skorzystać z kreatora wybierz menu Plik (File), Nowa (New), a następnie Sieć Web (Web). Powinieneś
ujrzeć dialog wyboru witryn, pokazany na rysunku 3.11.
ASP – Kompendium programisty
69
Rysunek 3.11. Dialog wyboru witryn
Bez względu na typ witryny, którą wybierzesz, będziesz musiał podać jej położenie. Jeśli serwer jest oddalony,
możesz być zapytany o nazwę użytkownika oraz hasło komputera NT, na którym zainstalowany został serwer
IIS. W tym miejscu będzie stworzona twoja witryna. Jeśli pracujesz z witryną i zapisujesz na bieżąco zmiany,
będą one natychmiastowo przenoszone na serwer.
Zwróć uwagę na duży wybór sieci Web. Jeśli wybierzesz pojedynczą stronę, kreator stworzy ją w jednym tylko
w jednym kroku, a niezbędne pliki zostaną umieszczone na serwerze. Inne kreatory są nieco bardziej złożone.
Weźmy na przykład kreatora prezentacji firmy. Na samym początku wybierasz strony, które chcesz włączyć do
witryny (zobacz rysunek 3.12.).
Rysunek 3.12. Wybór stron witryny prezentującej firmę
Dla każdej strony wybierasz elementy, które mają się na niej pojawić. Zaraz po tym, jak kreator wygeneruje
stronę, twój wybór zostanie uwzględniony w szablonie strony, który posiada wolne miejsce na dodatkową
zawartość.
Kreator zapyta cię również o wybór tematu, będącego ogólnym wyglądem twojej witryny, zawierającego
kombinację banerów, tła, stylu czcionki i innych elementów. FrontPage zawiera mnóstwo tematów. Możesz je
Rozdział 3 – Narzędzia pracy
70
wybierać bądź zmieniać korzystając z menu Format, a następnie zaznaczając Temat (Theme). Zobaczysz wtedy
okno dialogowe pokazane na rysunku 3.13.
Rysunek 3.13. Wybór tematu dla witryny
Temat możesz zastosować do dowolnej ilości stron twojej witryny. Możesz również modyfikować wygląd
tematu. Staraj się jednak uważnie korzystać z tych gotowych tematów. Pamiętaj, że FrontPage jest bardzo
popularny i każdy twórca korzystający z niego posiada te same tematy, co ty. Tak więc ktoś, kto odwiedza
twoją witrynę, a wcześniej przeglądał inne stworzone przy użyciu FrontPage, może stwierdzić, że twoja
witryna nie jest niczym wyjątkowym.
Przeglądanie strony
Jak mogliśmy się zorientować z wcześniejszych kart tego rozdziału, najprostszą i najszybszą metodą
przeglądania strony, nad którą pracujesz to wybrać Podgląd (Preview) w trybie Strona (Page) — pozwala to
jednak tylko na szybki przegląd. Ty natomiast chciałbyś może zobaczyć, jak twoja strona będzie widziana
przez wolnostojącą przeglądarkę. Da się to zrobić wybierając w menu Plik (File) opcję Widok w przeglądarce
(Preview in Browser). Wyświetlone zostaje okno dialogowe pokazane na rysunku 3.14.
Rysunek 3.14. Okno dialogowe Widok w przeglądarce
To narzędzie podglądu pozwala na wybranie typu przeglądarki, za pomocą której chcesz przeglądać witrynę.
To bardzo ważne, aby zobaczyć jak wygląda witryna we wszystkich tych przeglądarkach, których mogą
ASP – Kompendium programisty
71
używać potencjalni użytkownicy, ponieważ czasami strona różnie zachowuje się w różnych typach
przeglądarek.
Możesz również uzupełnić listę dodatkowymi przeglądarkami klikając przycisk Dodaj (Add). Wpisujesz wtedy
nazwę nowej przeglądarki, która pojawi się następnie na liście.
Zauważ również, że można dokonać wyboru rozmiaru okna. Pamiętaj, że odwiedzający mogą mieć monitor o
rozmiarze innym od tego, który ty posiadasz. Dlatego sprawdź, jak wygląda twoja witryna WWW na
monitorach różnego rozmiaru. Następnie, na podstawie tego podglądu, będziesz mógł wyregulować końcowy
wygląd twojej witryny.
FrontPage posiada jeszcze jedno narzędzie, które jest pomocne w radzeniu sobie z różnicami pomiędzy
przeglądarkami. Znajdując się w widoku Strona (Page), wybierz Opcje strony (Page Options) z menu
Narzędzia (Tools). Następnie wybierz zakładkę Kompatybilność (Compatibility). Zobaczysz okno dialogowe
pokazane na rysunku 3.15. Tutaj możesz wybrać przeglądarkę docelową dla tej strony, jej wersję oraz serwer,
na który strona będzie wysyłana. W oparciu o dokonane wybory, różne pola wyboru poniżej będą aktywowane
bądź dezaktywowane. To samo stanie się z pozycjami menu programu FrontPage.
Rysunek 3.15. Kompatybilność strony
Możesz również wybrać typ i wersję przeglądarki oraz typ serwera według własnych potrzeb. W tym wypadku
ręcznie określasz technologie, które mają obsługiwać stronę, zaznaczając bądź odznaczając dowolne pola
wyboru znajdujące się na dole okna.
Dodawanie strony
Możesz dodać nową stronę WWW lub ASP do sieci Web stworzonej w programie FrontPage wybierając Nowa
(New), Strona (Page) z menu Plik (File). Kiedy to uczynisz, zobaczysz kolejny ekran wyboru, który prezentuje
rysunek 3.16. W tym dialogu możesz dokonać wyboru spośród wielu szablonów stron. Te wzorcowe strony
przeprowadzą cię przez kreator, dzięki któremu stworzysz nową stronę, uzupełniając szablon odpowiednimi
informacjami. Możesz również wybrać szablon nazwany Stroną normalną (Normal Page), który jest po prostu
pustą stroną. Zakładka Strony ramek (Frames Pages) zawiera więcej szablonów, ale są one zbudowane przy
użyciu ramek.
Rozdział 3 – Narzędzia pracy
72
Rysunek 3.16. Dialog wyboru szablonu strony WWW
Kiedy przejdziesz przez wszystkie kroki kreatora, twoja nowa strona zostanie wyświetlona. Kiedy będziesz
chciał ją zapisać, zostaniesz zapytany o tytuł strony i nazwę pliku. To w tym miejscu ustalasz, czy dana strona
jest stroną ASP czy jakiegoś innego typu. Po prostu określ odpowiednio rozszerzenie pliku.
Pamiętaj jednak, że nawet jeśli dasz plikowi rozszerzenie .asp, to i tak kod strony serwera nie zadziała dopóki
nie zostanie przetworzony przez serwer. Kiedy już stworzyłeś stronę ASP, możesz przejść do widoku HTML i
ręcznie dodać twój kod do strony.
Praca ze stroną
Znajdując się w widoku normalnym strony możesz zacząć wpisywać do niej tekstową zawartość. Możesz
również formatować tekst podobnie jak w każdym innym programie Microsoft Office przy użyciu paska
formatowania, pokazanego na rysunku 3.17.
Rysunek 3.17. Pasek formatowania
Pierwsza lista rozwijana paska narzędziowego pozwala na wybór typu elementu HTML, który zostanie użyty
dla tego tekstu, na przykład H1 lub OL. Następnie możesz określić rodzaj i rozmiar czcionki oraz atrybuty
akapitu. Jeśli potem spojrzysz na kod HTML strony, zobaczysz, że twoje zmiany zamieniły się w odpowiednie
znaczniki HTML.
Jak pokazano na rysunku 3.18, inne elementy HTML dodaje się do strony WWW w menu Wstaw (Insert).
ASP – Kompendium programisty
73
Rysunek 3.18. Menu Wstaw w widoku strony
Wybór większości elementów w tym menu, uruchamia kreatora lub dialog uzyskujący od ciebie informacje
potrzebne podczas dodawania nowego elementu do strony. Na przykład jeśli wybierzesz Hiperłącze
(Hyperlink), program poprosi cię o podanie położenia pliku, do którego odnosi się łącze lub o wybranie strony
w sieci Web.
Dodawania elementów formularza dokonuje się w ten sam sposób, wybieramy któryś z podpunktów opcji
Formularz (Form) dostępnej w menu Wstaw (Insert). Możesz dodać formularz na dwa sposoby. Po pierwsze,
wstawienie pojedynczego elementu. Jeśli przykładowo chciałbyś wstawić pojedyncze pole tekstowe, wybierasz
odpowiednią pozycję z menu Formularza, a FrontPage doda ten element w ramach jego własnego znacznika
form
do twojej strony WWW i wyświetli widok pokazany na rysunku 3.19.
Rysunek 3.19. Pojedyncze pole formularza
Rozdział 3 – Narzędzia pracy
74
Możesz wtedy określić działania, które należy podjąć oraz inne właściwości formularza klikając na nim
prawym przyciskiem myszy, a następnie wybierając Właściwości Formularza (Form Properties). W ten sam
sposób możesz dodać inne formularze.
Jeśli formularz ma być bardziej złożony, możesz również wybrać w podmenu punkt Formularz (Form).
Stworzony zostanie wtedy formularz z przyciskami Prześlij (Submit) oraz Skasuj (Reset). Następnie dodajesz
elementy to tego formularza wybierając je z podmenu w czasie, gdy sam formularz jest zaznaczony.
Jeśli klikniesz prawym przyciskiem myszy którykolwiek z elementów formularza, możesz przejrzeć jego
właściwości wybierając Właściwości pola formularza (Form Field Properties). Odpowiednie okno dialogowe
pokazuje rysunek 3.20.
Rysunek 3.20. Właściwości pola formularza
Różne typy elementów formularza mają różne, odpowiadające im dialogi. Przycisk Sprawdź poprawność
(Validate) pozwala na stworzenie ograniczeń typu i wartości zapisu wprowadzanego w pole formularza po
stronie klienta.
NetObjects Fusion
Kolejnym narzędziem tworzenia witryn WWW jest NetObjects Fusion, http:\\www.netobjects.com. NetObjects
posiada duży wybór narzędzi wspierających projektowanie. W dalszej części rozdziału zwrócimy uwagę na
jedno z nich zwane ScriptBuilder, posiadające wspaniały interfejs do pracy z kodami stron ASP. Możesz
pobrać pełną, 30-dniową wersję tego programu z wymienionej wyżej witryny WWW.
Jak będziesz mógł się przekonać z treści tego rozdziału, największą korzyścią płynącą z pracy z NetObjects
Fusion to kontrola, jaką sprawujesz nad układem elementów strony. Narzędzie to pozwala na umieszczanie
elementów w dowolnej części strony, tak jak gdybyś projektował formularz w Visual Basic lub Access.
NetObjects bazuje na niewidzialnych tabelach i grafikach generowanych w HTML w celu zapewnienia
kompletnej swobody w rozmieszczaniu elementów na stronie.
Środowisko pracy
Fusion posiada pięć głównych widoków: Witryna (Site), Strona (Page), Styl (Style), Zasoby (Assets) oraz
Publikacja (Publish). Zmiany widoku dokonuje się klikając jedną z ikon z nazwami widoków, które znajdują
się w pasku narzędziowym tuż pod menu.
Widok Witryna (Site) jest pokazany na rysunku 3.21. Jest to miejsce, od którego prawdopodobnie rozpoczniesz
proces tworzenia, ponieważ właśnie w tym widoku możesz przeglądać strony znajdujące się w witrynie,
dodawać je oraz usuwać. Strony są prezentowane w hierarchii logicznej. Jako że jest to widok logiczny, a nie
fizyczny, nie możesz zapobiec połączeniom ze stronami spoza hierarchii. Widok ten wykorzystywany jest
przez twórców do przemyślenia i zorganizowania logicznej struktury witryny WWW.
ASP – Kompendium programisty
75
Rysunek 3.21. Widok Witryna programu NetObjects Fusion
Dodania strony do witryny dokonuje się przy użyciu klawisza Insert. Strona zostanie dodana jako potomna do
dowolnej strony, która w tym czasie będzie zaznaczona. Na rysunku 3.21. zaznaczona jest strona Home, tak
więc naciśnięcie klawisza Insert spowoduje dodanie właśnie do niej strony potomnej. Możesz usunąć stronę
klikając ją prawym przyciskiem, a potem przyciskając klawisz Delete.
Każda strona posiada swoje właściwości, które wyświetlane są w zakładce Właściwości (Properties) w małym
oknie dialogowym. Pokazane jest ono w prawym dolnym rogu rysunku 3.21.
W dialogu Właściwości (Properties) możesz zmienić nazwę bieżącej strony przez wpisanie jej do pola
tekstowego Nazwa (Name). Jeśli naciśniesz przycisk Dostosowanie nazwy (Custom Names), powinieneś ujrzeć
okno pokazane na rysunku 3.22.
Rysunek 3.22. Okno dialogowe Dostosowanie nazwy
Tworząc stronę w NetObjects, możesz dodać baner lub przycisk wyszukiwania. W oknie dialogowym
dostosowania nazw możesz określić tekst, który będzie się pojawiał na tych elementach strony. Tutaj możesz
również nadać plikowi odpowiednie rozszerzenie.
We właściwościach strony możesz umieścić również informacje związane z zarządzaniem twojej witryny.
Możesz wybrać kolor tła strony używany w widoku hierarchii. Możesz również określić czy dana strona jest
ukończona i czy powinna być publikowana. Dodatkowe pole tekstowe pozwala na dodanie komentarza do
strony.
Dodatkowa zakładka w widoku witryny nosi nazwę Struktury (Outline), który pokazuje strukturę stron w
postaci podobnej do tej w Eksploratorze Windows. Po lewej znajduje się lista stron pokazanych w ich
poszczególnych położeniach, natomiast po prawej widoczne są wszystkie strony potomne strony bieżącej.
Rozdział 3 – Narzędzia pracy
76
Tworząc stronę korzystasz z widoku Strona (Page). Aby znaleźć się w tym widoku, kliknij dwa razy na tej
stronie w widoku witryny, z którą chcesz pracować. Zobacz rysunek 3.23.
Rysunek 3.23. Widok Strona programu Fusion
Będąc już w widoku strony, możesz dostać się do innych stron na kilka sposobów. Możesz skorzystać ze
strzałek znajdujących się w lewym dolnym rogu, aby poruszać się między poziomami w hierarchii lub
pomiędzy stronami znajdującymi się na ty samym poziomie. Strzałki pozwalają na poruszanie się w hierarchii
pokazanej w widoku witryny.
Możesz również nacisnąć przycisk z czterema strzałkami, znajdujący się obok strzałek pojedynczych. Kiedy
przycisk jest naciśnięty, małe okno wyszczególnia listę stron w formie hierarchii.
Możesz również poszukiwać stron naciskając przycisk Przejdź do (Go to) w prawym górnym rogu ekranu.
Kiedy przycisk zostaje naciśnięty, program pyta cię o podanie części nazwy strony, którą chcesz znaleźć. Jeśli
naciśniesz przycisk Ostatnia (Last), umieszczony w prawym górnym rogu ekranu, przeniesiesz się do strony,
którą ostatnio otwierałeś.
Wzdłuż lewej strony okna umieszczono liczne elementy i składniki, które możesz włączyć do swojej strony.
Większa ilość tych elementów dostępna jest w menu Widok (View), Paski narzędzi (Toolbars), gdzie wybrać
można te paski, które aktualnie nie są prezentowane. Przyjrzymy się dokładnie niektórym z tych elementów
nieco dalej w tym podrozdziale.
Sama strona ma wiele właściwości, które możesz ustawić. Jeśli chcesz im się przyjrzeć, kliknij daną stronę
prawym przyciskiem myszy i wybierz Właściwości układu strony (Layout Properties). W zakładce Ogólne
(General) możesz ustalić rozmiar strony i sposób wykonania jej układu.
Druga zakładka tego okna to Tło (Background). Tutaj ustalasz kolor tła strony, obrazy tła oraz jego dźwięki.
Kolejnym widokiem głównym programu Fusion jest Styl (Style), który odnosi się do domyślnych czcionek,
kolorów, przycisków i grafik witryny, ich domyślnego wyglądu. Widok ten jest zaprezentowany na rysunku
3.24. Lewą stronę ekranu zajmuje długa lista stylów. Po prawej mamy podgląd wybranego stylu, który
uzyskujemy przez kliknięcie go w lewym panelu. Kiedy już wybrałeś styl dla twojej witryny, kliknij przycisk
Ustaw Styl (Set style).
ASP – Kompendium programisty
77
Rysunek 3.24. Widok Styl programu Fusion
Możesz również edytować każdy element istniejącego stylu. Przypuśćmy na przykład, że chciałbyś użyć stylu
Urban Legend, ale tło ma być inne. Modyfikacji tła stylu dokonasz wybierając Styl (Style), Edytuj element (Edit
Element), oraz Tło (Background). Pokaże się wtedy okno dialogowe, takie jak na rysunku 3.25. Podobnie
edytuje się inne elementy stylu.
Rysunek 3.25. Modyfikacja stylu
Jeśli nie chcesz korzystać z gotowych stylów, możesz stworzyć swój własny. Po prostu wybierz Styl (Style) i
Nowy styl (New Style). Zostaniesz poproszony o podanie nazwy dla twojego stylu, a potem możesz już zacząć
tworzyć jego elementy.
Kolejny widok główny Fusion to Zasoby (Assets), który wyszczególnia pliki, łącza, obiekty danych oraz
zmienne mające związek z twoją witryną. Ten widok pokazany jest na rysunku 3.26.
Rozdział 3 – Narzędzia pracy
78
Rysunek 3.26. Widok Zasoby programu Fusion
NetObjects Fusion obserwuje wszystkie pliki i łącza, które kiedykolwiek były związane ze stroną. Jeśli więc
zdecydujesz się na dodanie łącza bądź obrazka do witryny, możesz wybrać je z listy plików i łącz, które już są
jej częścią.
Możesz również użyć tego widoku do usuwania niepotrzebnych elementów z twojej witryny. Po prostu wybierz
odpowiedni element i naciśnij klawisz Delete.
Możesz również korzystać z tego widoku podczas globalnego zastępowania zasobu. Załóżmy, że posiadasz
łącze z witryną usytuowaną poza twoją własną, z którą łączysz się z różnych miejsc twojej witryny. Jeśli chcesz
zmienić to łącze na jakieś nowe i zmiana ma być globalna, znajdź je na liście w zakładce Łącza (Links).
Następnie kliknij dwukrotnie wybrane łącze i wpisz nowy adres URL.
Ostatni widok programu to Publikacja (Publish), gdzie określasz sposób i miejsce publikowania twojej
witryny. Ten widok, pokazany jest na rysunku 3.27, prezentuje sposób fizycznego zapamiętywania witryny
podczas jej publikowania. Na rysunku pliki są pokazane tak, jak byłyby umieszczone, gdyby były publikowane
według typu. Możesz również wybrać publikację wszystkich plików w jednym katalogu lub w ich hierarchii
logicznej. Aby zmienić sposób publikacji plików oraz ustawić inne właściwości, naciśnij przycisk Ustawienia
(Setup). Powinieneś ujrzeć okno dialogowe pokazane na rysunku 3.28.
ASP – Kompendium programisty
79
Rysunek 3.27. Widok Publikacja programu Fusion
Rysunek 3.28. Okno dialogowe Ustawienia publikacji
W pierwszej zakładce, Struktura katalogu (Directory Structure), możesz określić sposób fizycznego położenia
twoich plików. Druga zakładka, Wyjście HTML (HTML Output), umożliwia zmianę generowanego układu
strony oraz wykorzystywanego zestawu znaków. Zakładka trzecia, Położenie serwera (Server Location), daje
możliwość określenia miejsca lub miejsc, gdzie będzie się znajdowała twoja witryna. Ta zakładka pokazana
została na rysunku 3.29.
Rozdział 3 – Narzędzia pracy
80
Rysunek 3.29. Zakładka Położenie serwera dialogu Ustawienia publikacji
Istnieją dwa typy publikacji: lokalna i zdalna. Każdą z nich możesz dodać klikając przycisk Dodaj (Add).
Wybierając opcję Lokalna (Local) będziesz musiał po prostu podać katalog, w którym witryna będzie
publikowana w twojej sieci. Jeśli wybierzesz opcję Zdalna (Remote), musisz określić położenie macierzystego
komputera oddalonego, twoją nazwę użytkownika oraz hasło.
Czwarta zakładka okna dialogowego wyszczególnia listę składników, które będą publikowane wraz ze stroną,
jeśli w ogóle takowe istnieją.
Kiedy już zakończysz dokonywanie ustawień, jesteś gotowy do publikacji twojej witryny. Dokonuje się tego
klikając przycisk Publikuj (Publish). Po naciśnięciu przycisku wyświetlona zostanie lista miejsc publikacji
witryny, które określiłeś w zakładce Położenie serwera (Server Location). Naciśnij OK, a twoja strona zostanie
opublikowana.
Tworzenie witryny WWW przy użyciu programu Fusion
Aby stworzyć nową stronę przy użyciu programu Fusion, wybierz z menu Plik (File) pozycję Nowa witryna
(New Site). Jak to pokazano na rysunku 3.30, będziesz miał do wyboru trzy opcje. Wybierając opcję Pusta
witryna (Blank Site), stworzona zostanie pojedyncza strona WWW; wybierając Według szablonu (From
Template), zaprezentowany zostanie zbiór gotowych schematów witryn, które możesz wykorzystać jako
szkielet twojej witryny; jeśli zdecydujesz się na opcję Z istniejącej witryny WWW (From Existing Web Site),
program Fusion zaimportuje całą, wybraną witrynę WWW.
Rysunek 3.30. Tworzenie nowej strony
Praca ze stroną
Jeśli kiedykolwiek pracowałeś z Visual Basic lub projektowałeś formularze w Microsoft Access, stosunkowo
wygodnie będzie ci się pracowało ze stronami przy użyciu programu Fusion. Wszystkie elementy są kreślone
ASP – Kompendium programisty
81
na stronie. Kiedy już element się tam znajdzie, ustawiasz dla niego liczne właściwości w celu osiągnięcia
pożądanego efektu. Jeśli na przykład chcesz dodać tekst do strony, wybierzesz ikonę Tekst (Text) znajdującą się
w pasku narzędziowym widoku Strona (Page) po lewej stronie ekranu. Następnie wykreślisz element o
odpowiednim rozmiarze. Rysunek 3.31. pokazuje stronę z nakreślonym elementem tekstowym.
Rysunek 3.31. Strona z wstawionym polem tekstowym
Teraz, kiedy element jest wykreślony na stronie, możesz ustawić jego właściwości. Po pierwsze, możesz
wpisać tekst, który ma się pojawiać w elemencie. Następnie określasz styl tekstu, jego tło i wiele innych
właściwości przy użyciu odpowiedniego okna dialogowego. Podobne czynności wykonuje się przy dodawaniu
do strony innych elementów.
NetObjects ScriptBuilder
Kolejnym narzędziem NetObjects jest ScriptBuilder. To nie tylko wspaniałe narzędzie do tworzenia stron ASP.
Dzięki niemu można również tworzyć skrypty wykonywane po stronie klienta oraz czysty kod HTML. W tym
podrozdziale zwrócimy uwagę na tworzenie stron ASP przy użyciu NetObjects ScriptBuilder. Zobaczysz
również, jak można wykorzystać funkcje tego narzędzia do ułatwienia dodawania skryptów oraz ich
zatwierdzania.
Środowisko programowe
Okno główne programu ScriptBuilder składa się z dwóch paneli: lewego i prawego. Lewy panel zazwyczaj
zawiera listę działań lub opcji, zależnie od wybranej zakładki. Panel prawy pokazuje stronę ASP lub HTML,
nad którą pracujesz.
Aby otworzyć stronę w prawym panelu, wybierz Plik (File), Otwórz (Open). Okno dialogowe, które się ukaże,
pozwoli ci na znalezienie pliku, który chcesz otworzyć. Kiedy chcesz stworzyć nowy plik, wybierz Plik (File),
Nowy (New). Wyświetlony zostanie dialog, który pokazano na rysunku 3.32.
Rozdział 3 – Narzędzia pracy
82
Rysunek 3.32. Dialog Nowy Plik programu ScriptBuilder
Następnie możesz wybrać jeden z przedstawionych w oknie szablonów, reprezentujących typ strony, jaką
chcesz stworzyć. Wybrany szablon wygeneruje podstawowe znaczniki dla wybranego przez ciebie typu strony.
Jeśli zdecydowałeś się przykładowo na utworzenie strony ASP, szablon stworzy stronę zawierającą znaczniki
języka podstawowego, HTML, nagłówka (head), oraz treści (body).
Możesz również modyfikować te szablony, w ten sposób za każdym razem, kiedy stworzysz nową stronę przy
użyciu szablonu, będzie ona zawierała kod potrzebny dla tego typu pliku. Załóżmy na przykład, że posiadasz
plik biblioteki, który zawsze chcesz dołączać do twoich stron ASP. Aby to zrobić, za każdym razem musisz
dodawać do kodu wiersz
Include
dla tego pliku. Zmodyfikuj szablon strony ASP włączając do niego
odpowiedni kod. W celu dokonania zmian we szablonie, wyświetl zawartość plików położonych w folderze
Templates\Standard katalogu głównego ScriptBuilder.
Możesz również tworzyć swoje własne szablony. Być może często potrzebujesz strony ASP mającej kod, który
wykreśla graf w oparciu o dane pochodzące z zestawu rekordów — możesz stworzyć taki szablon zawierający
wspólny kod. Aby wykonać taki szablon, po prostu stwórz w zwykły sposób stronę ASP lub HTML, a
następnie umieść ją w folderze Templates\Custom. Te pliki dostępne są w menu Plik (File), Nowy (New), w
zakładce Własne (Custom).
W lewym panelu możesz wybrać zakładkę związaną z działaniami bądź opcjami, które wykorzystujesz podczas
pracy ze stroną. Wybierając zakładkę Odwołanie (Reference), ujrzysz widok pokazany na rysunku 3.33. To, co
tam widać to bogata biblioteka języków i technologii, które możesz wykorzystać podczas pracy z programem
ScriptBuilder.
ASP – Kompendium programisty
83
Rysunek 3.33. Widok Odwołanie w lewym panelu okna
Przypis
Jeśli nie widać listy rozwijanej, gdzie mógłbyś wpisać nazwę do wyszukania, kliknij małą strzałkę w górnym prawym rogu lewego
panelu.
Większość odwołań pochodzi z zasobów online, co ma swoje plusy i minusy. Musisz być połączony z siecią,
aby ujrzeć niektóre odwołania i punkty odwołań do stron, które już nie istnieją. Korzystne jest jednak to, że
zawartość listy jest cały czas uaktualniana, ponieważ pochodzi ze znaczących obszarów odwołań firm takich
jak Microsoft czy Netscape.
Możesz również użyć odwołania w celu wstawienia znaczników i kodu wprost do twojej strony. Na przykład
chcesz wstawić listę numerowaną HTML. Mógłbyś wybrać znacznik w odniesieniu HTML. Następnie jeśli
klikniesz prawym przyciskiem odpowiednią pozycję i wybierzesz Wstaw (Insert), znaczniki listy numerowanej
pojawią się w prawym panelu okna w miejscu, gdzie znajduje się kursor.
Możesz też uzupełnić bibliotekę o nowe odwołania. Jeśli klikniesz prawym przyciskiem w dowolnym miejscu
zakładki odwołań, powinieneś zobaczyć opcję Ustawienia (Settings). Kliknij ten punkt, a będziesz mógł
przejrzeć wszystkie dostępne książki biblioteki. Ustawień innych opcji zakładki odwołań dokonasz wybierając
Opcje (Options) z menu Narzędzia (Tools).
Jeśli wybierzesz zakładkę Odwzorowanie (Map), zobaczysz widok, który prezentuje rysunek 3.34.
Odwzorowanie odnosi się tutaj do reprezentacji dokumentu, z którym pracujesz. Odwzorowane są znaczniki i
składniki, które znalazły się w dokumencie, dzięki czemu możesz szybko znaleźć te miejsca w kodzie, gdzie
zostały one użyte. Gdybyś chciał odszukać miejsca, w których użyto znacznika
<BR>
, kliknij dwa razy
odpowiednią pozycję lewego panelu okna, a wiersz zawierający ten znacznik zostanie wyróżniony.
Rysunek 3.34. Widok Odwzorowanie programu ScriptBuilder
Zakładka Pulpit (Desktop), pokazana na rysunku 3.35, pozwala na poszukiwanie w systemie plików, które
chcesz wykorzystać podczas pracy z witryną. Jeśli klikniesz dwa razy dowolny plik, zostanie on otwarty w
prawym panelu okna. Jeśli klikniesz prawym przyciskiem myszy obszar Pulpitu, możesz utworzyć folder oraz
przejrzeć właściwości pliku.
Rozdział 3 – Narzędzia pracy
84
Rysunek 3.35. Widok Pulpit programu ScriptBuilder
Jednym z najużyteczniejszych składników programu ScriptBuilder jest biblioteka skryptów. Zakładka
Biblioteka skryptów (Script Library) pokazana została na rysunku 3.36. Pozwala ona na proste wstawianie
gotowych bloków kodu do twojej strony WWW. ScriptBuilder zawiera wiele skryptów strony klienta i strony
serwera, które możesz włączyć do twoich stron ASP i HTML.
Rysunek 3.36. Widok Biblioteka skryptów programu ScriptBuilder
Lista biblioteki skryptów może być sortowana po dowolnej kolumnie, którą wybierzesz klikając jej nagłówek.
Kolumny przedstawiają nazwę skryptu, użyty podczas jego tworzenia język lub technologię, jego opis oraz
wersję programu Navigator lub Explorer obsługującego skrypt.
Aby wstawić skrypt do twojej strony, umieść kursor w tym miejscu, gdzie ma się znaleźć oraz kliknij
dwukrotnie wybrany z biblioteki skrypt. Jeśli na przykład chcesz skorzystać z procedury odczytującej znacznik
ASP – Kompendium programisty
85
kontekstu klienta (cookie), najpierw umieść kursor w odpowiednim miejscu strony ASP, gdzie procedura ma
występować. Następnie kliknij dwukrotnie w lewym panelu prezentującym zbiór skryptów procedurę o nazwie
ReadCookie
. Od tej chwili stanie się ona częścią twojego kodu.
Te wbudowane skrypty są całkowicie konfigurowalne i podatne na zmiany. Aby zmienić właściwości skryptu,
kliknij go dwukrotnie i wybierz Właściwości (Properties). Ujrzysz dialog pokazany na rysunku 3.37. Tutaj
możesz zmienić nazwę i opis skryptu. Możesz również wybrać jego język bądź technologię, jak również wersję
przeglądarki Navigator lub Explorer, która będzie obsługiwała skrypt.
Rysunek 3.37. Dialog Właściwości skryptu
Modyfikacja kodu skryptu możliwa jest w zakładce Kod (Code). Okno powiększy się tak, aby pokazać kod
danej procedury (Rysunek 3.38.). Właśnie tutaj możesz wprowadzić pożądane zmiany w treści dostępnych w
bibliotece skryptów. Na przykład osobiście wolę, żeby procedury ASP (do nich należy ta pokazana na rysunku
3.38.) miały od razu w swej treści znaczniki bloku kodu ASP
<%
oraz
%>
. Mogę je tam umieścić modyfikując
skrypt w tej zakładce. Kiedy zamkniesz okno kodu, program poprosi cię o potwierdzenie lub odrzucenie
dokonanych zmian.
Rysunek 3.38. Okno kodu edytowanego skryptu
Moją ulubioną cechą programu jest możliwość dodawania do biblioteki własnych skryptów. Zauważyłem, że
wiele krótkich bloków kodu, z których stale korzystam, nie znalazło się w procedurach. Aby nie przepisywać
ciągle tych samych fragmentów kodu, można je umieścić w bibliotece.
Możesz dodać skrypt do biblioteki na dwa sposoby. Pierwszym z nich jest kliknięcie prawym przyciskiem w
obszarze okna biblioteki i wybranie punktu Dodaj (Add). Ujrzysz wtedy puste okno kodu, takie samo, jak w
wypadku edycji istniejącego skryptu. Tam wprowadzisz nowy kod skryptu. Po ukończeniu przejdź do zakładki
Rozdział 3 – Narzędzia pracy
86
Opis (Description). Tutaj wpiszesz nazwę nowego skryptu oraz jego krótki opis, wraz z wyszczególnieniem
zastosowanego języka lub technologii i wersji obsługującej ten skrypt przeglądarki Navigator lub Explorer.
Drugim sposobem dodania procedury do biblioteki skryptu jest odzyskanie odpowiedniego fragmentu kodu z
istniejącej już strony. Możesz to zrobić wyróżniając tekst w wybranym dokumencie, a następnie klikając
prawym przyciskiem zaznaczony tekst i wybierając opcję Dodaj do biblioteki skryptów (Add to Script Library).
Powiedzmy, że w wielu stronach ASP łączysz się z bazą danych w ten sam sposób i chcesz, aby ten kod
łączenia stał się częścią biblioteki skryptów. Wyróżnij ten fragment kodu przy użyciu myszy, a następnie
kliknij prawym przyciskiem. Okno, które się wtedy pojawi, pokazane jest na rysunku 3.39.
Rysunek 3.39. Dodawanie kodu do biblioteki skryptów
Jeśli wybierzesz opcję Dodaj do biblioteki skryptów (Add to Script Library), kod jest dodawany jako pozycja
do biblioteki. Ponownie wpisujesz wszystkie niezbędne informacje dotyczące nowego skryptu. Kiedy
skończysz, kod staje się częścią biblioteki i może być wstawiany do tworzonych stron.
Ostatnią zakładką lewego panelu głównego okna programu ScriptBuilder jest Galeria składników (Component
Gallery). Zawartość zakładki prezentuje rysunek 3.40. Galeria ułatwia pracę z programowalnymi, gotowymi do
wstawienia składnikami. Możesz włączyć dany składnik do tworzonej strony ASP lub HTML, przeciągając go
w to miejsce, w którym ma być inicjalizowany.
ASP – Kompendium programisty
87
Rysunek 3.40. Galeria składników programu ScriptBuilder
Możesz określić właściwości, metody oraz zdarzenia związane z danym składnikiem, klikając go prawym
przyciskiem myszy, a następnie wybierając odpowiedni punkt. Szablon właściwości, metody bądź zdarzenia
jest wtedy dodawany do twojej strony. Możesz również dodać własny składnik do środowiska programu,
klikając prawym przyciskiem w dowolnym miejscu Galerii składników oraz wybierając opcję Dodaj do galerii
(Add to Gallery).
Praca z kodem w programie ScriptBuilder
ScriptBuilder posiada wiele narzędzi wspomagających pisanie kodu i pracę z nim. ScriptBuilder wyświetla
wiersze kodu w różnych kolorach, co powoduje, że kod jest bardziej czytelny i rozpoznawalny. Aby jednak z
tej cechy programu skorzystać, najpierw musi on wiedzieć, z jakim językiem pracujesz. Tak więc jedną z
pierwszych rzeczy, którą zrobisz będzie ustawienie domyślnego języka, który będzie wyróżniany. Wybierz z
menu Widok (View) opcję Wyróżniony język (Highlighted Language), a następnie przykładowo VBScript, co
pokazano na rysunku 3.41.
Rysunek 3.41. Ustawianie domyślnego języka do wyróżniania
Rozdział 3 – Narzędzia pracy
88
Kiedy język zostanie określony, kod w odpowiedni sposób wyróżniany kolorami, co czyni go łatwiejszym do
odczytu. Poza tym, skoro ScriptBuilder już wie, jakiego języka używasz, może automatycznie pomagać ci w
uzupełnianiu bloków kodu. Jeśli na przykład napiszesz poniższy kod wraz ze spacją:
If
program uzupełni ten blok:
If expression Then
End If
Wyróżni nawet frazę
expression
, będziesz mógł więc natychmiast wpisać w to miejsce wybrane wyrażenie.
Jeśli wpisałbyś ten kod wraz ze spacją:
Select
ScriptBuilder zbuduje następujący blok kodu, wyróżniając w nim słowo
expression
:
Select Case expression
Case value
Case Else
End Select
Możesz również zmodyfikować funkcję automatycznego tworzenia skryptów tak, aby inne kody pojawiały się
przy wyborze poszczególnych instrukcji. Przykładowo możesz chcieć, aby instrukcja
If
zawsze była
uzupełniana instrukcją
Else
. Takiego ustawienia możesz dokonać wybierając Narzędzia (Tools) oraz
Automatyczne tworzenie skryptów (AutoScripting). Zobaczysz wtedy kompletną listę dostępnych opcji
automatycznego tworzenia skryptów (zobacz rysunek 3.42).
Rysunek 3.42. Konfiguracja funkcji Automatycznego tworzenia skryptów
Zauważ, że lista zawiera informacje o używanych językach. Przewijasz listę w poszukiwaniu instrukcji
If
dla
języka VBScript. Następnie kliknij Edytuj (Edit). Wyświetli się ekran pokazany na rysunku 3.43. Tutaj możesz
uzupełnić instrukcję
If
instrukcją
Else
lub dokonać jakiejkolwiek innej modyfikacji. Zwróć uwagę, że słowo
expression
jest wyróżnione. Kiedy wpisałeś
If
w kodzie strony, właśnie słowo
expression
było zaznaczone.
ASP – Kompendium programisty
89
Rysunek 3.43. Edycja kodu w Automatycznym tworzeniu skryptów
Możesz również dodać swoje własne bloki kodu poprzez funkcję Automatycznego tworzenia skryptów,
naciskając przycisk Nowy (New) w oknie dialogowym. Ukaże się ten sam dialog, co w wypadku edycji. Musisz
tutaj wpisać słowo kluczowe, instrukcję, po pojawieniu się której ma wystąpić odpowiedni kod. Oprócz tego
określasz język programowania dla tego kodu oraz oczywiście sam kod.
Możesz również użyć tej funkcji programu, aby zastosować skróconą metodę tworzenia kodu. Jak się dowiesz z
kolejnego rozdziału, często na przykład będziesz włączał do kodu wiersz
Option Explicit
, aby ułatwić
usuwanie błędów. Możesz zapewnić sobie skrót dla tej instrukcji dzięki stworzeniu odpowiedniej pozycji w
oknie Automatycznego tworzenia skryptów. Najpierw wpisz następującą kluczową frazę:
ooo
Poniżej, w polu Wstawiany tekst (Text to Insert), wpisz:
Option Explicit
oraz nowy wiersz. Teraz, kiedy podczas tworzenia kodu wprowadzisz
ooo
, pojawi się na ekranie instrukcja
Option Explicit
, a po niej nowy wiersz.
W menu Skrypt (Script), a następnie pozycji Menu dostępna jest opcja Blok serwera (Server Block), której
wybór powoduje wpisanie następującego kodu:
<%
%>
Tworzony jest więc blok serwera. Kiedy wybierzesz menu Narzędzia (Tools), Opcje (Options) oraz przejdziesz
do zakładki Kod (Code), ukaże się ekran pokazany na rysunku 3.44. W tej zakładce możesz dokonać zmiany
używanej składni bloku kodu przez ustawienie jej w polu o nazwie Typ znacznika (Tag Type).
Rozdział 3 – Narzędzia pracy
90
Rysunek 3.44. Opcje ustawień kodu
W tym samym dialogu znajduje się punkt Bloki funkcji (Function Blocks). W odpowiednim polu wpisujesz
tekst, który ma pojawiać się w bloku komentarza wstawianej procedury. Jeśli chcesz, aby pojawiało się twoje
imię, wpisz je w pole Nazwa użytkownika (Username). Następnie możesz zaznaczyć, że twoje imię wraz z
aktualną datą chcesz włączyć do nagłówka komentarza funkcji.
Ta informacja jest wykorzystywana w oknie dialogowym pokazanym na rysunku 3.45, które pojawi się kiedy
wybierzesz opcję Bloki funkcji (Function Blocks) z menu Skrypt (Script).
Rysunek 3.45. Wstawianie bloku funkcji
Wpisujesz nazwę funkcji, a następnie opis jej działania. Kiedy naciśniesz OK, wprowadzone tutaj dane są
łączone z danymi wprowadzonymi w dialogu Opcji i wytwarzany jest następujący, przykładowy blok kodu:
'*************************************************************
' SampleFunction ()
'
' Tutaj wpisz szczegóły dotyczące twojej funkcji
'
' Autor: Greg Buczek
' Data utworzenia: 8/4/99
'*************************************************************
*/
Function SampleFunction ()
End Function
Jak więc widzisz, ScriptBuilder nie jest narzędziem wizualnego projektowania stron. Możesz w prosty sposób
uruchomić podgląd strony, ale nie możesz umieszczać na niej elementów metodą przeciągania i upuszczania.
W programie ScriptBuilder pracujesz jedynie z kodem oraz czystym HTML.
ASP – Kompendium programisty
91
Pasek narzędziowy Znaczniki HTML (HTML Tags) pomaga jednak wstawiać znaczniki. Pasek ten pokazany
jest na rysunku 3.46. Po naciśnięciu wybranego przycisku, odpowiedni znacznik jest wstawiany do twojego
dokumentu w miejscu, gdzie znajduje się kursor, jeśli więc naciśniesz przycisk B, znaczniki
<B>
oraz
</B>
staną
się częścią dokumentu. Jeśli najpierw wyróżnisz tekst do pogrubienia, a dopiero potem wybierzesz przycisk z
paska, znaczniki będą umieszczone wokoło zaznaczonego tekstu.
Rysunek 3.46. Pasek narzędziowy Znaczniki HTML
Naciśnięcie jednego z przycisków wyrównania tekstu powoduje wytworzenie odpowiednich znaczników
akapitu. Na przykład naciśnięcie przycisku wyrównania do lewej, tworzony jest następujący HTML:
<P ALIGN=LEFT></P>
Po ikonach wyrównania w pasku umieszczono ikony wypunktowania, numerowania, akapitu, wiersza podziału
oraz linii poziomej, których naciśnięcie również spowoduje pojawienie się odpowiedniego znacznika.
Przyciski od H1 do H6 wytwarzają odpowiadające im znaczniki nagłówka, tak więc naciśnięcie przycisku H1
wywoła następujący HTML:
<H1></H1>
Kursor będzie znajdował się pomiędzy znacznikami, tak więc możesz od razu zacząć wpisywać tekst.
Ostatnie dwa przyciski związane są odpowiednio ze znacznikami obrazu i łącza. Naciśnięcie tych przycisków
spowoduje pojawienie się odpowiedniego dialogu, w którym podasz konieczne informacje. Kiedy wybierzesz
ikonę Obraz (Image), zobaczysz okno pokazane na rysunku 3.47.
Rysunek 3.47. Wstawianie znacznika obrazu
Wpisujesz w nim ścieżkę dostępu do obrazu, tekst pojawiający się wraz z obrazkiem lub zamiast niego, sposób
wyrównania tekstu, granice, rozmiar obrazu oraz rozstaw. Znacznik obrazu tworzony jest na podstawie
wprowadzonych zapisów.
Kiedy naciśniesz przycisk Łącze (Link), ujrzysz dialog pokazany na rysunku 3.48. Uzupełniasz go lokalizacją,
do której łącze będzie odsyłało, tekstem pojawiającym się na stronie jako łącze oraz, opcjonalnie, nazwę łącza i
jego cel. Pole tekstowe Cel (Target) odnosi się do przeglądarki lub ramki, do której wysyłana jest strona. Kiedy
wprowadzisz już informacje i naciśniesz OK, utworzony zostanie odpowiedni znacznik.
Rozdział 3 – Narzędzia pracy
92
Rysunek 3.48. Wstawianie znacznika łącza
ScriptBuilder posiada również pasek narzędziowy elementów formularza (rysunek 3.49.). Użycie każdego ze
znajdujących się w nim przycisków spowoduje wyświetlenie dialogu, w który należy wpisać odpowiednie
informacje potrzebne do stworzenia pożądanego znacznika. Pierwszy przycisk służy do tworzenia samego
formularza. Kiedy go naciśniesz, dialog zapyta cię o nazwę formularza, okno wyjściowej przeglądarki lub
ramki, typ kodowania oraz położenie strony, do której należy odesłać użytkownika po wypełnieniu i wysłaniu
formularza. Określasz również metodę przesyłania formularza, GET lub POST. Różnice pomiędzy tymi
metodami omówione zostały w rozdziale 5.
Rysunek 3.49. Pasek narzędziowy Elementy formularza
Rezultatem wypełnienia okna dialogowego jest stworzenie znacznika formularza w miejscu kursora, który
może być podobny do tego:
<FORM NAME="MoreInfoForm" TARGET="New"
ACTION="http://www.whatever.com/page.asp" METHOD="post"
ENCODE="application/x-www-form-urlencoded">
</FORM>
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:
<INPUT TYPE="text" SIZE=20 MAXLENGHT=50 NAME="FirstName">
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:
<A HREF="../html/lecturerouter.asp?LectureID=
<% Response.write RSLectures("LectureID") %>">
<IMG HEIGHT=28 WIDTH=35 SRC="<% Response.Write iconpath %>"
Rozdział 3 – Narzędzia pracy
94
BORDER=0 ></A>
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:
<HTML>
<HEAD>
<TITLE>Simple Tag Page</TITLE>
</HEAD>
<BODY>
<H1>Witam na stronie z zegarem</H1>
<P>Teraz jest: <% = Now() %><P>
</BODY>
</HTML>
Strona jest napisana przy użyciu standardowego HTML-a aż do wiersza:
<P>Teraz jest: <% = Now() %><P>
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:
<P>Teraz jest: 7/12/99 12:10:14 PM<P>
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:
<HTML>
<HEAD>
<TITLE>Days Until Christmas</TITLE>
</HEAD>
<BODY>
<H1>Ile czasu zostało?</H1>
<P>Dni do Bożego Narodzenia: <%
Response.Write DateDiff("d",Date,"12/25/" & Year(Date)) %>
<P>
</BODY>
</HTML>
Strona zbudowana jest z samego HTML-a aż do wiersza:
<P>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:
<P>Dni do Bożego Narodzenia: 157<P>
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 </Script>
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>
.
<HTML>
<HEAD>
<TITLE>Session Object</TITLE>
</HEAD>
<BODY>
<H1>Czas trwania sesji</H1>
<P>Czas trwania sesji upływa po (minutach):
<SCRIPT LANGUAGE=VBScript RUNAT=Server >
Response.Write Session.Timeout
</SCRIPT>
</BODY>
</HTML>
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
</Script>
. 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:
<HTML>
<HEAD>
<TITLE>Change the Light</TITLE>
</HEAD>
<%
if hour(Time) > 6 and Hour(Time) < 19 then
Response.Write "<BODY BGCOLOR=""#FFFFD7"">"
else
Response.Write "<BODY BGCOLOR=""#808080"">"
end if
%>
<H1>W nocy wyłączamy światło.</H1>
</BODY>
</HTML>
Zwróć uwagę na to, jak wygląda kod. Posiada jeden znacznik treści (
<BODY>
) 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:
<BODY BGCOLOR="#808080">
Rysunek 4.4. pokazuje wygląd strony w nocy.
Rozdział 4 – Podstawy ASP
102
Rysunek 4.4. Strona zmieniająca kolor tła — w godzinach nocnych
W czasie dnia wyjściowym znacznikiem treści kodu będzie:
<BODY BGCOLOR="#FFFFD7">
Wygląd strony w tym wypadku pokazuje rysunek 4.5.
Rysunek 4.5. Strona zmieniająca kolor tła — w czasie dnia
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:
<HTML>
<HEAD><TITLE>Client and Server</TITLE>
<%
If Session("CustomerType") = "Preferred" then
TheRate = 25
else
TheRate = 50
end if
%>
<SCRIPT language="JavaScript">
<!--
function CheckPrice()
{
var TheMessage = 0;
TheMessage = <% response.write TheRate %> * document.sampleform.Quantity.value;
alert("Twoja cena wynosi $" + TheMessage);
}
// -->
</SCRIPT></HEAD>
<BODY>
<FORM NAME="sampleform">
Wpisz ilość, aby określić cenę
<p>
<INPUT TYPE="text" NAME="Quantity" SIZE=10>
<p>
<INPUT TYPE="button" NAME="submitButton" VALUE="Pokaż cenę"
onClick="CheckPrice();">
</FORM>
</BODY>
</HTML>
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">
<!--
function CheckPrice()
{
var TheMessage = 0;
TheMessage = <% response.write TheRate %> * document.sampleform.Quantity.value;
alert("Twoja cena wynosi $" + TheMessage);
}
// -->
</SCRIPT>
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:
<HTML>
<HEAD><TITLE>Client and Server</TITLE>
<SCRIPT language="JavaScript">
<!--
function CheckPrice()
{
var TheMessage = 0;
TheMessage = 50 * document.sampleform.Quantity.value
alert("Twoja cena wynosi $" + TheMessage);
}
// -->
</SCRIPT></HEAD>
<BODY>
<FORM NAME="sampleform">
Wpisz ilość, aby określić cenę
<p>
<INPUT TYPE="text" NAME="Quantity" SIZE=10>
<p>
<INPUT TYPE="button" NAME="submitButton" VALUE="Pokaż cenę"
onClick="CheckPrice();">
</FORM>
</BODY>
</HTML>
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:
<%@ LANGUAGE=JSCRIPT %>
Rozdział 4 – Podstawy ASP
106
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">
<!-- #include file="FieldValidation.inc" -->
</SCRIPT>
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">
<!-- #include file="../lib/FieldValidation.inc" -->
</SCRIPT>
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.
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ę:
ASP – Kompendium programisty
107
<%
'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
Else
ZipCode = 0
End If
Rozdział 4 – Podstawy ASP
108
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">
<!-- #include file="FieldValidation.inc" -->
</SCRIPT>
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
Możesz również użyć apostrofu do zaznaczenia, że cały wiersz jest komentarzem:
If Year(Request.Form("StartDate")) = Year(Date) then
ASP – Kompendium programisty
109
'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 " _
& "OCQuizQuestions where QuizQuestionID = " _
& Question)
if Request.Form(Question)=RSQuestion("QuizAnswer") then
NumberCorrect=NumberCorrect + 1
Rozdział 4 – Podstawy ASP
110
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
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.
ASP – Kompendium programisty
111
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
MyVariable = MyVariable * 3
MyVariable = MyVaraible + 1
Response.Write MyVariable
Rozdział 4 – Podstawy ASP
112
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"
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")
ASP – Kompendium programisty
113
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"
End Sub
%>
Rozdział 4 – Podstawy ASP
114
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 Operator
, której wartością zwracaną jest reszta z dzielenia. Na
przykład wynikiem kodu:
X = 5 MOD 3
będzie przypisanie zmiennej
X
wartości
2
, ponieważ właśnie dwójka jest resztą z tego dzielenia.
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:
ASP – Kompendium programisty
115
<%
'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
Y = int(X)
Reaponse.Write Y
%>
Rozdział 4 – Podstawy ASP
116
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")
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,
ASP – Kompendium programisty
117
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ę!<BR>"
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 _
Response.Write "Zgadza się!<BR>" else _
Response.Write "Źle!<BR>"
Rozdział 4 – Podstawy ASP
118
Response.Write "To wszystko"
%>
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 "<FONT SIZE=""+2"">"
Response.Write "Zgadza się!<BR>"
Response.Write "</FONT>"
else
Response.Write "<FONT SIZE=""-2"">"
Response.Write "Źle!<BR>"
Response.Write "</FONT>"
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 Until
jest prawdą, a w takim
wypadku kod przechodzi od razu do instrukcji
Loop
.
W następnym przykładzie kod przejdzie przez pętlę trzy razy:
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
%>
<P>Item Name: <% Response.Write RSOrderItems("ItemType") %>
<% Response.Write RSOrderItems("ItemName") %>
<BR>Quantity: <% Response.Write RSOrderItems("Quantity") %>
<BR>Price: <% Response.Write RSOrderItems("TotalPrice") %>
<%
RSOrderItems.MoveNext
Loop
%>
ASP – Kompendium programisty
123
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:
<BR>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 & "<BR>"
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 "<FONT SIZE=""" & I & """>Witaj</FONT><BR>"
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) _
& "<BR>"
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 & "<BR>"
Response.Write Time & "<BR>"
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) & "<BR>"
Response.Write "Numer miesiąca: " & Month(Date) & "<BR>"
Response.Write "Dzień miesiąca: " & Day(Date) & "<BR>"
Response.Write "Numer dnia tygodnia: " & WeekDay(Date) & "<BR>"
Response.Write "Godzina: " & Hour(Time) & "<BR>"
Response.Write "Minuta: " & Minute(Time) & "<BR>"
Response.Write "Sekunda: " & Second(Time) & "<BR>"
%>
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) & "<P>"
Response.Write "Data długa: "
Response.Write FormatDateTime(Now,1) & "<P>"
Response.Write "Data krótka: "
Response.Write FormatDateTime(Now,2) & "<P>"
Response.Write "Czas długi: "
Response.Write FormatDateTime(Now,3) & "<P>"
Response.Write "Czas krótki: "
Response.Write FormatDateTime(Now,4)
%>
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) & "<P>"
Response.Write FormatCurrency(-12345.67) & "<P>"
Response.Write FormatCurrency(12345.67,3) & "<P>"
Response.Write FormatCurrency(.67, ,0) & "<P>"
Response.Write FormatCurrency(-12345.67,,,0) & "<P>"
Response.Write FormatCurrency(12345.67,,,,0) & "<P>"
%>
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) & "<P>"
Response.Write FormatNumber(-12345.67) & "<P>"
Response.Write FormatNumber(12345.67123456,5) & "<P>"
Response.Write FormatNumber(.67, ,0) & "<P>"
Response.Write FormatNumber(-12345.67,,,0) & "<P>"
Response.Write FormatNumber(987654321.1234,,,,0) & "<P>"
%>
Wyniki tych wywołań pokazuje rysunek 4.21.
Rozdział 4 – Podstawy ASP
138
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) & "<P>"
Response.Write FormatPercent(-.67) & "<P>"
Response.Write FormatPercent(23.67) & "<P>"
Response.Write FormatPercent(23.67, 0) & "<P>"
%>
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
ASP – Kompendium programisty
141
StringToChop = "New Mexico"
Response.Write Mid(StringToChop, 5, 3)
Response.Write Mid(StringToChop, 5)
%>
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 = "bob@somewhere.com"
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") & "<P>"
'początek przeszukiwania od pozycji 5
Response.Write Replace("Mississippi", "s", "x", 5) & "<P>"
'początek przeszukiwania od pozycji 1 i dwie zamiany
Response.Write Replace("Mississippi", "s", "x", 1, 2) & "<P>"
'początek przeszukiwania od pozycji 4 i dwie zamiany
Response.Write Replace("Mississippi", "s", "x", 4, 2) & "<P>"
'zwykła zamiana, ale znak nie został znaleziony
Response.Write Replace("Mississippi", "S", "x") & "<P>"
'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 + LowValue
reprezentuje
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) & "<BR>"
Next
%>
Wyniki działania tego kodu pokazano na rysunku 4.24.
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 = "mary@somewhere.com"
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."
End if
ASP – Kompendium programisty
149
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.
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
Rozdział 5 – Obiekt Request
150
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 e-
commerce 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 "gbuczek@somewhere.com", "you@whoknows.com", "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:
<FORM ACTION="http://www.whatever.com/shoppingcart.asp" METHOD=GET>
Rozdział 5 – Obiekt Request
152
Ten wiersz wyśle zawartość formularza do strony shoppingcart.asp.
Kiedy umieszczasz znacznik
Form
na twojej stronie WWW, uzupełniasz go parametrem
Action
, który określa
sposób przesyłania danych. Możesz użyć metody
Post
, jak w tym przykładzie:
<FORM ACTION="http://www.whatever.com/shoppingcart.asp" METHOD=POST>
Kiedy korzystasz z metody
Post
, pola są wysyłane w postaci strumienia binarnego i nie są widziane jako część
łącza do strony. Możesz również wykorzystać metodę
Get
:
<FORM ACTION="http://www.whatever.com/shoppingcart.asp" METHOD=GET>
Kiedy używasz metody
Get
, liczba wysłanych bajtów jest ograniczona, a pola pojawiają się jako część łącza do
strony. Spójrzmy na przykład na wyszukiwarkę taką jak Go To. Kiedy wprowadzisz słowo kluczowe do
wyszukania, stanie się ono częścią adresu URL stronie wyników wyszukiwania, jak to pokazano na rysunku
5.1.
Rysunek 5.1.
Adres URL zawierający pola formularza
W polu wyszukiwania wpisałem "
Active Server Page
". Zauważ, że ta fraza jest częścią adresu URL w polu
adresowym przeglądarki Internet Explorer. Wynika to z zastosowania metody
Get
podczas przesyłania
formularza.
Kiedy formularz jest przesyłany przy użyciu metody
Post
, jego pola dostępne są poprzez zbiór
Form
. Kiedy są
przesyłane przy wykorzystaniu metody
Get
, zbiór
QueryString
będzie zawierał przesłane dane.
Podczas tworzenia formularza na stronie WWW wykorzystujesz różne pola, na przykład pola tekstowe, z
hasłem, ukryte oraz obszary tekstowe. Definiując każdy z tych elementów na stronie WWW, nadajesz im
określone nazwy. Na przykład jeśli masz stronę zbierającą informacje o użytkownikach, formularz mógłby być
zdefiniowany w następujący sposób:
<FORM ACTION="http://www.somewhere.com/processform.asp"
METHOD="POST">
ASP – Kompendium programisty
153
Nazwa:<BR>
<INPUT TYPE="text" SIZE=30 MAXLENGTH=50 NAME="Name">
<P>Adres e-mail:<BR>
<INPUT TYPE="text" SIZE=30 MAXLENGTH=50 NAME="EmailAddress">
<P>Zainteresowania:<BR>
<SELECT NAME="Interests" SIZE=4 MULTIPLE>
<OPTION VALUE="Nowości">Nowości
<OPTION VALUE="Sport">Sport
<OPTION VALUE="Wycieczki">Wycieczki
<OPTION VALUE="Inne">Inne
</SELECT>
<P><INPUT TYPE="submit" NAME="SubmitButton" VALUE="OK">
</FORM>
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) & "<P>"
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 & "<BR>"
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:
<A
HREF="http://www.somewhere.com/productdetails.asp?ProductID
=2355">Pasta</A>
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
156
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) &
"<P>"
Next
Wynik wykonania tego kodu prezentuje rysunek 5.3.
Rysunek 5.3. Wynik przetworzenia strony
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.
Rozdział 5 – Obiekt Request
158
CONTENT_LENGTH
Liczba bitów zgłaszanych przez klienta serwerowi wraz z
żądaniem.
CONTENT_TYPE
Typ żądania.
GATEWAY_INTERFACE
Wersja CGI w formie numeru CGI.
HTTPS
Zawiera ciąg
on
, gdy żądanie jest bezpieczne, jeśli nie —
ciąg
off
.
HTTPS_KEYSIZE
Liczba bitów SSL używanych przy żądaniu.
HTTPS_SECRETKEYSIZE
Liczba bitów używana na serwerze.
HTTPS_SERVER_ISSUER
Wydawca certyfikatu dla serwera.
HTTPS_SERVER_SUBJECT
Pole tematu certyfikatu serwera.
INSTANCE_ID
Numer identyfikacyjny egzemplarza serwera WWW.
INSTANCE_META_PATH
Ścieżka do metabazy dla tego określonego egzemplarza.
LOCAL_ADDR
Adres IP serwera.
LOGON_USER
Jeśli użytkownik jest zalogowany w systemie NT, to pole
zawiera nazwę tego użytkownika.
PATH_INFO
Ścieżka dostępu do żądanej strony poza katalogiem
macierzystym nazwy domeny.
PATH_TRANSLATED
Fizyczna ścieżka żądania.
QUERY_STRING
Dowolna dana przekazana metodą
Get
lub występująca po
znaku zapytania w łączu.
REMOTE_ADDR
Adres IP komputera, który wystosował żądanie.
REMOTE_HOST
Tłumaczona nazwa komputera wystosowującego żądanie,
jeśli takowa istnieje. Jeśli nie, pole zawiera adres IP.
REMOTE_USER
Nazwa użytkownika, jeśli takowa została wysłana przez
gościa.
REQUEST_METHOD
Wykorzystana metoda żądania,
Post
lub
Get
.
SCRIPT_NAME
Położenie pliku wirtualnego wywoływanego skryptu.
SERVER_NAME
Nazwa serwera.
SERVER_PORT
Port używany podczas żądania.
SERVER_PORT_SECURE
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.
SERVER_PROTOCOL
Używany protokół z numerem wersji, to znaczy
HTTP/1.1.
SERVER_SOFTWARE
Nazwa i wersja oprogramowania uruchamianego przez
serwer.
URL
Ś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) & "<P>"
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") & "<P>"
response.write "Czy cookie 1 ma klucz?: " _
& request.cookies("SampleCookie1").HasKeys & "<P>"
response.write "Cały złożony cookie: " _
& request.cookies("SampleCookie2") & "<P>"
response.write "Czy cookie 2 ma klucz?: " _
& request.cookies("SampleCookie2").HasKeys & "<P>"
response.write "Cookie złożony część 1: " _
& request.cookies("SampleCookie2")("Part1") & "<P>"
response.write "Cookie złożony część 1: " _
Rozdział 5 – Obiekt Request
160
& request.cookies("SampleCookie2")("Part2")
Wynik wykonania kodu pokazano na rysunku 5.4.
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) & "<P>"
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ść Przeznaczenie
TotalBytes
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:
<FORM ACTION="./processform.asp" METHOD="POST">
Name:<BR><INPUT TYPE="text" SIZE=30 MAXLENGTH=50 NAME="Name">
<P>Email Address:<BR><INPUT TYPE="text" SIZE=30 MAXLENGTH=50 NAME="EmailAddress">
<P>Interests:<BR><SELECT NAME="Interests" SIZE=4 MULTIPLE>
<OPTION VALUE="News">News
<OPTION VALUE="Sports">Sports
<OPTION VALUE="Hiking">Hiking
<OPTION VALUE="Other">Other
</SELECT>
Rozdział 5 – Obiekt Request
162
<P><INPUT TYPE="submit" NAME="SubmitButton" VALUE="OK">
</FORM>
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ść Przeznaczenie
BinaryRead
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)
ASP – Kompendium programisty
163
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.
ASP – Kompendium programisty
165
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:
<INPUT TYPE=HIDDEN NAME="SendTo" VALUE="gbuczek@thuntek.net">
<INPUT TYPE=HIDDEN NAME="CompleteMessage"
VALUE=" Dziękujemy za podanie niezbędnych informacji"
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:
<INPUT TYPE=SUBMIT NAME="SubmitButton" VALUE="Send">
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: Dave@whatever.com
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 "na@na.com", 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 "na@na.com", 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:
<TEXTAREA WRAP=PHYSICAL NAME="Service" ROWS=3 COLS=61></TEXTAREA>
wymaga zastosowania dla pola tabeli nazwy Service. Formularz HTML zawiera również następujące pola
ukryte:
<INPUT TYPE=HIDDEN NAME="CompleteMessage"
VALUE="Dziękujemy za podanie niezbędnych informacji">
<INPUT TYPE=HIDDEN NAME="TableName" VALUE="C5Survey">
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:
Rozdział 5 – Obiekt Request
174
TheFields = TheFields & TheFormField & ", "
TheValues = TheValues & "'" & Request.Form(TheFormField) & "', "
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.
ASP – Kompendium programisty
175
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:
Rozdział 5 – Obiekt Request
178
response.cookies("Login")("UserName") = request.form ("username")
response.cookies("Login")("FavCat") = request.form("FavCat")
response.cookies("Login").Expires = "2/2/2002"
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ść"
NameOfCookie
jest nazwą cookie zapamiętanego na systemie gościa.
Wartość
reprezentuje tekst zapamiętywany
w cookie. Tak więc ten kod:
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
182
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
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>
<OPTION VALUE="<% Response.Write
Request.Cookies("SearchCriteria")("1") %>"><% Response.Write
Request.Cookies("SearchCriteria")("1") %>
<OPTION VALUE="<% Response.Write
Request.Cookies("SearchCriteria")("2") %>"><% Response.Write
Request.Cookies("SearchCriteria")("2") %>
<OPTION VALUE="<% Response.Write
Request.Cookies("SearchCriteria")("3") %>"><% Response.Write
Request.Cookies("SearchCriteria")("3") %>
<OPTION VALUE="<% Response.Write
Request.Cookies("SearchCriteria")("4") %>"><% Response.Write
Request.Cookies("SearchCriteria")("4") %>
<OPTION VALUE="<% Response.Write
Request.Cookies("SearchCriteria")("5") %>"><% Response.Write
Request.Cookies("SearchCriteria")("5") %>
</SELECT>
Znacznik cookie będzie jednak obecny tylko przez czas, w którym odwiedzający jest połączony z twoją
witryną. Aby znacznik pozostał dłużej na systemie gościa, musisz określić poprzez właściwość
Expires
odpowiednią datę i czas (lub jedną z tych wartości) ważności cookie. Składnia jest właściwość
Expires
następująca:
Response.Cookies("NameOfCookie").Expires = Data
Rozdział 6 – Obiekt Response
184
Data
określa moment upłynięcia ważności cookie.
NameOfCookie
jest nazwą tego znacznika, dla którego chcesz
ustalić datę ważności. W naszym przykładzie kod wyglądałby tak:
Response.Cookies("SearchCriteria").Expires = "5/1/2005"
Istnieją trzy inne właściwości cookie, które możesz określić:
Domain
,
Path
i
Secure
. Możesz ograniczyć
wysyłanie cookie do jednej tylko nazwy domeny przy użyciu właściwości
Domain
. Jeśli więc napisałbyś taki
kod:
Response.Cookies("SearchCriteria").Domain = "whatever.com"
to przekazywanie cookies zostałoby ograniczone jedynie do domeny whatever.com. Możemy pójść dalej i
ograniczyć cookie do wyszczególnionej ścieżki katalogu wykorzystując właściwość
Path
. Jeśli chcielibyśmy
ograniczyć przesyłanie cookie do katalogu o nazwie Docs, kod byłby taki:
Response.Cookies("SearchCriteria").Path = "/docs/"
Ostatnią właściwością zbioru Cookies, którą należy omówić jest
Secure
. Ta boole’owska właściwość
zapamiętuje, czy cookie został bezpiecznie przesłany bądź otrzymany. Kod jest następujący:
Response.Cookies("SearchCriteria").Secure = FALSE
Właściwości obiektu Response
Właściwości obiektu pozwalają na kontrolę sposobów wysyłania danych do przeglądarki odwiedzającego.
Właściwości zostały omówione poniżej, a podsumowano je w tabeli 6.2.
Tabela 6.2. Właściwości obiektu
Response
Właściwość Przeznaczenie
Buffer
Właściwość boole’owska określająca czy wyjście ASP jest
wysłane zaraz po pojawieniu się, czy jako blok.
CacheControl
Używana do wskazania informacji dotyczących buforowania
dla serwerów proxy.
Charset
Używana do ustalenia typu znaków, który jest dołączany do
nagłówka typu zawartości.
ContentType
Określa nagłówek typu zawartości, który ustala typ danych
zwracanych, na przykład HTML, obraz.
Expires
Okres ważności buforowanej strony w minutach.
ExpiresAbsolute
Określona data i czas (lub jedno z nich) upłynięcia okresu
ważności buforowanej strony.
IsClientConnected
Właściwość boole’owska sprawdzająca, czy klient w dalszym
ciągu jest połączony z witryną.
PICS
Dołącza pola etykiety PICS do zwracanych nagłówków.
Status
Nagłówek wiersza stanu zwracany do przeglądarki.
Właściwość Buffer
Właściwość
Buffer
jest boole’owską właściwością, określającą czy wyjście strony ASP jest wysyłane na
bieżąco podczas uruchamiania, czy jest zapamiętywane dopóki cały kod nie będzie kompletny lub nie zostanie
ASP – Kompendium programisty
185
wywołana metoda
Flush
. Używając właściwości
Buffer
, musisz to zrobić przed wpisaniem jakiejkolwiek
informacji do przeglądarki.
Jak stwierdzono wcześniej, jest to właściwość boole’owska, co oznacza, że może przyjmować dwie wartości:
prawdę (True) i fałsz (False). Spójrzmy na dwa przykładowe bloki kodów różniących się między sobą
ustawieniem właściwości
Buffer
. Pierwszy kod jest buforowany.
<%
Option Explicit
Response.Buffer = True
Response.Write "Zapytanie uruchomione…"
Dim conn
Dim RSTotalSales
set conn = server.createobject ("adodb.connection")
conn.open "Sales", "sa", "YourPassword"
set RSTotalSales = conn.Execute("select Sum(TotalAmount) as
TotalSales " _
& "from Sales")
Response.Write RSTotalSales("TotalAmount")
%>
Scenariuszem tego bloku kodu jest prezentowanie strony ukazującej całkowitą kwotę sprzedaży dla wszystkich
rekordów w tabeli bazy danych. Szacowany czas zapytania będzie wynosił 20 sekund. Bufor jest włączony.
Kiedy więc kod dojdzie do tego wiersza:
Response.Write "Zapytanie uruchomione..."
tekst jest umieszczany w buforze i nie jest wysyłany do przeglądarki. Kod jest kontynuowany i 20 sekund
później jego działanie jest zakończone. Tekst
Zapytanie uruchomione…
, jak również wynik zapytania są w tym
momencie wysyłane do przeglądarki.
Teraz zwróć uwagę na działanie tego bloku kodowego:
<%
Option Explicit
Response.Buffer = False
Response.Write "Zapytanie uruchomione…"
Dim conn
Dim RSTotalSales
set conn = server.createobject ("adodb.connection")
conn.open "Sales", "sa", "YourPassword"
set RSTotalSales = conn.Execute("select Sum(TotalAmount) as
TotalSales " _
& "from Sales")
Response.Write RSTotalSales("TotalAmount")
%>
Kiedy kod dojdzie do wiersza:
Response.Write "Zapytanie uruchomione..."
tekst natychmiastowo wysłany jest do przeglądarki. teraz więc goście otrzymują informację o tym, że coś się
dzieje w czasie ich oczekiwania na zakończenie działania zapytania. Ta technika udzielania gościom
stopniowego sprzężenia zwrotnego jest bardzo ważna przy procedurach, których czas działania zajmuje więcej
Rozdział 6 – Obiekt Response
186
niż kilka sekund. Bez takiego sprzężenia, szczególnie w Internecie, goście mogliby stwierdzić, że coś poszło
nie tak i opuszczą twoją witrynę.
Właściwość CacheControl
Wielu użytkowników uzyskuje dostęp do Internetu poprzez serwer proxy. Przekazują oni swe żądanie przez
przeglądarkę, która następnie wysyła je do serwera proxy, pełniącego rolę ‘lejka’ dla wielu komputerów
wysyłających żądania do Internetu. Jedną z rzeczy przechowywanych przez proxy jest podręczna pamięć stron,
do których dostępu żądali jego użytkownicy. Zamiast więc wyszukiwać wielokrotnie tą samą stronę w
Internecie, proxy jedynie zwraca buforowaną stronę tej osobie, która wystosowała żądanie.
Działa to zazwyczaj dobrze, gdy masz do czynienia ze statycznymi stronami HTML, chociaż przy
dynamicznych stronach ASP często nie będziesz chciał ich buforować. Właściwość
CacheControl
jest
sposobem na poinstruowanie serwera proxy o tym, czy zastosować buforowanie. Kod musi występować przed
HTML-em, a jego forma jest następująca:
Response.CacheControl = "Public"
lub
Response.CacheControl = "Private"
Domyślnym ustawieniem właściwości jest
Private
, co oznacza, że zawartość nie powinna być buforowana.
Jeśli chcesz buforować tekst twojej strony ASP, po prostu ustal dla właściwości wartość
Public
.
Właściwość Charset
Właściwość
Charset
pozwala na modyfikację parametru o tej samej nazwie w nagłówku typu zawartości. Kod
ma następującą składnię:
Response.Charset = "CharSetValue"
CharSetValue
reprezentuje nazwę zestawu znaków, którego chcesz użyć. Jeśli użyjesz więcej niż jednego
wiersza kodu modyfikującego właściwość
Charset
, tylko ostatnia wartość będzie zastosowana. Ponieważ
wiersz kodu modyfikuje nagłówek, musi on poprzedzać HTML wysyłany do przeglądarki.
Właściwość ContentType
Kiedy odsyłasz zawartość do przeglądarki, bez względu na to czy jest to HTML czy twój kod, określasz typ
zawartości, który informuje przeglądarkę i rodzaju zwracanych danych. Wysyłasz HTML, obrazek, wideo,
audio? O tym poinformuje przeglądarkę właśnie typ zawartości.
Możesz ustawić tą wartość w kodzie używając właściwości
ContentType
. Jeśli na przykład chciałbyś zaznaczyć,
że wysyłałeś HTML, kod wyglądałby tak:
Response.ContentType = "text/HTML"
Jeśli chciałbyś zasygnalizować wysłanie obrazu gif, kod byłby taki:
Response.ContentType = "image/GIF"
Domyślną wartością dla tej właściwości jest
text/HTML
. Pierwsza część wartości określa typ, a druga podtyp
zawartości. Tabela 6.3. wyszczególnia główne typy.
Tabela 6.3. Typy zawartości
ASP – Kompendium programisty
187
Typ Definicja
Application
Nieokreślona informacja binarna.
Audio
Przesyłane dane obejmują format audio.
Image
Transmitowana jest grafika, zazwyczaj
plik gif lub jpeg.
Message
Treść wiadomości.
Multipart
Dane przesyłane łączą w sobie różne
typy.
Text
Wysyłany jest sam tekst, zwykły lub
HTML.
Video
Przesyłane dane mają format video, taki
jak avi lub mpeg.
Właściwość Expires
Przeglądarka odwiedzającego zawiera pamięć podręczną, która jest obszarem pamięci systemu gościa
przechowującym poprzednio przeglądane strony. Pozwala to gościom na przegląd danej strony WWW bez
konieczności ponownego jej ładowania pod warunkiem, że się nie zmieniła.
Przy stronach HTML zazwyczaj działa to świetnie — strona znajduje się w buforze dopóki nie musi być
uaktualniona, a wtedy ładowana jest ponownie. Jednak przy stronach ASP będziesz potrzebował lepszej
kontroli nad czasem pozostawania strony w podręcznej pamięci gościa przed jej bezpośrednim uaktualnieniem
na twoim serwerze. Jednym ze sposobów na zrealizowanie tego zadania jest właściwość
Expires
ustalająca
czas w minutach, podczas którego strona będzie dostępna w podręcznej pamięci odwiedzającego.
Właściwość ma następującą składnię:
Response.Expires = NumMinutes
gdzie
NumMinutes
określa ilość minut buforowania strony.
Za przykład weźmy prosty przykład kodu:
<%
Response.Expires = 2
Response.Write Now
%>
Wynik wykonania kodu prezentuje rysunek 6.4.
Rozdział 6 – Obiekt Response
188
Rysunek 6.4. Wyjście kodu używającego właściwości
Expires
Kod wpisuje do przeglądarki aktualne wartości daty i godziny systemu operacyjnego serwera. Zauważ jednak,
że wartość właściwości
Expires
wynosi 2. Jeśli gość zamknie przeglądarkę i powróci do strony wciągu dwóch
minut, zobaczy dokładnie tą samą datę i godzinę. Jeśli powróci do strony po czasie większym niż dwie minuty,
strona będzie uaktualniona.
W ten sposób właściwość ustala zakres czasu, który musi upłynąć zanim strona będzie uaktualniona, chyba że
gość naciśnie przycisk Odśwież (Refresh) swojej przeglądarki. Ten typ kodu jest użyteczny w sytuacjach, kiedy
masz stronę, która jest częściej wywoływana niż zmieniana. Twoja strona może być buforowana przez czas tylu
minut, w którym jej zawartość będzie poprawna.
Właściwość ExpiresAbsolute
Kolejną metodą definiowania czasu buforowania strony jest właściwość
ExpiresAbsolute
, która umożliwia
ustalenie granicznej daty lub godziny (lub obu tych wartości) poprawności strony, w następującej formie:
Response.ExpiresAbsolute = "5/14/2004 14:13"
Poprawne użycie tej właściwości może zaoszczędzić serwerowi niepotrzebnego zajmowania pasma oraz
zbędnego przetwarzania wysyłanej strony w sytuacjach, kiedy strona jest zmieniana raz na jakiś czas. Na
przykład twoja witryna może mieć stronę z prognozą pogody. Tak strona może się zmieniać tylko jeden raz
dziennie. Jeśli odwiedzający powróci na stronę w ciągu tego samego dnia, nie zajdzie potrzeba ponownego
wysyłania strony. Może ona znajdować się po prostu w pamięci podręcznej.
Albo powiedzmy, że dysponujesz stroną zawierającą listę zajęć, która jest uaktualniana co piątek. Jeśli ktoś
przeglądał stronę w poniedziałek, nie będziesz chciał aby serwer wysyłał mu tą stronę ponownie w przeciągu
całego tygodnia aż do piątku. Aby rozwiązać ten problem, mógłbyś stworzyć następujący kod:
<%
Option Explicit
Dim TheExpireDate
If WeekDay(Date) = 1 then
TheExpireDate = DateAdd("d", 5, Date)
ElseIf WeekDay(Date) = 2 then
TheExpireDate = DateAdd("d", 4, Date)
ElseIf WeekDay(Date) = 3 then
ASP – Kompendium programisty
189
TheExpireDate = DateAdd("d", 3, Date)
ElseIf WeekDay(Date) = 4 then
TheExpireDate = DateAdd("d", 2, Date)
ElseIf WeekDay(Date) = 5 then
TheExpireDate = DateAdd("d", 1, Date)
ElseIf WeekDay(Date) = 6 then
TheExpireDate = DateAdd("d", 7, Date)
Else
TheExpireDate = DateAdd("d", 6, Date)
End If
Response.ExpiresAbsolute = TheExpireDate
%>
Na wstępie korzystamy z dyrektywy
Option Explicit
, która informuje kompilator o tym, że zamierzamy
deklarować wszystkie nasze zmienne:
Option Explicit
Następnie deklarujemy zmienną
TheExpireDate
, która zapamiętuje datę upłynięcia ważności strony:
Dim TheExpireDate
Pamiętaj, że strona z listą zajęć jest uaktualniana w każdy piątek, skoro więc aktualną datą jest niedziela, strona
utraci ważność za pięć dni:
If WeekDay(Date) = 1 then
TheExpireDate = DateAdd("d", 5, Date)
Jeśli poniedziałek, strona straci ważność za cztery dni:
ElseIf WeekDay(Date) = 2 then
TheExpireDate = DateAdd("d", 4, Date)
Jeśli aktualnym dniem jest wtorek, brakuje trzech dni do piątku:
ElseIf WeekDay(Date) = 3 then
TheExpireDate = DateAdd("d", 3, Date)
W środę należy dodać dwa dni do aktualnego dnia:
ElseIf WeekDay(Date) = 4 then
TheExpireDate = DateAdd("d", 2, Date)
Dodajemy jeden dzień, jeśli aktualnym dniem w systemie jest czwartek:
ElseIf WeekDay(Date) = 5 then
TheExpireDate = DateAdd("d", 1, Date)
W piątek strona pozostanie aktualna przez cały tydzień:
ElseIf WeekDay(Date) = 6 then
TheExpireDate = DateAdd("d", 7, Date)
Rozdział 6 – Obiekt Response
190
Aby została wykonany warunek instrukcji
Else
, musi być sobota. Dodajemy więc sześć dni:
Else
TheExpireDate = DateAdd("d", 6, Date)
Następnie kod używa zmiennej
TheExpireDate
w celu ustawienia właściwości
ExpiresAbsolute
:
Response.ExpiresAbsolute = TheExpireDate
Właściwość IsClientConnected
Właściwość
IsClientConnected
informuje o tym, czy gość w dalszym ciągu jest połączony z twoją witryną. Ta
właściwość boole’owska, przeznaczona jedynie do odczytu, zwraca prawdę lub fałsz. Jeśli wartością zwracaną
jest prawda, gość cały czas jest połączony. Jeśli wartością jest fałsz, gość opuścił twoją stronę.
Właściwość zazwyczaj używana jest w instrukcji
If
w ten sposób:
If Response.IsClientConnected = True then
Pamiętaj jednak, że instrukcja
If
oblicza wyrażenie, tak więc wystarczy napisać:
If Response.IsClientConnected then
Możesz użyć tej właściwości w stronach o kodzie, którego uruchomienie może zająć więcej niż kilka sekund.
Jeśli gość opuści stronę podczas działania kodu, jego działanie powinno być wstrzymane w celu oszczędzenia
zasobów serwera. Spójrz na ten blok kodowy:
<%
Option Explicit
Dim conn
Dim RSTotals
Response.Buffer = False
set conn = server.createobject ("adodb.connection")
conn.open "Sales", "sa", "yourpassword"
set RSTotals = conn.Execute("select Sum(Sales) as TotalSales from Sales99")
response.write RSTotals("TotalSales") & "<P>"
If Response.IsClientConnected Then
set RSTotals = conn.Execute("select Sum(Sales) as TotalSales from Sales98")
response.write RSTotals("TotalSales") & "<P>"
If Response.IsClientConnected Then
set RSTotals = conn.Execute("select Sum(Sales) as TotalSales from Sales97")
response.write RSTotals("TotalSales") & "<P>"
End If
End If
%>
Na początku deklaracja pary zmiennych przy użyciu dyrektywy
Option Explicit
:
Option Explicit
Dim conn
Dim RSTotals
ASP – Kompendium programisty
191
Scenariusz strony jest następujący: chcemy uruchomić kilka zapytań, a każde z nich zajmie trochę czasu, tak
więc nie chcemy, aby strona była buforowana. Chcielibyśmy, aby goście widzieli wynik każdego zapytania w
chwili ich pojawiania się, buforowanie jest więc wyłączone:
Response.Buffer = False
Następnie łączymy się z bazą danych i uruchamiamy zapytanie:
set conn = server.createobject ("adodb.connection")
conn.open "Sales", "sa", "yourpassword"
set RSTotals = conn.Execute("select Sum(Sales) as TotalSales from Sales99")
Wtedy kod wysyła wynik zapytania do przeglądarki:
response.write RSTotals("TotalSales") & "<P>"
Dalej musimy się upewnić, czy gość w dalszym ciągu jest połączony, ponieważ nie chcemy uruchamiać
następnego zapytania, jeśli opuścił on stronę:
If Response.IsClientConnected Then
Jeśli gość jest połączony, uruchamiane jest kolejne zapytanie, a jego wynik wpisywany jest do przeglądarki:
set RSTotals = conn.Execute("select Sum(Sales) as TotalSales from Sales98")
response.write RSTotals("TotalSales") & "<P>"
W końcu kod sprawdza, czy gość jest połączony ze stroną przed uruchomieniem ostatniego zapytania:
If Response.IsClientConnected Then
set RSTotals = conn.Execute("select Sum(Sales) as TotalSales from Sales97")
response.write RSTotals("TotalSales") & "<P>"
Właściwość PICS
Właściwość
PICS
umożliwia dodanie etykiety PICS do nagłówka odpowiedzi. Właściwość ma następującą
składnię:
Response.PICS = Wartość
gdzie
Wartość
reprezentuje tekst etykiety PICS, którą chcesz dodać.
Ogólnie rzecz biorąc etykiety PICS używane są do określenia wartości znamionowej pod kątem zawartości.
Niektóre przeglądarki i niezależne narzędzia dodatkowe wyszukują taki znacznik w celu określenia, czy
wyświetlić stronę filtrując ją na podstawie informacji pochodzących od gościa, jak to jest w wypadku
rodzicielskiej kontroli zawartości stron.
Użyłbyś ten znacznik na stronie ASP, która miałaby zmienną zawartość w zależności od twojego kodu. Aby
dowiedzieć się nieco więcej o systemach wskaźników, możesz odwiedzić stronę Recreational Software
Advisory Council (http://www.rsac.org).
Rozdział 6 – Obiekt Response
192
Właściwość Status
Ostatnią właściwością obiektu
Response
jest
Status
, która pozwala na ustalenie wartości zwracanego nagłówka
stanu. Mógłbyś na przykład użyć takiego kodu, aby przeglądarka myślała, że strona nie została znaleziona:
Response.Status = 404
Ten kod wytworzy wyjście pokazane na rysunku 6.5. Może to być użyteczne w okolicznościach dynamicznego
tworzenia warunku, który w rzeczywistości nie jest prawdziwy. Ustawienie stanu może być również użyteczne
podczas debuggingu w celu stwierdzenia co się stanie, jeśli wystąpi określony stan.
Rysunek 6.5. Wynik
ustawienia wartości statusu 404 widziany w przeglądarce Internet Explorer 5
Metody obiektu Response
Metody obiektu
Response
zostały omówione poniżej, a podsumowano je w tabeli 6.4.
Tabela 6.4. Metody obiektu
Response
Metoda Definicja
AddHeader
Pozwala na dodanie własnego, dostosowanego nagłówka do
odpowiedzi.
AppendToLog
Ta metoda zapewnia możliwość wpisania informacji do
dziennika zdarzeń systemu NT.
BinaryWrite
Metoda używana do wysyłania informacji nietekstowych do
przeglądarki.
Clear
Usuwa dowolne buforowane wyjście.
End
Zatrzymuje dowolne przetwarzanie kodu strony ASP.
Flush
Wysyła zawartość bufora do przeglądarki.
Redirect
Odsyła przeglądarkę do innej strony.
Write
Wysyła tekst do przeglądarki.
ASP – Kompendium programisty
193
Metoda AddHeader
Możesz użyć metody
AddHeader
aby dodać do wyjścia strony HTML swój własny, dostosowany do własnych
potrzeb nagłówek. Metoda przyjmuje następującą formę:
Response.AddHeader NameOfHeader, ValueOfHeader
NameOfHeader
jest nazwą, którą chcesz użyć dla nagłówka, a
ValueOfHeader
jest wartością wysyłaną do
nagłówka. Ponieważ metoda ta wpisuje treść do nagłówka HTTP, musi występować przed każdym wyjściem
HTML. Na przykład kod:
Response.AddHeader "StorageValue", "Red63"
stworzy pozycję nagłówka o nazwie
StorageValue
i
wartości
Red63
.
Metoda AppendToLog
Bardzo poręczna metoda
AppendToLog
pozwala na dodanie tekstu do dziennika zdarzeń serwera WWW dla
określonego żądania. Tekst może mieć do 80 znaków i nie mogą znaleźć się w nim przecinki. Metoda ma
następującą formę:
Response.AppendToLog Text2Add
Text2Add
jest zmienną zawierającą tekst, który chcesz dodać do dziennika zdarzeń. Aby skorzystać z tej funkcji,
musisz włączyć rejestrację dla tej witryny, w której strona jest ulokowana. Możesz to zrobić poprzez Konsolę
zarządzania Microsoftu wybierając Witrynę WWW (Web Site), a następnie klikając ją prawym przyciskiem i
zaznaczając Właściwości (Properties). Przejdź do zakładki Witryna WWW (Web Site), a wtedy ukaże się dialog
pokazany na rysunku 6.6. Upewnij się czy zaznaczyłeś kratkę Włącz rejestrację (Enable Logging).
Rysunek 6.6. Właściwości witryny WWW
Gdybyś napisał taki kod:
Response.AppendToLog "mymessage"
to w dzienniku zdarzeń formatu W3C znalazłaby się następująca pozycja:
1999-08-14 16:27:40 207.66.52.164 – W3SVC3 NETSTATS2000
204.238.18.144 GET
/aspbook/c6/logtry.asp mymessage 200 0 429 382 47088 80 HTTP/1.1
Mozilla/4.0+(compatible;+MSIE+5.0;+Windows+98;+DigExt)
Login=FAVCAT=Music&USERNAME=Dave+Smith;
+NSCookie=207%2E66%2E52%2E130%3A8%2F14%2F99+9%3A45%3A50+AM;
+ASPSESSIONIDQGQQQQPF=GACBAFHAFIIOKEDDDBPAMJHJ –
Zauważ, że dodany do dziennika tekst znajduje się w środku tej pozycji i jest pogrubiony. Poza tym zwróć
uwagę na to, że tekst pojawi się tylko w pozycji dziennika odnoszącej się do tej określonej strony.
Metoda BinaryWrite
Metoda
BinaryWrite
umożliwia wysyłanie nietekstowych, binarnych informacji do przeglądarki. Metoda ma
następującą formę:
Response.BinaryWrite DateToWrite
Rozdział 6 – Obiekt Response
194
Bardzo ciekawym sposobem wykorzystania tej funkcji jest możliwość umieszczenia znacznika ASP jako źródła
obrazka w standardowej stronie HTML.
Za przykład weźmy witrynę WWW posiadającą stronę pogodową podobną do tej pokazanej na rysunku 6.7. Ta
prosta strona stworzona została na bazie HTML-a:
<HMTL>
<HEAD>
</HEAD>
<BODY>
<IMG SRC="./mount71.gif">
</BODY>
Znacznik obrazka zawiera zdjęcie reprezentujące aktualną pogodę. Znacznik ten mógłby być wyjściem strony
ASP, jeśli zmieniłbyś źródło obrazka w następujący sposób:
<IMG SRC="./weatherpict.asp">
Zmienna
DataToWrite
zawiera informację binarną, którą chcesz wysłać do przeglądarki. Zazwyczaj wysyła się
przeglądarce zamiast tekstu dane — obrazki lub dźwięk.
<TITLE>Pogoda</TITLE>
<P>Dzisiejsza pogoda:<P>
</HTML>
Rysunek 6.7. Strona z pogodą
Wtedy w stronie weatherpict.asp użyłbyś metody
BinaryWrite
, aby zwrócić binarną reprezentację
wyświetlanego obrazka w stronie HTML. Kod takiej strony ASP mógłby wyglądać w ten sposób:
<%
Option Explicit
Dim conn
Dim RSWeather
Dim ThePicture
ASP – Kompendium programisty
195
set conn = server.createobject ("adodb.connection")
conn.open "Pogoda", "sa", "yourpassword"
set RSWeather = conn.Execute("select PathToCurrentWeather from
WeatherCond" _
& "where WheatherDate = ‘" & Date & "'")
response.contenttype = "image/gif"
set ObjBin = server.createobject("bin.binary")
ThePicture = ObjBinReadFile(RSWeather("PathToCurrentWeather"))
response.binarywrite(ThePicture)
set ObjBin = Nothing
%>
Po pierwsze informujemy przeglądarkę o zamiarze deklarowania wszystkich naszych zmiennych:
Option Explicit
Następnie deklarowana jest para zmiennych bazy danych:
Dim conn
Dim RSWeather
Potem deklarowana jest zmienna, która będzie zapamiętywała binarne dane obrazka:
Dim ThePicture
Kod bazy danych wyszukuje obrazek reprezentujący aktualny stan pogodowy:
set conn = server.createobject ("adodb.connection")
conn.open "Pogoda", "sa", "yourpassword"
set RSWeather = conn.Execute("select PathToCurrentWeather from
WeatherCond" _
& "where WheatherDate = ‘" & Date & "'")
Domyślnie zwracana jest strona HTML. Strona ta wyświetli obrazek pokazujący warunki pogodowe, tak więc
typ zawartości musi być ustawiony w taki sposób, aby odzwierciedlał wartość zwracaną:
response.contenttype = "image/gif"
Następnie używamy jednego z wielu dostępnych na rynku niezależnych obiektów sterujących, pozwalającego
otworzyć plik binarny:
set ObjBin = server.createobject("bin.binary")
ThePicture = ObjBinReadFile(RSWeather("PathToCurrentWeather"))
W końcu plik binarny jest wpisywany do przeglądarki przy użyciu metody
BinaryWrite
obiektu
Response
:
response.binarywrite(ThePicture)
Rozdział 6 – Obiekt Response
196
Metoda Clear
Metoda
Clear
opróżnia bufor. Ponieważ metoda ta obsługuje bufor, musisz mieć włączoną właściwość
Buffer
,
w przeciwnym razie wystąpi błąd. Metoda ma następującą składnię:
Response.Clear
Spójrz na ten kod:
<%
Response.Buffer = True
Response.Write "Hello"
Response.Write " World!"
%>
Ten kod wysyła tekst
"Hello World!"
do przeglądarki. Ten kod:
<%
Response.Buffer = True
Response.Write "Hello"
Response.Clear
Response.Write " World!"
%>
wpisze do przeglądarki jedynie
"World!"
. Tekst
"Hello"
był w buforze, kiedy ten został opróżniony.
Teraz zwróć uwagę na ten kod:
<%
Response.Write "Hello"
Response.Clear
Response.Write " World!"
%>
Ten kod wywoła stan błędu, ponieważ bufor nie był włączony.
Metoda End
Metoda
End
obiektu
Response
nakazuje kompilatorowi zatrzymanie przetwarzania kodu. Przybiera ona
następującą formę:
Response.End
Wiemy, że kod użyty w poprzednim podrozdziale:
<%
Response.Write "Hello"
Response.Write " World!"
%>
wpisze do przeglądarki tekst
"Hello World!"
. Ale taki kod:
<%
Response.Write "Hello"
ASP – Kompendium programisty
197
Response.End
Response.Write " World!"
%>
wyświetli w przeglądarce jedynie tekst
"Hello"
.
Jeśli korzystasz z buforowania wyjścia, zawartość bufora wysyłana jest do przeglądarki w chwili wywołania
metody
End
. Metody tej używa się zazwyczaj w instrukcji
If
. Sprawdzasz jakiś warunek, a jeśli zostanie on
spełniony — kończysz przetwarzanie. Na przykład podczas dodawania rekordu pracownika do tabeli możesz
sprawdzać czy pewne pola są obecne lub czy mają określony typ. Jeśli nie, generujesz wiadomość o błędzie,
która jest wyświetlana odwiedzającemu i zatrzymujesz przetwarzanie.
Metoda Flush
W tym rozdziale przyjrzeliśmy się właściwościom kontrolującym czas wysyłania i jakość danych wysyłanych
do przeglądarki. Zwróciliśmy uwagę na właściwość
Buffer
, która pozwala przetrzymywać dane przed
wysłaniem ich do przeglądarki; metodę
Clear
opróżniającą bufor; ponadto metodę
End
wstrzymującą dalsze
przetwarzanie kodu.
Jeszcze jedna metoda pozwala na kontrolę zachowania wyjścia: metoda
Flush
, która natychmiastowo wysyła
dowolne buforowane wyjście do przeglądarki. Ponieważ metoda ta opróżnia bufor, wywoła ona stan błędu, jeśli
bufor będzie wyłączony. Metoda ma następującą składnię:
Response.Flush
Dzięki połączeniu właściwości
Buffer
i metody
Flush
możesz sprawować kompletną kontrolę nad tym, w
którym momencie różne wyniki kodów są wysyłane do przeglądarki.
Powiedzmy, że masz stronę wytwarzającą serie raportów w postaci tabel HTML, których treść oparta jest na
wynikach zapytań działających w bazie z danymi o sprzedaży. Taka strona mogłaby mieć wygląd podobny do
tego pokazanego na rysunku 6.8. Strona ładuje się 30 sekund. Każdy kolejny rok sprzedaży zajmuje 15 sekund,
a każdy miesiąc kolejnych kilka sekund. Zdecydowałeś, aby pokazywać gościowi dane każdego roku po
przetworzeniu ich jako pojedynczej jednostki. Możesz zrealizować to zadanie ustawiając dla właściwości
Buffer
wartość
True
. Następnie po kodzie każdego roku możesz zastosować metodę
Flush
w celu
natychmiastowego wysłania tych danych do przeglądarki.
Rozdział 6 – Obiekt Response
198
Rysunek 6.8. Raport sprzedaży
Metoda Redirect
Metoda
Redirect
wysyła przeglądarkę do innej strony w celu otrzymania odpowiedzi. Metoda ma następującą
formę:
Response.Redirect URL
W tym przypadku
URL
oznacza adres strony, do której przeglądarka jest odsyłana.
Metoda ta jest użyteczna w wielu rozmaitych przypadkach. Głównym przeznaczeniem metody jest
przetworzenie żądania w jakiś sposób, a następnie wysłanie osoby do innej strony, czasami nie będącej stroną
ASP.
Przykładowo możesz dysponować katalogiem wyświetlającym informacje o twoich produktach, ich cenę, opis
itd. Możesz mieć przycisk, przez który goście wysyłaliby zamówienie na dany produkt do strony ASP. Strona
zawierałaby również ikonę ze zdjęciem produktu. Taka strona pokazana jest na rysunku 6.9. Kiedy goście
kliknęliby ikonę produktu, zobaczyliby większy jego obraz. Zazwyczaj taka ikona jest łączem do obrazka.
Jednak dla informacji marketingowych być może będziesz chciał obserwować, jaka liczba gości żąda dostępu
do większego obrazka produktu.
Rysunek 6.9. Przykład katalogu produktów
Możesz to zrobić łącząc się ze stroną ASP, która zapamiętywałaby żądania w bazie danych, a następnie
readresowałaby gości do większego obrazka produktu.
Kolejnym częstym przykładem zastosowania metody
Redirect
są paski reklamowe (banery), które są obrazami
umieszczanymi w witrynie w celu reklamowania jakiejś innej witryny. Kiedy goście klikną baner, zostaną
przeniesieni na witrynę reklamowaną na pasku. Liczba gości, którzy kliknęli baner jest bardzo ważna,
ponieważ często używana jest ona do określenia opłaty za reklamę.
Prawdopodobnie chciałbyś mieć stronę ASP pomiędzy banerem a witryną reklamującego się. Kiedy goście
klikną baner, żądanie zostanie wysłane do strony ASP, która zapamięta to działanie. Następnie kod strony ASP
readresuje gościa do strony reklamodawcy.
ASP – Kompendium programisty
199
Metoda Write
Metoda
Write
(często używaną w ostatnich kilku rozdziałach) jest metodą, z której najprawdopodobniej
będziesz korzystał najczęściej. Umożliwia ona zwracanie do przeglądarki danych niebinarnych.
Metoda przyjmuje następującą formę:
Response.Write Text2Write
gdzie
Text2Write
jest tekstem, który chcesz wysłać do przeglądarki. Na przykład ten wiersz kodu:
Response.Write "Hello World!"
wyśle do przeglądarki tekst
"Hello World!"
w tym miejscu, gdzie kod został napisany. Możesz wypisywać
teksty, daty, liczby itd.
Możesz również wbudować HTML w tekst wysyłany przy użyciu metody
Write
:
Response.Write "<B>Hello World!</B>"
Ten wiersz kodu wypisze tekst
"Hello World!"
wraz ze znacznikami pogrubienia HTML.
Czasami musisz wstawić cudzysłów do ciągu znaków, który wysyłasz do przeglądarki. Możesz to zrobić w taki
sposób:
Response.Write "Bob mówi, ""Hello World!"""
Podwójny cudzysłów oznacza, że chcesz umieścić cudzysłów w cudzysłowie.
Obiekt Response w działaniu
W tym podrozdziale zwrócimy uwagę na kilka przykładów użycia metod, właściwości i zbioru obiektu
Response
, dzięki którym możesz stworzyć programy usługowe, gotowe do zastosowania od razu. Pierwszym
przykładem będzie dodanie obiektu wyboru do strony głównej, którego goście mogliby używać w celu
szybkiego odnajdywania ścieżki do najbardziej popularnych stron witryny.
Następnie rzucimy okiem na narzędzie implementujące pasek zaawansowania, który jest podobny do paska w
diagramie, ale wskazuje postęp w wykonywaniu zadania. Narzędzie to będzie wykorzystywało buforowanie.
Ponadto zwrócimy uwagę na stronę pozwalającą gościom zapamiętywać ich osobiste preferencje
przeszukiwania witryny. Zbiór
Cookies
używany jest do zapamiętywania ulubionych kolorów i czcionek, a
metoda
Write
— do dostosowania widoku strony.
Przypis
Ten podrozdział zawiera w swojej treści pewne obiekty i metody, które nie były jeszcze omówione. Użyto ich jednak tutaj, aby
przykłady były kompletne.
Readresowanie i obiekt wyboru
W tej przykładowej witrynie, strona główna zawiera standardowe łącza nawigacyjne z głównymi obszarami
witryny. Oprócz tego zawiera też obiekt sterujący Select, który goście wykorzystać mogą do przeglądu
najpopularniejszych stron witryny. Witryna wykorzystuje metodę
Redirect
podczas odsyłania gości do strony
wybranej w obiekcie sterującym. Używa ona również metody
Write
w celu wypełnienia obiektu. Strona główna
pokazana jest na rysunku 6.10.
Rozdział 6 – Obiekt Response
200
Rysunek 6.10. Strona główna wykorzystująca readresowanie przy użyciu obiektu wyboru
Obiekt sterujący Select, który wyświetla listę najpopularniejszych stron witryny WWW, zawiera informacje o
stronach i ich lokalizacji wzięte z tabeli bazy danych. Goście wybierają stronę z listy, a następnie, kiedy nacisną
przycisk Go, są do niej przenoszeni. Jedna z pozycji na liście to strona transakcji miesiąca. Kiedy zostanie ona
wybrana z listy, a gość naciśnie przycisk Go, zostanie przeniesiony do strony, która została pokazana na
rysunku 6.11.
Rysunek 6.11. Strona transakcji miesiąca ukazująca się po wybraniu jej w obiekcie wyboru
Obiekt Select jest wypełniany z tabeli bazy danych SQL Servera. Tabela zawiera nazwy stron wyświetlanych w
obiekcie oraz adresy URL w postaci wartości przekazywanych obiektowi.
Wyszczególnienie pól tabeli bazy danych prezentuje tabela 6.5.
ASP – Kompendium programisty
201
Tabela 6.5. Pola tabeli
C6Redirect
Nazwa pola Typ pola
Długość
PageName
varchar 100
PageUrl
varchar 100
Pole
PageName
zapamiętuje nazwę strony wyświetlany w obiekcie wyboru. Pole
PageUrl
przechowuje położenie
tej strony.
Kod strony głównej wyszukuje dane z tabeli
C6Redirect
.
<%
Option Explicit
Dim conn
Dim RSMostPopular
set conn = server.createobject ("adodb.connection")
conn.open "ASPBook", "sa", "yourpassword"
set RSMostPopular = conn.Execute("select * from C6Redirect")
%>
Na początku kod informuje kompilator o zamiarze deklarowania wszystkich naszych zmiennych:
Option Explicit
Następnie deklarowane są dwie zmienne, które wykorzystamy do łączenia się z bazą oraz wyszukiwania
potrzebnych danych:
Dim conn
Dim RSMostPopular
Teraz kod łączy się z bazą danych i wyszukuje informacje o najpopularniejszych stronach:
set conn = server.createobject ("adodb.connection")
conn.open "ASPBook", "sa", "yourpassword"
set RSMostPopular = conn.Execute("select * from C6Redirect")
Wyszukane w bazie dane są wykorzystywane w drugim bloku kodu tworzącym obiekt sterujący Select.
<SELECT NAME="RedirectTo">
<%
Do Until RSMostPopular.EOF
%>
<OPTION VALUE="<% response.write RSMostPopular("PageURL") %>">
<% response.write RSMostPopular("PageName") %></OPTION>
<%
RSMostPopular.MoveNext
Loop
%>
</SELECT>
Obiekt Select wywołuje pole
RedirectTo
:
<SELECT NAME="RedirectTo">
Rozdział 6 – Obiekt Response
202
Następnie kod uruchamia pętlę przechodzącą przez wszystkie rekordy tabeli najpopularniejszych stron:
<%
Do Until RSMostPopular.EOF
%>
Metoda
Write
obiektu
Response
używana jest przy dodawaniu opcji do obiektu wyboru. Zauważ, że metoda
Write
występuje w jednym wierszu z HTML-em. Poza tym zwróć uwagę na to, że dokonujemy dwóch wpisów
dla jednego rekordu: pierwszy zapamiętuje wewnętrzną wartość opcji — stronę, do której odsyłany jest gość po
dokonaniu wyboru; drugi wpis zawiera prezentowaną nazwę strony:
<OPTION VALUE="<% response.write RSMostPopular("PageURL") %>">
<% response.write RSMostPopular("PageName") %></OPTION>
Następnie kod przechodzi do kolejnego rekordu:
<%
RSMostPopular.MoveNext
Loop
%>
Tabela 6.6. ukazuje przykładowe rekordy, które mogą zostać umieszczone w tabeli bazy. Rekordy z tabeli 6.6.
wytworzą następujący HTML:
<SELECT NAME="RedirectTo">
<OPTION VALUE="./clearance.asp ">Sprzedaż</OPTION>
<OPTION VALUE="./deal_of_the_month.html">Transakcja miesiąca</OPTION>
<OPTION VALUE="../index.html">Numery telefonów</OPTION>
<OPTION VALUE="mailto:jsmith@whatever.com">E-mail</OPTION>
</SELECT>
Tabela 6.6. Przykładowe rekordy tabeli
C6Redirect
Strona Definicja
Sprzedaż
./clearance.asp
Transakcja miesiąca
./deal_of_the_month.html
Numery telefonu
../index.html
mailto:jsmith@whatever.com
Zwróć uwagę na pozycję
, która funkcjonuje jak łącze pocztowe i otwiera nową wiadomość
zaadresowaną według wartości pola.
Kiedy gość naciśnie przycisk Go, formularz jest przesyłany do strony redirectcombo.asp, jak to określono w
znaczniku
Form
:
<FORM NAME="LAYOUTFORM" ACTION="./redirectcombo.asp" METHOD=POST>
Kod tej strony readresuje gościa według wystosowanego żądania:
<%
If not isempty(Request.Form("RedirectTo")) Then
Response.Redirect Request.Form("RedirectTo")
else
ASP – Kompendium programisty
203
Response.Redirect "../index.html"
End If
%>
Wstępnie powyższy kod upewnia się, czy pole
RedirectTo
było przesłane wraz z formularzem:
If not isempty(Request.Form("RedirectTo")) Then
Jeśli tak, goście są odsyłani do adresu URL określonego w polu
RedirectTo
:
Response.Redirect Request.Form("RedirectTo")
W przeciwnym razie wprowadzili oni tą stronę w sposób nie pozwalający na dostęp do niej, są więc odsyłani
do strony głównej:
Response.Redirect "../index.html"
Pasek zaawansowania
Ta przykładowa strona pokazuje jak stworzyć pasek zaawansowania, który stanowiłby wizualny sygnał
postępu w wykonywaniu jakiegoś zadania. Narzędzie wykorzystuje metodę
Write
w celu sterowania wyjściem
HTML. Włącza również funkcję buforowania i przy użyciu metody
Flush
dokładnie kontroluje czas
ukazywania się wyjścia.
Kiedy goście wejdą na stronę, zobaczą widok pokazany na rysunku 6.12. Następnie strona rozpoczyna swój
długi proces tworzenia raportu. Pasek zaawansowania wskazuje jak daleko posunął się proces, jak to pokazano
na rysunku 6.13.
Rysunek 6.12. Pasek zaawansowania w początkowym stanie
Rozdział 6 – Obiekt Response
204
Rysunek 6.13. Pasek zaawansowania w połowie procesu
Pasek zaawansowania pokazuje odwiedzającemu, że strona cały czas pracuje aż do chwili, gdy proces się nie
zakończy, a wtedy ukaże się wynik prezentowany na rysunku 6.14.
Rysunek 6.14. Pasek zaawansowania w całości
Do stworzenia paska zaawansowania kod wykorzystuje opóźnienia czasowe symulujące działanie kodu
podczas tworzenia raportu. Pierwszy blok kodu jest następujący:
<%
Option Explicit
Response.Buffer = True
Dim DelayTime
ASP – Kompendium programisty
205
%>
Po pierwsze informujemy kompilator o deklarowaniu zmiennych:
Option Explicit
Następnie włączamy bufor, ponieważ będziemy używać metody
Flush
:
Response.Buffer = True
Tworzona jest również zmienna przechowująca czas opóźnienia potrzebny do symulacji długości procesu:
Dim DelayTime
Kolejny blok kodowy kreśli pasek zaawansowania:
<%
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Flush
DelayTime = Second(Time) + 10
If DelayTime > 59 Then
DelayTime = DelayTime - 60
End If
Do Until Second(Time) = DelayTime
Loop
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Flush
DelayTime = Second(Time) + 5
If DelayTime > 59 Then
DelayTime = DelayTime - 60
End If
Do Until Second(Time) = DelayTime
Loop
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Flush
DelayTime = Second(Time) + 16
If DelayTime > 59 Then
DelayTime = DelayTime - 60
End If
Do Until Second(Time) = DelayTime
Loop
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Flush
DelayTime = Second(Time) + 1
If DelayTime > 59 Then
DelayTime = DelayTime - 60
End If
Do Until Second(Time) = DelayTime
Rozdział 6 – Obiekt Response
206
Loop
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Flush
DelayTime = Second(Time) + 1
If DelayTime > 59 Then
DelayTime = DelayTime - 60
End If
Do Until Second(Time) = DelayTime
Loop
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Flush
DelayTime = Second(Time) + 1
If DelayTime > 59 Then
DelayTime = DelayTime - 60
End If
Do Until Second(Time) = DelayTime
Loop
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Flush
DelayTime = Second(Time) + 1
If DelayTime > 59 Then
DelayTime = DelayTime - 60
End If
Do Until Second(Time) = DelayTime
Loop
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Flush
%>
Na wstępie używamy tutaj metody
Write
w celu umieszczenia paska zaawansowania o pierwotnej długości, aby
nasz gość widział jakiś postęp w procesie już od samego początku.
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Zauważ, że metoda
Write
jest wpisana w znacznik obrazka HTML. Poza tym zastosowano tu podwójny
cudzysłów, co oznacza, że jeden cudzysłów znajduje się w drugim.
Ten znacznik HTML jest następnie wyprowadzany z bufora:
Response.Flush
Dalej, w celu symulacji dziesięciosekundowego opóźnienia, wyszukiwana jest ilość sekund w aktualnym
czasie, a do tej wartości dodawane jest 10:
DelayTime = Second(Time) + 10
Z powodu dodania wartości 10 do liczby sekund, ich ilość może przekroczyć 59, musimy to sprawdzić:
If DelayTime > 59 Then
ASP – Kompendium programisty
207
Jeśli liczba przekroczy 59, odejmowana jest wartość 60 w celu przywrócenia odpowiedniego zakresu sekund:
DelayTime = DelayTime – 60
Kod opóźnia swe działanie, aby zademonstrować użycie paska zaawansowania:
Do Until Second(Time) = DelayTime
Loop
Następnie obrazki określające postęp procesu są wpisywane do bufora podczas wykonywania tej części kodu:
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Response.Write "<IMG HEIGHT=12 WIDTH=10 SRC=""../assets/images/redbar2.gif"" BORDER=0>"
Później bufor zostaje opróżniony i powyższe wiersze kodu są wysyłane do przeglądarki:
Response.Flush
Proces powtarza się podczas całego okresu wykonywania zadania, aż do jego ukończenia. Tak jak widać w
bloku kodu, różnym jego fragmentom przekazywane są różne wielkości obrazka postępu. Powinieneś
zastosować ten typ uzupełniania długości paska w twoim bloku kodowym. Pomyśl o tym, jaki czas zajmie
wykonanie danego zadania i zastosuj odpowiednią szybkość postępowania paska, porównując ten całkowity
okres z czasami wykonania poszczególnych bloków.
Strona preferencji
Strona preferencji pokazuje w jaki sposób możesz zapamiętać ulubiony wygląd twojej witryny wybrany przez
gości, którym umożliwiono ustalenie czcionek i kolorów strony. Kiedy wracają na witrynę, jej widok oparty
jest na ich własnych preferencjach.
Strona używa zbioru
Cookies
do zapamiętania i wyszukania preferencji gości. W celu wyświetlenia zawartości
strony w formacie wymaganym przez odwiedzającego, wykorzystywana jest metoda
Write
.
Podczas pierwszych odwiedzin strony, goście widzą domyślny schemat kolorów ukazany na rysunku 6.15.
Rozdział 6 – Obiekt Response
208
Rysunek 6.15. Strona preferencji, widok początkowy
Goście mogą wybrać własny układ kolorów i czcionek. Kiedy nacisną przycisk Zapisz, ich preferencje są
zapamiętywane, a strona przybiera wybrany przez nich wygląd, jak to pokazano na rysunku 6.16.
Rysunek 6.16. Strona preferencji po dokonaniu przez gościa pożądanych zmian w widoku
Ponieważ preferencje zapamiętywane są w cookie, podczas następnych odwiedzin goście ujrzą widok strony
oparty na ich wyborze. Jeśli znacznik cookie zniknął lub goście odwiedzają stronę przy użyciu innego systemu,
ujrzą jej pierwotny widok z początkowym schematem kolorów.
Kod strony zapamiętuje i wyszukuje wartości znacznika cookie. Określa, czy formularz został przesłany i
podejmuje odpowiednie działanie w oparciu o warunek. Kod formatuje również samą stronę, bazując na
wyborze dokonanym przez gościa. Główny blok kodowy przedstawia się następująco:
<%
Option Explicit
Dim BackgroundColor
Dim LargeFontColor
Dim SmallFontColor
Dim LargeFont
Dim SmallFont
If IsEmpty(Request.Form("Save")) Then
If not len(Request.Cookies("Prefs")("BackgroundColor")) > 0 Then
Response.Cookies("Prefs")("BackgroundColor") = "#FFFFFF"
BackgroundColor = "#FFFFFF"
Response.Cookies("Prefs")("LargeFontColor") = "#000000"
LargeFontColor = "#000000"
Response.Cookies("Prefs")("SmallFontColor") = "#000000"
SmallFontColor = "#000000"
Response.Cookies("Prefs")("LargeFont") = "Arial,Helvetica,Univers,Zurich BT"
LargeFont = "Arial,Helvetica,Univers,Zurich BT"
Response.Cookies("Prefs")("SmallFont") = "Times New Roman,Times,Times NewRoman"
SmallFont = "Times New Roman,Times,Times NewRoman"
ASP – Kompendium programisty
209
Response.Cookies("Prefs").Expires = "2/2/2002"
Else
BackgroundColor =Request.Cookies("Prefs")("BackgroundColor")
LargeFontColor = Request.Cookies("Prefs")("LargeFontColor")
SmallFontColor = Request.Cookies("Prefs")("SmallFontColor")
LargeFont = Request.Cookies("Prefs")("LargeFont")
SmallFont = Request.Cookies("Prefs")("SmallFont")
End If
else
Response.Cookies("Prefs")("BackgroundColor") = Request.Form("BackgroundColor")
BackgroundColor = Request.Form("BackgroundColor")
Response.Cookies("Prefs")("LargeFontColor") = Request.Form("LargeFontColor")
LargeFontColor = Request.Form("LargeFontColor")
Response.Cookies("Prefs")("SmallFontColor") = Request.Form("SmallFontColor")
SmallFontColor = Request.Form("SmallFontColor")
Response.Cookies("Prefs")("LargeFont") = Request.Form("LargeFont")
LargeFont = Request.Form("LargeFont")
Response.Cookies("Prefs")("SmallFont") = Request.Form("SmallFont")
SmallFont = Request.Form("SmallFont")
Response.Cookies("Prefs").Expires = "2/2/2002"
end if
%>
Kod informuje kompilator o zamiarze deklarowania zmiennych:
Option Explicit
Następnie deklarowane są zmienne zapamiętujące preferencje gościa lub preferencje domyślne:
Dim BackgroundColor
Dim LargeFontColor
Dim SmallFontColor
Dim LargeFont
Dim SmallFont
Później określany jest stan. Jeśli przycisk Zapisz (Save) nie został naciśnięty, formularz nie jest przesyłany:
If IsEmpty(Request.Form("Save")) Then
Oznacza to, że mamy w tym miejscu pierwotny widok strony. Następnie kod sprawdza, czy gość dysponuje
znacznikiem cookie z zapisanymi w nim preferencjami, a robi to poprzez funkcję
Len
, testującą długość
jednego z podkluczy znacznika:
If not len(Request.Cookies("Prefs")("BackgroundColor")) > 0 Then
Jeśli cookie nie zostaje znaleziony, tworzony jest nowy znacznik zapamiętujący domyślne ustawienia w
systemie gościa:
Response.Cookies("Prefs")("BackgroundColor") = "#FFFFFF"
Następnie w zmiennej używanej do modyfikacji strony ustawiana jest domyślna preferencja:
Rozdział 6 – Obiekt Response
210
BackgroundColor = "#FFFFFF"
Ta sama metoda jest używana do zapamiętania wszystkich innych preferencji:
Response.Cookies("Prefs")("LargeFontColor") = "#000000"
LargeFontColor = "#000000"
Response.Cookies("Prefs")("SmallFontColor") = "#000000"
SmallFontColor = "#000000"
Response.Cookies("Prefs")("LargeFont")
"Arial,Helvetica,Univers,Zurich BT"
LargeFont = "Arial,Helvetica,Univers,Zurich BT"
Response.Cookies("Prefs")("SmallFont") = "Times New Roman,Times,
Times NewRoman"
SmallFont = "Times New Roman,Times,Times NewRoman"
Następnie ustalana jest data ważności dla cookie:
Response.Cookies("Prefs").Expires = "2/2/2002"
Przejście kodu do części
Else
instrukcji
If
drugiego poziomu oznacza, że goście właśnie weszli na stronę, ale
odwiedzali ją już wcześniej. Mają więc cookie z preferencjami i ten znacznik używany jest do ustawienia
zmiennych wykorzystywanych podczas definiowania widoku strony:
BackgroundColor =Request.Cookies("Prefs")("BackgroundColor")
LargeFontColor = Request.Cookies("Prefs")("LargeFontColor")
SmallFontColor = Request.Cookies("Prefs")("SmallFontColor")
LargeFont = Request.Cookies("Prefs")("LargeFont")
SmallFont = Request.Cookies("Prefs")("SmallFont")
Część
Else
głównej instrukcji
If
jest wykonywana, gdy spełniony będzie warunek przesłania formularza. W
tym przypadku przesłane wartości są wykorzystane do ponownego wypełnienia cookie:
Response.Cookies("Prefs")("BackgroundColor") = Request.Form("BackgroundColor")
Ustawiany jest również bieżący widok strony na podstawie domyślnych preferencji:
BackgroundColor = Request.Form("BackgroundColor")
To samo z innymi preferencjami:
Response.Cookies("Prefs")("LargeFontColor") = Request.Form("LargeFontColor")
LargeFontColor = Request.Form("LargeFontColor")
Response.Cookies("Prefs")("SmallFontColor") = Request.Form("SmallFontColor")
SmallFontColor = Request.Form("SmallFontColor")
Response.Cookies("Prefs")("LargeFont") = Request.Form("LargeFont")
LargeFont = Request.Form("LargeFont")
Response.Cookies("Prefs")("SmallFont") = Request.Form("SmallFont")
SmallFont = Request.Form("SmallFont")
Ustalana jest też data ważności cookie:
ASP – Kompendium programisty
211
Response.Cookies("Prefs").Expires = "2/2/2002"
W wierszu HTML strona może zostać sformatowana zgodnie z domyślnymi preferencjami lub preferencjami
gościa. Na przykład poniższy wiersz kodu ustala kolor tła:
<BODY BGCOLOR="<% Response.Write BackgroundColor %>">
A ten wiersz kodu ustawia czcionkę i kolor dla jednego z wierszy tekstu:
<FONT FACE="<% Response.Write LargeFont %>" Color="
<% Response.Write LargeFontColor %>">
Rozdział 7.
Obiekt Server
Wejście na szczyt
Do tej pory przyjrzeliśmy się obiektowi
Request
, który, jak mogłeś stwierdzić, pozwala na otrzymywanie
informacji o gościu. Poznaliśmy również obiekt
Response
, którego używamy do wysyłania informacji do
przeglądarki gościa. W tym rozdziale zwrócimy uwagę na kolejny element modelu obiektów ASP — obiekt
Server
.
Obiekt Server używa jednej właściwości i czterech metod pozwalających na komunikację z Internetowym
serwerem informacyjnym (IIS) i wykorzystanie jego funkcjonalności. Przez komunikację z serwerem IIS
rozumiemy możliwość zmiany sposobów jego pracy ze stroną. Funkcjonalność obiektu
Server
pozwala na
podjęcie takich działań w skrypcie, dla których sam skrypt nie posiada odpowiednich mechanizmów.
Rysunek 7.1. prezentuje rolę, jaką odgrywa obiekt
Server
w modelu przetwarzania strony ASP. Zgodnie z
modelem goście wpisują w przeglądarce stronę, którą chcą przeglądać bądź klikają łącze będące częścią innej
strony, która jest stroną ASP. Żądanie przemierza Internet podążając do twojego serwera. Ten następnie
wyszukuje pożądaną stronę i jeśli jest to strona ASP, rozpoczyna jej przetwarzanie. Obiekt
Server
odgrywa rolę
właśnie w tym momencie, kiedy strona jest przetwarzana. Obiekt pozwala włączyć inne składniki w proces
przetwarzania strony oraz komunikować się z samym serwerem. Przetworzona strona jest następnie wysyłana
do przeglądarki odwiedzającego.
1. Żądanie http://www.cds.com/sales.asp
2. Internet
3. IIS wyszukuje stronę ASP
4. IIS interpretuje stronę ASP i korzysta ze składników
Składniki
5. Internet
6. HTML w przeglądarce: Cześć Bob! Dzisiaj w sprzedaży mamy…
Rysunek 7.1. Rola obiektu
Server
w modelu obiektów ASP
Właściwość obiektu Server
Obiekt
Server
zawiera jedną tylko właściwość, która umożliwia komunikację z serwerem. Ta właściwość
została omówiona poniżej, a podsumowana jest w tabeli 7.1.
Tabela 7.1. Właściwość obiektu
Server
.
Właściwość
Przeznaczenie
ScriptTimeout
Czas uruchomienia strony ASP (w sekundach) przed jej
przeterminowaniem.
ASP – Kompendium programisty
213
Właściwość ScriptTimeout
Z różnorakich powodów przetwarzanie kodu może zająć dużo czasu. Serwer może być bardzo zajęty, składnik
może utknąć w pętli lub twój własny program może zawierać kod powtarzający się w nieskończoność. Głównie
z takich powodów być może ustalisz maksymalny czas działania twojego skryptu przed jego zatrzymaniem i
zwróceniem błędu przeglądarce wystosowującej żądanie.
Możesz ustalić ten czas uruchamiania na poziomie serwera WWW, przeglądając jego właściwości i naciskając
przycisk Konfiguracja (Configuration) w zakładce Katalog główny (Home Directory). W ten sam sposób
możesz ustawić tą właściwość na poziomie strony WWW. Możesz to również zrobić na poziomie aplikacji
ASP klikając prawym przyciskiem myszy wybraną aplikację w widoku Konsoli zarządzania Microsoftu
serwera IIS, a następnie zaznaczając Właściwości (Properties). Następnie, gdy przejdziesz do zakładki Katalog
(Directory) po naciśnięciu przycisku Konfiguracja (Configuration), zobaczysz dialog pokazany na rysunku 7.2.
Rysunek 7.2. Ustawianie maksymalnego czasu uruchamiania strony ASP
W zakładce Opcje aplikacji (App Options) tego dialogu znajduje się pole tekstowe o nazwie Czas
uruchamiania skryptu ASP (ASP Script Timeout). Tutaj możesz ustalić maksymalną ilość sekund uruchamiania
skryptu.
W swoim kodzie możesz zwiększyć ten czas uruchamiania przy użyciu właściwości
ScriptTimeout
obiektu
Server
. Właściwość ma następującą składnię:
Server.ScriptTimeout = NumberOfSeconds
Zmienna
ScriptTimeout
jest liczbą sekund, podczas których skrypt może być uruchamiany przed jego
przeterminowaniem.
Wartość tej właściwości możesz wyświetlić w oknie przeglądarki poprzez następujący kod:
<%
Response.Write "<B>Ta strona może być uruchamiana przez "
Response.Write Server.ScriptTimeout
Response.Write "sekund przed przeterminowaniem.</B>"
%>
Ta strona wypisze domyślną wartość właściwości, jak to pokazano na rysunku 7.3.
Rozdział 7 – Obiekt Server
214
Rysunek 7.3. Wyjście właściwości
ScriptTimeout
Możesz również określić wartość właściwości w kodzie zwiększając w ten sposób czas potrzebny na
zakończenie jego przetwarzania. Poniższy kod ustala ten maksymalny czas na poziomie 200 sekund:
<%
Server.ScriptTimeout = 200
Response.Write "<B>Ta strona może być uruchamiana przez "
Response.Write Server.ScriptTimeout
Response.Write "sekund przed przeterminowaniem.</B>"
%>
Wyjście tego kodu pokazuje, że wartość się zmieniła, co prezentuje rysunek 7.4. Wartość ta musi być liczbą
większą od zera, w przeciwnym wypadku wystąpi stan błędu.
Rysunek 7.4. Wyjście kodu programowo zmieniającego wartość właściwości
Metody obiektu Server
Obiekt
Server
posiada cztery metody, których możesz użyć podczas realizacji rozmaitych zadań. Są one
omówione poniżej, a podsumowano je w tabeli 7.2.
Tabela 7.2. Metody obiektu
Server
.
Metoda Przeznaczenie
CreateObject
Pozwala na tworzenie składników serwera.
HTMLEncode
Koduje tekst w formacie HTML.
MapPath
Zwraca fizyczną ścieżkę ścieżki wirtualnej bądź względnej.
URLEncode
Modyfikuje przekazany tekst tak, że jest on zakodowany w
formacie URL.
ASP – Kompendium programisty
215
Metoda CreateObject
Z tą metodą spotkałeś się już wielokrotnie w tej książce. W rzeczywistości bez tej metody strony ASP byłyby
tak ograniczone w swojej funkcjonalności, że mało kto chciałby z nich korzystać.
Metoda
CreateObject
pozwala na tworzenie egzemplarza składnika serwera, co oznacza obiekt znajdujący się
na serwerze, zwykle bibliotekę DLL, posiadającą własne obiekty, zbiory, metody, właściwości i zdarzenia.
Termin „tworzyć egzemplarz” oznacza możliwość dostępu do składnika serwera poprzez twój kod.
Składniki serwera można podzielić na trzy różne kategorie. Istnieją składniki będące częścią serwera IIS. Takie
składniki są specjalnie zaprojektowane tak, aby rozszerzać możliwości pracy ze stronami ASP. Łączą one w
sobie składnik możliwości przeglądarki, który dostarcza informacji o przeglądarce wysyłającej żądanie;
składnik rotatora ogłoszeń pozwalający umieścić na witrynie paski reklamowe i zarządzać nimi; oraz składnik
licznika stron, dzięki któremu można uzyskać informacje o trafnych odpowiedziach.
Drugim typem składników serwera są te, które zwiększają funkcjonalność strony, ale niekoniecznie są
zaprojektowane specjalnie na potrzeby stron ASP. Ten typ składników obejmuje Microsoft Word , którego
możesz użyć do sformatowania tekstu w formie dokumentu Word; Graph Generator, który tworzy ‘w locie’
wykres w oparciu o wyjście mogące znajdować się na twojej stronie WWW; oraz zaawansowany program
matematyczny dostarczający stronie wyniku obliczeń naukowych.
Ostatnim typem składników serwera będą te, które tworzysz sam. Przyjdzie czas, gdy będziesz potrzebował
stworzyć procedurę, której nie możesz wykonać w ramach strony ASP oraz nie znajdującej się na serwerze.
Czasami stworzysz taki składnik w celu ominięcia pewnych błędów i niedoborów w stronie ASP. Kolejnym
powodem tworzenia własnych składników serwera jest kapsułkowanie, które oznacza umieszczenie kodu w
jednym miejscu, a następnie używanie go w wielu innych położeniach; jeśli potem kod musi zostać zmieniony,
należy to uczynić tylko w jednym miejscu.
Metoda ma następujący format:
Set MyObject = Server.CreateObject(NameOfAppClass)
Deklarację musisz rozpocząć od kluczowego słowa
Set
. Jeśli tak nie zrobisz (łatwo o tym zapomnieć), wystąpi
błąd, co pokazano na rysunku 7.5.
Rysunek 7.5. Błąd metody
CreateObject
Dużym problemem związanym z wystąpieniem tego błędu jest fakt, że wiadomość o błędzie nie jest opisowa.
Poza tym nie wystąpi w tym miejscu, gdzie użyłeś instrukcji
CreateObject
, ale w miejscu pierwszego użycia
obiektu poprzez jego metody i właściwości.
Rozdział 7 – Obiekt Server
216
W poprzednim przykładzie ukazującym składnię
MyObject
jest zmienną, która staje się kopią obiektu serwera.
Poprzez metodę
CreateObject
przekazywany jest pojedynczy parametr
NameOfAppClass
. Ogólnie rzecz biorąc
jest on ciągiem zawierającym nazwę serwera i klasę, którą chcesz stworzyć w serwerze. Tak więc forma tego
ciągu będzie następująca:
Aplikacja.Klasa
Jeśli na przykład chciałbyś ustanowić połączenie z bazą danych, kod wyglądałby tak:
set Conn = server.createobject ("ADODB.Connection")
W tym przykładzie nazwą aplikacji serwera jest
ADODB
. Klasa tworzona nosi nazwę
Connection
. Ustanawiany
obiekt jest umieszczony w zmiennej
Conn
.
Spójrzmy na kolejny przykład:
set MyWord = server.createobject("Word.Application")
Tutaj zmienna
MyWord
będzie obiektem dostarczonym przez klasę o nazwie
Application
składnika serwera,
jakim jest Word.
Kiedy już stworzysz swój obiekt, możesz zacząć korzystać z jego metod, właściwości i zbiorów. Poniższy
przykład pokazuje jak można to zrobić.
<%
Option Explicit
Dim conn
Dim RSEmp
set conn = server.createobject ("adodb.connection")
conn.open "ASPBook", "sa", "yourpassword"
conn.execute "delete from Emps where EmpID = " & Request.Form("EmpID")
set RSEmp = conn.Execute("select * from Emps where EmpID = " _
& Request.Form("NewEmpID"))
Response.Write "<P>" & RSEmp("FirstName")
Response.Write "<P>" & RSEmp("LastName")
set conn = Nothing
set RSEmp = Nothing
%>
Na początku kompilator otrzymuje informację o zamiarze deklarowania naszych zmiennych. Pamiętaj, że
pomaga to bardzo podczas usuwania błędów ze stron ASP o dużej objętości:
Option Explicit
Następnie definiujemy dwie zmienne. Jedna z nich zapisuje obiekt połączenia w bazie danych:
Dim conn
Druga będzie przetrzymywała zestaw rekordów wzięty z bazy danych:
Dim RSEmp
Tutaj metoda
CreateObject
wykorzystana jest do stworzenia obiektu aplikacji ADODB z klasą
Connection
:
set conn = server.createobject ("adodb.connection")
ASP – Kompendium programisty
217
Kiedy już stworzyliśmy połączenie, możemy zacząć z niego korzystać. Tutaj metoda
Open
obiektu
Connection
jest używana przy połączeniu z określoną nazwą źródła danych:
conn.open "ASPBook", "sa", "yourpassword"
Następnie metoda
Execute
obiektu
Connection
jest używana do usuwania rekordu z bazy danych:
conn.execute "delete from Emps where EmpID = " & Request.Form("EmpID")
W następnym wierszu kodu ponownie korzystamy z metody
Execute
, ale tym razem zwraca ona kolejny obiekt:
set RSEmp = conn.Execute("select * from Emps where EmpID = " _
& Request.Form("NewEmpID"))
Zmienna
RSEmp
nie jest tworzona z metodą
CreateObject
, ale z metodą metody
Execute
obiektu połączenia.
Jednak
RSEmp
jest obiektem i to obiektem typu
Recordset
(zestawem rekordów). Typ ten łączy w sobie zbiór
Fields
, który używany jest do wyszukiwania danych w polach bazy:
Response.Write "<P>" & RSEmp("FirstName")
Response.Write "<P>" & RSEmp("LastName")
Ponieważ użyto tutaj obiektów, które są bardziej złożone od standardowych zmiennych zapamiętujących liczbę
lub tekst, korzystamy z większej ilości zasobów. Możesz zwolnić zasoby używane przez obiekt, porównując je
do wartości
Nothing
, jak tutaj:
set conn = Nothing
set RSEmp = Nothing
W następnym przykładzie kodu tworzona jest kopia obiektu CDO (Collaborative Data Object). Ten obiekt
wykorzystywany jest do wysyłania wiadomości e-mail poprzez twój kod i pracy z programem Microsoft
Exchange.
<%
Option Explicit
Dim objMail
Set objMail = Server.CreateObject("CDONTS.NewMail")
ObjMail.Send "susan@whatever.com", "jill@whatever.com", "Cześć",
"Jak się masz?"
Set objMail = Nothing
%>
Na początku instrukcja deklaracji zmiennych:
Option Explicit
Następnie tworzona jest zmienna przeznaczona do przetrzymywania obiektu e-mail:
Dim objMail
Metoda
CreateObject
użyta jest w celu stworzenia kopii klasy
NewMail
serwera CDONTS:
Set objMail = Server.CreateObject("CDONTS.NewMail")
Rozdział 7 – Obiekt Server
218
Następnie pojawia się metoda
Send
obiektu
objMail
, wysyłająca wiadomość e-mail. Metodzie przekazywane są
cztery parametry:
ObjMail.Send "susan@whatever.com", "jill@whatever.com", "Cześć", _
"Jak się masz?"
Później uwalniamy zasoby obiektu:
Set objMail = Nothing
Metoda HTMLEncode
Załóżmy, że twoja strona ASP wyświetlająca pytania quizu sprawdza, czy studenci rozumieją zasady
porównania numerycznego. Na przykład chciałbyś wyświetlić pytanie pokazane na rysunku 7.6.
Rysunek 7.6. Przykład strony quizu
Zauważ, że używamy znaków
<
i
>
, które oczywiście mają specjalne znaczenie na naszej stronie WWW. Jeśli
strona ASP zawierałaby poniższy kod, nie otrzymałbyś pożądanego wyjścia:
<%
Response.Write "Pytanie 1:" & "<P>"
Response.Write "P = 5, B = 8. Używając operatorów <, >, i =" _
& "określ relację pomiędzy liczbami P i B." & "<P>"
Response.Write "A. P<B" & "<P>"
Response.Write "B. P>B" & "<P>"
Response.Write "C. P=B" & "<P>"
%>
Zamiast tego otrzymasz stronę pokazaną na rysunku 7.7. Zauważ, że odpowiedzi nie znajdują się tam, gdzie
być powinny. Jest to spowodowane tym, że niektóre fragmenty tekstu zostały zinterpretowane przez
przeglądarkę jako znaczniki HTML.
ASP – Kompendium programisty
219
Rysunek 7.7. Nieprawidłowy tekst na stronie quizu
Możesz obejść ten problem stosując metodę
HTMLEncode
obiektu
Server
, która ma następującą składnię:
ConvertedText = Server.HTMLEncode(TextToConvert)
Zmienna
TextToConvert
jest tekstem, który chcesz konwertować.
ConvertedText
to zakodowany tekst HTML,
zwracany przez metodę. Jeśli więc poprawilibyśmy poprzedni kod w taki sposób:
<%
Response.Write "Pytanie 1:" & "<P>"
Response.Write "P = 5, B = 8. Używając operatorów <, >, i =" _
& "określ relację pomiędzy liczbami P i B." & "<P>"
Response.Write Server.HTMLEncode("A. P<B") & "<P>"
Response.Write Server.HTMLEncode("B. P>B") & "<P>"
Response.Write Server.HTMLEncode("C. P=B") & "<P>"
%>
to otrzymalibyśmy pożądane wyjście, ponieważ tekst posiadałby właściwie zakodowane sekwencje HTML,
mianowicie:
A. P<B<P>B. P>B<P>C. P=B<P>
Metoda MapPath
Metoda
MapPath
obiektu
Server
zamienia wirtualną lub względną ścieżkę widzianą przez serwer WWW na
rzeczywistą ścieżkę fizyczną. Metoda przyjmuje następującą formę:
ConvertedPath = Server.MapPath(PathToConvert)
Zmienna
PathToConvert
jest ścieżką, którą chcesz zamienić, a zmienna
ConvertedPath
jest ścieżką zamienioną
na jej katalog fizyczny.
Rozdział 7 – Obiekt Server
220
Na przykład:
<%
Response.Write "Ścieżka do katalogu nadrzędnego: " & "<BR>"
Response.Write Server.MapPath("../") & "<P>" & "<P>"
Response.Write "Ścieżka do katalogu bieżącego: " & "<BR>"
Response.Write Server.MapPath ("./") & "<P>" & "<P>"
Response.Write "Ścieżka do pliku w katalogu bieżącym: " & "<BR>"
Response.Write Server.MapPath ("myfile.txt") & "<P>" & "<P>"
Response.Write "Ścieżka do katalogu głównego: " & "<BR>"
Response.Write Server.MapPath ("/") & "<P>" & "<P>"
%>
Po pierwsze mapowana jest ścieżka do katalogu nadrzędnego:
Response.Write Server.MapPath("../") & "<P>" & "<P>"
Następnie ścieżka do katalogu bieżącego:
Response.Write Server.MapPath ("./") & "<P>" & "<P>"
Później mapujemy plik w katalogu bieżącym:
Response.Write Server.MapPath ("myfile.txt") & "<P>" & "<P>"
Na końcu mapujemy katalog macierzysty serwera:
Response.Write Server.MapPath ("/") & "<P>" & "<P>"
Wyjście kodu prezentuje rysunek 7.8.
Rysunek 7.8. Wyjście metody
MapPath
ASP – Kompendium programisty
221
Metoda URLEncode
Kiedy przesyłasz formularz metodą Post lub dostarczasz łącza z ciągiem zapytania, tekst w ciągu nie może
zawierać w sobie pewnych znaków, ponieważ staje się on częścią łącza.
Możesz na przykład chcieć wyszukać znaczenie zapisu
http://
i w tym celu korzystasz z wyszukiwarki. Gdy
wpiszesz taki ciąg i naciśniesz przycisk przesłania, ujrzysz rezultaty poszukiwań. Część łącza do wyniku
szukania jest twoim zapytaniem. Zauważ, że teraz twój ciąg
http://
został zamieniony na:
http%3A%2F%2F
Znak dwukropka zamieniony został na coś, co nie zostanie odrzucone ani nie zaskoczy przeglądarki i serwera.
Możesz zrealizować to zadanie manualnie w twoim kodzie przy użyciu metody
URLEncode
, która ma
następującą składnię:
ConvertedText = Server.URLEncode(Text2Convert)
Text2Convert
jest tekstem, który chcesz zamienić, a
ConvertedText
jest wynikiem metody. Za przykład weźmy
taki kod:
<%
Response.Write Server.URLEncode("Hello? World!") & "<P>"
Response.Write Server.URLEncode("http://www.whatever.com") & "<P>"
Response.Write Server.URLEncode("Yes, 10% of $20.") & "<P>"
Response.Write Server.URLEncode("';:[]{}") & "<P>"
%>
Wynik wykonania kodu pokazano na rysunku 7.9.
Rysunek 7.9. Wynik kodu używającego metody
URLEncode
Rozdział 7 – Obiekt Server
222
Obiekt Server w działaniu
Zanim przyjrzymy się kodowi, wcześniej zwrócimy uwagę na to, co właściwie ona ma robić. Kiedy goście po
raz pierwszy odwiedzają stronę, widzą menu pokazane na rysunku 7.10. Zawiera ona listę wszystkich
dostępnych formularzy listów. Jeśli gość wybrał list w sprawie bilansu, zobaczy formularz pokazany na
rysunku 7.11.
W tym podrozdziale zwrócimy uwagę na rozwiązania wykorzystujące obiekt
Server
i inne obiekty omówione
do tej pory. Przykład będzie używał metody
CreateObject
obiektu
Server
w celu stworzenia kopii Microsoft
Worda umożliwiającej kreowanie własnych dokumentów Word.
Automatyzacja biura
W tym przykładzie używamy serwera Microsoft Word w kodzie do wygenerowania dokumentu Word. Gość
przekazuje nam określone dane, które wykorzystamy w celu stworzenia dokumentu; ta informacja zostanie
połączona z szablonem dokumentu. Następnie dokument dostosowany do potrzeb klienta jest prezentowany
gościowi.
Kod wykorzystuje metodę
CreateObject
do stworzenia kopii Worda. Używa również metody
MapPath
obiektu
Server
w celu określenia fizycznego położenia wyjściowego dokumentu Word. Zastosowano także obiekty
Request
i
Response
, które wyszukują wejściowe dane gościa i odsyłają go odpowiedniego dokumentu Word.
Rysunek 7.10. Menu wyboru formularza listu
ASP – Kompendium programisty
223
Rysunek 7.11. Formularz listu w sprawie bilansu
Większość pól formularza bilansu odnosi się do zakładek w szablonie Worda, które zaznaczają te miejsca w
dokumencie, gdzie znajdą się teksty wpisane w poszczególne pola. Formularz przesyła wprowadzone dane z
powrotem do siebie w celu przetworzenia:
<FORM ACTION="./balance_due.asp" METHOD=POST>
Kod sprawdza czy został naciśnięty przycisk Prześlij i na tej podstawie określa, czy należy wyświetlić
formularz. Jeśli stwierdzono naciśnięcie przycisku, formularz musi być przesłany.
Kiedy gość naciska przycisk Prześlij, serwer ładuje kopię Worda w celu stworzenia dokumentu. Następnie gość
jest readresowany to tego dokumentu gdy tylko jest on ukończony, jak to pokazano na rysunku 7.12. Zwróć
uwagę na tekst strony. Zawiera ona dane wprowadzone w poprzednim formularzu. Kod umieszcza je w
określonych miejscach dokumentu Word zwanych zakładkami (bookmarks). Odpowiedni szablon tworzysz
poprzez menu programu Word, wybierając Wstaw (Insert), a następnie Zakładka (Bookmark) dokładnie w tym
miejscu, gdzie ma być wstawione określone pole formularza.
Rozdział 7 – Obiekt Server
224
Rysunek 7.12. Wygenerowany list w sprawie bilansu
Jeśli goście wybraliby w menu głównym list w sprawie opóźnienia płatności, ujrzeliby formularz pokazany na
rysunku 7.13. Następnie wprowadziliby dane konieczne w tym formularzu w celu wygenerowania dokumentu
Word zaprezentowanego na rysunku 7.14.
Rysunek 7.13. Formularz gromadzący dane potrzebne do stworzenia dokumentu Worda w sprawie opóźnienia
płatności
ASP – Kompendium programisty
225
Rysunek 7.14. Dokument formatu Word w sprawie opóźnienia płatności
Zauważ, że goście mogą wpisać w pola formularza dowolną treść. Poza tym, ponieważ wyjściowa strona
posiada format Worda, goście mogą ją drukować, zapisywać i modyfikować w jakikolwiek sposób. Kod dla
strony ASP formularza bilansu określa stan formularza. Jeśli został on przesłany, kod tworzy dokument Word i
readresuje gości do miejsca jego położenia.
Główny blok kodowy jest następujący:
<%
Option Explicit
Dim MyWord
Dim Path2File
Dim Path2File1
if not isempty(Request.Form("Submit")) then
set MyWord = Server.Createobject("Word.Application")
MyWord.Application.Documents.Open Server.MapPath("../") _
& "\balancedue.doc"
MyWord.ActiveWindow.Selection.GoTo -1,,, "CurrentDate"
MyWord.ActiveWindow.Selection.TypeText cstr(Date)
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersName"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("CustomersName"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersAddress"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("CustomersAddress"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersCSZ"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("CustomersCSZ"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "FirstName"
if instr(Request.Form("CustomersName"), " ") > 0 then
MyWord.ActiveWindow.Selection.TypeText _
Rozdział 7 – Obiekt Server
226
cstr(left(Request.Form("CustomersName"),instr(Request.Form
("CustomersName"), " ")-1))
else
MyWord.ActiveWindow.Selection.TypeText cstr
(Request.Form("CustomersName"))
end if
MyWord.ActiveWindow.Selection.GoTo -1,,, "CurrentBalance"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CurrentBalance"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "YourName"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("YourName"))
Path2File1 = Month(Date) & Day(Date) & Year(Date) _
& Hour(Time) & Minute(Time) & Second(Time) & ".doc"
Path2File = Server.MapPath("./") & "\" & Path2File1
MyWord.ActiveDocument.SaveAs Path2File
set MyWord = Nothing
Response.Redirect "./" & Path2File1
end if
%>
Po pierwsze informujemy kompilator o zamiarze deklaracji naszych zmiennych:
Option Explicit
Następnie deklarujemy zmienną przechowującą kopię serwera Word:
Dim MyWord
Dwie inne zmienne zapamiętują informację o nazwie generowanego pliku:
Dim Path2File
Dim Path2File1
Następnie sprawdzamy czy formularz został przesłany. Realizujemy to wyszukując przycisk Prześlij (Submit)
w zbiorze
Form
:
if not isempty(Request.Form("Submit")) then
Jeśli przycisk został naciśnięty, musimy stworzyć dokument Word. W tym celu należy ustanowić połączenie z
serwerem Word. Metoda
CreateObject
obiektu
Server
używana jest do połączenia z Wordem. Zmienna
MyWord
będzie zawierała naszą kopię serwera:
set MyWord = Server.Createobject("Word.Application")
Następnie metoda
Open
zbioru
Documents
, który jest zbiorem obiektu
Application
, który z kolei jest
podobiektem naszego obiektu
MyWord
, wykorzystywana jest do otwarcia szablonu dokumentu Worda o nazwie
balancedue.doc. Zwróć uwagę na metodę
MapPath
obiektu
Server
, która wykorzystywana jest podczas
określenia fizycznej ścieżki katalogu nadrzędnego:
MyWord.Application.Documents.Open Server.MapPath("../") _
& "\balancedue.doc"
ASP – Kompendium programisty
227
Następnie używamy metody
Goto
w celu znalezienia zakładek w dokumencie Word o nazwie
CurrentDate
,
który właśnie otwarliśmy:
MyWord.ActiveWindow.Selection.GoTo -1,,, "CurrentDate"
Bieżąca data, najpierw zamieniana na ciąg, umieszczana jest w tym miejscu:
MyWord.ActiveWindow.Selection.TypeText cstr(Date)
W następnej kolejności umieszczamy w szablonie dokumentu znacznik
CustomersName
:
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersName"
A w tym miejscu umieszczamy pole zbioru
Form
o nazwie
CustomersName
przekazane przez gościa w
formularzu:
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("CustomersName"))
W podobny sposób postępujemy z polami
CustomersAddress
i
CustomerCSZ
:
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersAddress"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CustomersAddress"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersCSZ"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CustomersCSZ"))
Następnie kod wstawia zakładkę
FirstName
:
MyWord.ActiveWindow.Selection.GoTo -1,,, "FirstName"
W tym miejscu musimy umieścić imię klienta. Dysponujemy jednak imieniem i nazwiskiem klienta. W kodzie
zakładamy, że jeśli pomiędzy imieniem i nazwiskiem znajduje się spacja, to wszystko przed nią jest imieniem.
Tak więc najpierw musimy sprawdzić, czy znak spacji znalazł się w tym polu:
if instr(Request.Form("CustomersName"), " ") > 0 then
Jeśli w ciągu znaków znalazła się spacja, umieszczamy cały tekst znajdujący po jej lewej stronie w zakładce,
używając przy tym metody
TypeText
obiektu
MyWord
:
MyWord.ActiveWindow.Selection.TypeText _
cstr(left(Request.Form("CustomersName"),_
instr(Request.Form("CustomersName"), " ")-1))
W innym wypadku po prostu umieszczamy w polu imię i nazwisko:
else
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("CustomersName"))
end if
Teraz poprzedni kod jest wykorzystywany ponownie w celu wypisania pól
CurrentBalance
i
YourName
:
MyWord.ActiveWindow.Selection.GoTo -1,,, "CurrentBalance"
Rozdział 7 – Obiekt Server
228
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("CurrentBalance"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "YourName"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("YourName"))
Teraz, kiedy stworzyliśmy już dokument Word, musimy zapisać plik w określonym fizycznym położeniu.
Nazwa pliku będzie oparta o bieżącą datę i czas:
Path2File1 = Month(Date) & Day(Date) & Year(Date) _
& Hour(Time) & Minute(Time) & Second(Time) & ".doc"
Następnie metoda
SaveAs
zapisuje nowo utworzony plik:
set MyWord = Nothing
Option Explicit
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersCSZ"
Ścieżka dostępu do pliku będzie taka sama jak do strony ASP. W celu wyszukania tego położenia korzystamy z
metody
MapPath
:
Path2File = Server.MapPath("./") & "\" & Path2File1
MyWord.ActiveDocument.SaveAs Path2File
Na końcu uwalniamy zasoby używane przez dokument:
Następnie gość jest readresowany do miejsca zapisania pliku:
Response.Redirect "./" & Path2File1
Podobny kod użyto dla strony ASP formularza opóźnienia płatności. Główny blok kodowy strony jest taki:
<%
Dim MyWord
Dim Path2File
Dim Path2File1
if not isempty(Request.Form("Submit")) then
set MyWord = Server.CreateObject("Word.Application")
MyWord.Application.Documents.Open Server.MapPath("../") _
& "\overdue.doc"
MyWord.ActiveWindow.Selection.GoTo -1,,, "CurrentDate"
MyWord.ActiveWindow.Selection.TypeText cstr(Date)
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersName"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CustomersName"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersAddress"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CustomersAddress"))
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CustomersCSZ"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "FirstName"
if instr(Request.Form("CustomersName"), " ") > 0 then
MyWord.ActiveWindow.Selection.TypeText_
cstr(left(Request.Form("CustomersName"),instr(Request.Form
("CustomersName"), " ")-1))
ASP – Kompendium programisty
229
else
MyWord.ActiveWindow.Selection.TypeText cstr
(Request.Form("CustomersName"))
Dim Path2File
end if
MyWord.ActiveWindow.Selection.GoTo -1,,, "DaysOverDue"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("DaysOverDue"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "DueDate"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("DueDate"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "YourName"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("YourName"))
Path2File1 = Month(Date) & Day(Date) & Year(Date) _
& Hour(Time) & Minute(Time) & Second(Time) & ".doc"
Path2File = Server.MapPath("./") & "\" & Path2File1
MyWord.ActiveDocument.SaveAs Path2File
set MyWord = Nothing
Response.Redirect "./" & Path2File1
end if
%>
Najpierw informujemy kompilator o zamiarze deklarowania naszym zmiennych:
Option Explicit
Następnie deklarujemy zmienną, która będzie przechowywała kopię Worda:
Dim MyWord
Również deklarowane są zmienne zapamiętujące informację o ścieżce dostępu do pliku:
Dim Path2File1
Później sprawdzamy przycisk Prześlij (Submit) używając przy tym funkcji
IsEmpty
, która zwraca prawdę, jeśli
pole formularza nie jest częścią zbioru. Operator
not
określa logikę odwrotną i wyrażenie jest wartością
prawdziwą, jeśli pole jest obecne:
if not isempty(Request.Form("Submit")) then
Następnie łączymy się z serwerem Word przy użyciu metody
CreateObject
:
set MyWord = Server.CreateObject("Word.Application")
Teraz używamy metody
MapPath
w celu wyszukania fizycznej lokalizacji pliku overdue.doc, bazując przy tym
na informacji, że znajduje się on w katalogu nadrzędnym tej strony ASP:
MyWord.Application.Documents.Open Server.MapPath("../") _
& "\overdue.doc"
Rozdział 7 – Obiekt Server
230
Następnie kod używa metody
Goto
, aby znaleźć w naszym szablonie dokumentu zakładkę o nazwie
CurrentDate
:
MyWord.ActiveWindow.Selection.GoTo -1,,, "CurrentDate"
Używając metody
TypeText
wstawiamy bieżącą datę w miejscu zakładki:
MyWord.ActiveWindow.Selection.TypeText cstr(Date)
Ta sama procedura przeprowadzana jest dla pól
CustomersName
,
CustomersAddress
i
CustomersCSZ
:
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersName"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CustomersName"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersAddress"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CustomersAddress"))
MyWord.ActiveWindow.Selection.GoTo -1,,, "CustomersCSZ"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form("CustomersCSZ"))
Później umieszczamy zakładkę, która zostanie użyta do wstawienia imienia gościa:
MyWord.ActiveWindow.Selection.GoTo -1,,, "FirstName"
Ponieważ dysponujemy jedynie pełnym imieniem i nazwiskiem gościa, jego imię musi być wyodrębnione
poprzez wypisanie wszystkich znaków znajdujących się po lewej stronie spacji:
if instr(Request.Form("CustomersName"), " ") > 0 then
MyWord.ActiveWindow.Selection.TypeText_
cstr(left(Request.Form("CustomersName"),instr(Request.Form
("CustomersName"), " ")-1))
else
MyWord.ActiveWindow.Selection.TypeText cstr
MyWord.ActiveWindow.Selection.GoTo -1,,, "DueDate"
MyWord.ActiveWindow.Selection.GoTo -1,,, "YourName"
Path2File1 = Month(Date) & Day(Date) & Year(Date) _
(Request.Form("CustomersName"))
end if
Następnie ustalamy kolejne zakładki i wstawiamy ich tekst w oparciu o zbiór formularza przesłany przez
odwiedzającego:
MyWord.ActiveWindow.Selection.GoTo -1,,, "DaysOverDue"
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("DaysOverDue"))
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("DueDate"))
MyWord.ActiveWindow.Selection.TypeText cstr(Request.Form
("YourName"))
Teraz musimy wymyślić niepowtarzalną nazwę dla dokumentu Worda, ponieważ nie chcemy, aby plik
szablonu został podmieniony. Nazwa jest liczbą tworzoną w oparciu o bieżącą datę i godzinę:
& Hour(Time) & Minute(Time) & Second(Time) & ".doc"
ASP – Kompendium programisty
231
Ta nazwa pliku będzie wykorzystana w ścieżce do katalogu, w którym znajduje się bieżąca strona ASP.
Korzystamy tutaj z metody
MapPath
:
Path2File = Server.MapPath("./") & "\" & Path2File1
a następnie gość readresowany jest do wygenerowanego dokumentu Word:
Dokument Word jest zapisywany przy użyciu metody
SaveAs
. Metodzie przekazywana jest nazwa utworzonego
wcześniej pliku:
MyWord.ActiveDocument.SaveAs Path2File
Uwalniamy serwer Word:
set MyWord = Nothing
Response.Redirect "./" & Path2File1
Rozdział 8.
Obiekt Session, obiekt Application oraz
plik global.asa
Aplikacje ASP
Do tej pory przyjrzeliśmy się przykładom kodów wykorzystujących obiekt
Request
w celu uzyskania danych od
naszego gościa oraz informacji o nim samym. Korzystaliśmy z obiektu
Response
, aby wysyłać dane z powrotem
do przeglądarki odwiedzającego. Tego samego obiektu
Response
używaliśmy również w celu wysyłania
informacji do innej strony przy pomocy łącza lub metody
Redirect
wraz z zapytaniem. Wiemy też, jak
komunikować się z serwerem. Lecz do tej pory nie poznaliśmy metod dzielenia informacji pomiędzy stronami
tak, aby mogły być wykorzystywane przez wszystkich gości lub jedynie niektórych z nich. Ten rozdział
koncentruje się na tym temacie: na aplikacjach ASP.
Jeśli na co dzień programujesz w jakimś innym języku lub tylko słyszałeś, jak rozmawiają ze sobą programiści,
możesz być już zaznajomiony ze słowem stan (state), odnoszący się do trwałości informacji w obrębie danej
aplikacji. W aplikacjach bezstanowych wszystkie dane są tracone podczas przechodzenia od jednej procedury
do drugiej. Tak więc każde wywołanie lub (jak to jest w wypadku stron ASP) każda strona musi dysponować
własnym zestawem danych. Aplikacja posiadająca stan zachowuje informacje podczas kolejnych wywołań, do
których to informacji dostęp uzyskać może wiele procedur aplikacji lub ta sama procedura, ale wielokrotnie.
Jeśli kiedykolwiek programowałeś w Visual Basicu, zapewne znasz już zmienne
Public
i
Global
. Zmienne te
mogą być widoczne w obrębie całej aplikacji od jej uruchomienia aż do zamknięcia. W Visual Basicu
deklarujesz tego typu zmienną w następujący sposób:
Public EmpName as String
Możesz ustalić jej wartość w dowolnej procedurze:
EmpName = "Nancy"
Kiedy procedura ustalająca wartość zmiennej kończy swe działanie, wartość tą w dalszym ciągu stanowi tekst
Nancy
, tak więc inne procedury lub ta sama procedura może odwoływać się do ustawionej ostatnio wartości tej
zmiennej. Taka aplikacja posiada swój stan. Widzieliśmy, że w większości kodów prezentowanych do tej pory
nie mieliśmy możliwości takich odwołań. Zmienne tworzyliśmy używając w kodzie strony instrukcji
Dim
:
Dim EmpName
Jednak gdy tylko przetwarzanie strony zostaje ukończone, dana ulokowana w zmiennej
EmpName
jest tracona.
Żadna inna strona nie może odnosić się do tej zmiennej, jeśli została ona zdeklarowana w ten sposób.
Stworzyliśmy strony, które są bezstanowe.
W tym rozdziale zwrócimy uwagę na tworzenie aplikacji ASP pozwalających na utrzymywanie stanu.
Aplikacja ASP dostarcza mechanizmów zapamiętywania informacji o stanie we wszystkich stronach.
Informacja ta może być zapamiętana na dwóch poziomach: poziomie aplikacji i poziomie sesji.
ASP – Kompendium programisty
233
Poziom aplikacji odnosi się do wszystkich stron aplikacji ASP oraz wszystkich gości twojej aplikacji, możesz
więc stworzyć zmienną w jednym położeniu, do której to zmiennej wszystkie strony aplikacji i wszyscy
odwiedzający mogliby się odwoływać. Informacja o aplikacji jest wywoływana i tworzona poprzez obiekt
Application
.
Informacje o stanie możesz również zapamiętać na poziomie sesji, który odnosi się do jednego tylko gościa
witryny. W tym przypadku informacja o stanie znajduje się na niższym poziomie od poziomu aplikacji.
Informacja jest dostępna dla określonego gościa na wszystkich stronach. Oznacza to, że możesz stworzyć
informację o stanie aplikacji, która jest widoczna poprzez kod dla jednego tylko odwiedzającego. Ten poziom
jest kodowany przez obiekt
Session
.
Jak się dowiesz bardziej szczegółowo z niniejszego rozdziału, obiekty
Session
i
Application
mogą obsługiwać
wystąpienie określonych zdarzeń, tak więc możesz dysponować kodem uruchamianym podczas rozpoczęcia
działania aplikacji lub podczas wchodzenia odwiedzającego na witrynę. Te funkcje naprawdę podnoszą
możliwości twoich witryn WWW.
Tworzenie aplikacji ASP
Aplikacja ASP jest serią połączonych ze sobą stron ASP oraz pliku o nazwie global.asa. Wszystkie pliki
aplikacji ASP muszą znajdować się w tej samej strukturze katalogu głównego, w którym aplikacja jest
zdefiniowana lub w jego podkatalogach.
Spójrz na strukturę katalogu pokazaną na rysunku 8.1.
Rysunek 8.1. Przykładowa struktura katalogu
Aplikacja ASP składa się z wszystkich plików znajdujących się w katalogu głównym lub w dowolnym jego
podkatalogu, chyba że podkatalog ten należy do innej aplikacji ASP. Patrząc na nasz przykład widzimy, że
najwyższy poziom nie jest zdefiniowany jako aplikacja ASP. Następnie mamy podkatalog o nazwie HR, który
zdefiniowany jest jako aplikacja ASP, tak więc strony ASP w tym katalogu są częścią jednej aplikacji HR.
Powiedzieliśmy również, że podkatalogi są częścią aplikacji, o ile nie stanowią swojej własnej aplikacji ASP.
W katalogu HR znajduje się katalog o nazwie NewEmps. Nie jest on aplikacją ASP, tak więc każda strona w
nim się znajdująca należy do aplikacji HR. Jeśli katalog NewEmps zawiera w sobie jakieś podkatalogi, one
również będą składnikami aplikacji ASP, chyba że zostały zdefiniowane jako własna, odrębna aplikacja ASP.
Drugim podkatalogiem HR jest Train. Ten katalog sam w sobie jest aplikacją ASP, więc strony ASP znajdujące
się w nim nie należą do aplikacji HR. W katalogu Train znajduje się podkatalog C1. Ponieważ nie jest on
katalogiem ASP, należy do aplikacji Train, znajduje się bowiem na niższym poziomie w stosunku do niej.
W katalogu głównym znajduje się ponadto katalog o nazwie IS, który zdefiniowany jest jako aplikacja ASP, tak
więc wszystkie strony ASP w tym katalogu będą należały do aplikacji IS, a nie HR czy jakiejkolwiek innej.
Ostatnim podkatalogiem katalogu głównego jest Sales. Nie jest on aplikacją ASP, więc strony znajdujące się w
nim są bezstanowe. Nie należą one do żadnej aplikacji ASP, ponieważ ani katalog, w którym się znajdują, ani
żaden katalog nadrzędny nie jest zdefiniowany jako aplikacja ASP.
Tworząc aplikację ASP musisz orientować się, w którym miejscu umieszczasz poszczególne strony, aby ich
względne położenie gwarantowało możliwość dzielenia między sobą informacji o stanie. Normalnie dokonasz
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
234
tego tworząc katalog podrzędny w stosunku do katalogu głównego twojej witryny WWW. Następnie
umieszczasz w obrębie tego katalogu wszystkie pliki będące częścią aplikacji.
Teraz jesteś już gotowy do oznaczenia katalogu jako aplikacji ASP. Możesz to zrobić klikając katalog prawym
przyciskiem myszy w oknie Konsoli zarządzania Microsoftu serwera IIS, a następnie wybierając Właściwości
(Properties), jak to zaprezentowano na rysunku 8.2.
Rysunek 8.2. Przeglądanie Właściwości w celu stworzenia aplikacji ASP
Po wybraniu Właściwości (Properties) powinieneś ujrzeć dialog pokazany na rysunku 8.3. Kiedy już znajdziesz
się we właściwościach katalogu, powinieneś znaleźć się w zakładce Katalog (Directory); jeśli tak nie jest,
zmień zakładkę. Następnie naciśnij przycisk Utwórz (Create) w sekcji Ustawienia aplikacji (Application
Settings) i wprowadź w pole tekstowe Nazwa (Name) nazwę, jaką chcesz nadać aplikacji. Naciśnij OK. Od tej
pory dysponujesz aplikacją ASP. Wszystkie strony ASP w obrębie aplikacji mogą dzielić między sobą
informacje przy użyciu obiektów
Application
i
Session
.
Rysunek 8.3. Tworzenie aplikacji ASP
ASP – Kompendium programisty
235
Obiekt Session
Sesja, w terminologii ASP, odnosi się do przemierzania przez określonego gościa twojej aplikacji. Sesja
rozpoczyna się w momencie, gdy gość przegląda jedną ze stron ASP twojej aplikacji lub przechodzi do strony
HTML, której kod wywołuje którąś z twoich stron ASP. Trwa ona dopóki odwiedzający nie opuści twej
witryny.
Sesja określonego gościa witryny może być zakończona w sposób ukryty lub jawny. Kończy się ona w sposób
ukryty, gdy gość nie żądał dostępu do strony na ustalony z góry czas trwania w minutach. Kończy się w sposób
jawny, gdy wywołujesz metodę zakańczającą sesję gościa.
Podczas gdy odwiedzający przemierza twoją witrynę, możesz użyć obiektu
Session
w celu zapamiętania
informacji o gościu oraz kontrolowania pewnych aspektów jego sesji. Obiekt
Session
zawiera zbiory,
właściwości oraz metody zapewniające realizację tego typu funkcji w kodzie.
Zbiory obiektu Session
Obiekt
Session
posiada dwa zbiory, których możesz wykorzystać do kontrolowania danych używanych w
stanie sesji. Zbiory te omówione są poniżej, a podsumowano je w tabeli 8.1.
Tabela 8.1. Zbiory obiektu Session
Zbiór
Opis
Contents
Zbiór wszystkich zmiennych dostępnych na poziomie sesji,
wyłączając te tworzone ze znacznikiem
Object
.
StaticObjects
Zbiór wszystkich obiektów poziomu sesji, które utworzone były
przy użyciu znacznika
Object
w pliku global.asa.
Zbiór Contents
Zbiór
Contents
jest grupą zmiennych, którą tworzysz w celu udostępnienia ich we wszystkich stronach
aplikacji ASP poprzez obiekt
Session
. Zmienne obejmują swym zasięgiem poziom sesji, są więc dostępne dla
dowolnej strony ASP, ale ich wartości nie są użytkowane przez wszystkich gości. Każdy gość będzie
dysponował własną kopią zmiennej.
Ustalenia wartości dla pozycji zbioru
Contents
dokonujesz w następujący sposób:
Session.Contents("EmpName") = "Tonya"
Ponieważ jednak zbiór ten jest zbiorem domyślnym, możesz również napisać to samo w następujący sposób:
Session("EmpName") = "Tonya"
Każdy ze sposobów, wyszukujący lub ustalający wartość danej pozycji zbioru
Contents
, rozpoczyna się
obiektem
Session
. Później pojawia się w cudzysłowie (jako że jest to pozycja zbioru) nazwa pozycji, do której
chcesz się odnieść.
Ponieważ zmienne są pozycjami zbioru, to w odróżnieniu od standardowych zmiennych, nie wykorzystują
instrukcji
Option Explicit
. Jej użycie w tym wypadku nie ma sensu, ponieważ najpierw możesz stworzyć
zmienną w jednej stronie, a potem odwoływać się do niej na innych stronach. I takie jest rzeczywiste
przeznaczenie zmiennych zbioru
Contents
— mają być wyszukiwane i ustawiane w wielu stronach twojej
witryny WWW.
Na przykład mógłbyś w stronie zawrzeć następujący kod tworzący kilka zmiennych sesji:
<%
Session("UserName") = "Bob Tyler"
Session("UserID") = 10
Session("City") = "Portland"
%>
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
236
Tworzymy tutaj trzy zmienne sesji, które od tej pory dostępne są dla każdej strony naszej aplikacji ASP. Po
pierwsze tworzymy zmienną sesji o nazwie
UserName
i ustalamy dla niej wartość w postaci ciągu
"Bob Tyler"
:
Session("UserName") = "Bob Tyler"
Wartość tą ustalamy wpisując ciąg, ale może być ona określona przez odwołanie się do wartości w bazie
danych lub może zostać odebrana od użytkownika poprzez zbiór
Form
obiektu
Request
.
Następnie tworzona jest zmienna o nazwie
UserID
, dla której ustalamy wartość 10. Zapamiętaj, że uzupełniając
wartości zmiennych sesji możemy użyć ciągów, liczb, a także dat:
Session("UserID") = 10
W końcu ustalamy trzecią zmienną sesji,
City
, w której przechowujemy wartość
"Portland"
:
Session("City") = "Portland"
Teraz w kolejnej stronie możemy odwołać się do tych zmiennych sesji lub możemy stworzyć nowe. Spójrz na
poniższy kod:
<%
If Session("City") = "Portland" Then
Session("City") = "Portland, stan Oregon"
End If
Response.Write "Cześć: " & Session("UserName") & ".<P>"
Response.Write "Twój numer to : " _
& Session("UserID") & ".<P>"
Response.Write "Co ciekawego w " & Session("City") & "?<P>"
%>
Po pierwsze wyszukujemy wartość zmiennej sesji
City
przy użyciu instrukcji
If
aby się przekonać, czy
znajduje się w niej ciąg
"Portland"
:
If Session("City") = "Portland" Then
Jeśli tak, ustalamy nową wartość zmiennej:
Session("City") = "Portland, stan Oregon"
Następnie wykorzystujemy wartość zmiennej sesji
UserName
w metodzie
Write
:
Response.Write "Cześć: " & Session("UserName") & ".<P>"
Wartości zmiennych
UserID
i
City
używane są jako dodatkowe wyjście dla przeglądarki:
Response.Write "Twój numer to : " _
& Session("UserID") & ".<P>"
Response.Write "Co ciekawego w " & Session("City") & "?<P>"
Wyjście kodu przedstawia rysunek 8.4.
ASP – Kompendium programisty
237
Rysunek 8.4. Wyjście kodu wykorzystującego zbiór
Contents
Możesz również tworzyć obiekty zbioru
Contents
. Jest to trochę niebezpieczne, ponieważ zasoby używane
przez obiekty mogą być znacznie większe od prostych zmiennych, ale pozwala to na stworzenie obiektu
Session
w jednym miejscu, a następnie korzystanie z niego w całej twojej aplikacji ASP.
Przykładowo możesz stworzyć na stronie kopię obiektu:
set Session("Sconn") = Server.CreateObject("adodb.connection")
Ten obiekt
Session
jest teraz utworzony i używa zasobów systemowych odpowiednich dla swojego typu. W
kolejnej stronie lub stronach możesz pisać kody używając przy tym obiektu
Session
:
Session("Sconn").open "ASPBook", "sa", "yourpassword"
Ponieważ te pola są częścią zbioru, możemy użyć bloku
For...Each
do przejścia kolejno przez każdą zmienną
sesji lub obiekt. Kod bloku jest następujący:
<%
For Each MySession in Session.Contents
Response.Write "Punkty sesji: " & MySession & "<P>"
Next
%>
Wyjście kodu, stworzone na podstawie wszystkich zdefiniowanych do tej pory zmiennych, pokazano na
rysunku 8.5.
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
238
Rysunek 8.5. Wyświetlanie punktów sesji przy użyciu zbioru
Contents
Pomyśl o przepływie kodu w stronie, gdzie najpierw do zmiennej sesji
City
wpisujemy ciąg
"Portland"
, a
następnie w kolejnej stronie zmieniamy tą wartość na
"Portland, stan Oregon"
. Jeśli gość wróciłby na
pierwszą stronę, wartość zmiennej znowu zostałaby ustawiona na
"Portland"
. Wiele razy będziesz dysponował
kodem, który stworzy te zmienne sesji i nada im początkową wartość. Jeśli jednak zmienne te były już
wcześniej utworzone, nie chcesz zmieniać ich wartości. Możesz wykorzystać funkcję
IsEmpty
w celu
określenia, czy zmienna sesji już istnieje.
Tak więc nasz kod moglibyśmy zmodyfikować w następujący sposób:
<%
If IsEmpty(Session("City")) Then
Session("City") = "Portland"
End If
%>
Teraz kod zadziała tylko raz w czasie sesji gościa. Po utworzeniu zmiennej sesji warunek instrukcji
If
nie
będzie prawdą, więc zmienna nie będzie przydzielona ponownie. W dalszej części rozdziału zwrócimy uwagę
na jeszcze jeden sposób inicjalizacji zmiennych sesji — poprzez plik global.asa.
Kolejnym zastosowaniem zmiennych sesji jest wymuszenie na gościach, aby najpierw weszli na określoną
stronę przed odwiedzeniem jakiejś innej strony. Załóżmy na przykład, że dysponujesz na twojej witrynie
WWW quizami dla klasy, którą uczysz. Przed rozpoczęciem quizu goście będą musieli się zalogować.
Problemem, z którym się spotkasz jest fakt, że uczniowie ustawią znacznik w samym quizie i w ten sposób
będą powracać wprost do tej strony z pominięciem logowania.
Aby z tym sobie poradzić możesz wykorzystać zmienną sesji. Mogłaby ona zawierać numer identyfikacyjny
ucznia i nosić nazwę
StudentID
, a ustawiana byłaby jedynie w stronie logowania. Sama strona quizu
zawierałaby kod podobny do tego przedstawionego poniżej, który zapobiegałby wchodzeniu na stronę z
pominięciem strony logowania:
<%
If IsEmpty(Session("StudentID")) then
Response.Redirect "./login.asp"
End If
%>
ASP – Kompendium programisty
239
Teraz, gdy uczniowie będą próbować wejścia wprost na stronę quizu bez logowania, zmienna sesji
StudentID
będzie pusta i uczniowie będą readresowani do strony logowania.
Zbiór StaticObjects
W dalszej części tego rozdziału omówimy plik global.asa w całej rozciągłości. W tym momencie powinieneś
wiedzieć, że jest on częścią aplikacji ASP. Daje on możliwość napisania kodu, który uruchamiany jest na
początku lub pod koniec sesji gościa. Ponadto plik umożliwia napisanie kodu uruchamianego w chwili
rozpoczęcia bądź zakończenia działania aplikacji ASP.
Możesz również stworzyć obiekty
Session
w pliku global.asa, które później dostępne są — jak te omówione do
tej pory — dla wszystkich stron znajdujących się w obrębie aplikacji ASP. Obiekty te tworzysz przy użyciu
znacznika
Object
, a stają się one dostępne dzięki zbiorowi
StaticObjects
.
Takie statyczne obiekty sesji są deklarowane w pliku global.asa poprzez znacznik
Object
w następujący
sposób:
<OBJECT RUNAT=Server SCOPE=Session ID=Sconn PRODIG="adodb.connection">
</OBJECT>
Ponieważ są to pozycje zbioru, możemy użyć bloku
For...Each
, aby przejść kolejno przez wszystkie te
pozycje:
Ten wiersz kodu tworzy obiekt zasięgu sesji o nazwie
Sconn
, który jest obiektem połączenia ADO. Ten
natomiast:
<OBJECT RUNAT=Server SCOPE=Session ID=SobjMail PRODIG="CDONTS.
NewMail">
</OBJECT>
tworzy obiekt sesji o nazwie
SobjMail
, który jest obiektem CDO używanym do wysyłania wiadomości e-mail.
Po utworzeniu obiektów możesz odwoływać się do każdego z nich w kodzie dowolnej strony ASP będącej
częścią aplikacji, tak jak tutaj:
<%
Option Explicit
Dim RSUser
Sconn.open "ASPBook", "sa", "yourpassword"
set RSUser = Sconn.Execute("select * from Users")
%>
Najważniejsze rzeczą, na którą powinieneś zwrócić uwagę jest to, że do zbioru
StaticObjects
odnosimy się
inaczej niż do zbioru
Contents
. Po prostu określamy nazwę pozycji zbioru bez wcześniejszego podawania
obiektu. W tym przykładzie właśnie w ten sposób używamy nazwy obiektu
Sconn
:
Sconn.open "ASPBook", "sa", "yourpassword"
<%
Option Explicit
Dim MySessionSO
For Each MySessionSO in Session.StaticObjects
Response.Write "Obiekt statyczny: & MySessionSO & "<P>"
Next
%>
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
240
Po pierwsze informujemy kompilator o zamiarze deklaracji naszych zmiennych:
Option Explicit
Następnie deklarujemy zmienną, która będzie przechowywała odwołanie do każdego obiektu zbioru
StaticObjects
:
Dim MySessionSO
Blok
For...Each
rozpoczyna swe działanie i przechodzi w pętli kolejno przez wszystkie pozycje zbioru:
For Each MySessionSO in Session.StaticObjects
Metoda
Write
obiektu
Response
wpisuje nazwę obiektu statycznego do przeglądarki przed przejściem do
kolejnego obiektu zbioru:
Response.Write "Obiekt statyczny: & MySessionSO & "<P>"
Next
Wyjście kodu, wyświetlającego nazwę dwóch stworzonych przez nas obiektów, pokazano na rysunku 8.6.
Rysunek 8.6. Wyjście kodu wykorzystującego zbiór
StaticObjects
Właściwości obiektu Session
Właściwości obiektu
Session
pozwalają na konfigurację, a następnie odnoszenie się do aspektów sesji gościa.
Omówiono je w tym podrozdziale oraz podsumowano w tabeli 8.2.
Tabela 8.2. Właściwości obiektu
Session
Właściwość Przeznaczenie
CodePage
Określa zestaw znaków używany w sesji.
LCID
Definiuje identyfikator lokalizacji dla sesji.
SessionID
Definiuje unikalny identyfikator dla sesji gościa.
TimeOut
Określa czas w minutach pomiędzy kolejnymi żądaniami dostępu
ASP – Kompendium programisty
241
do strony, który nie może zostać przekroczony, w innym
wypadku sesja gościa będzie traktowana jako zakończona.
Właściwość CodePage
Właściwość
CodePage
pozwala na wybór zestawu znaków, który będzie używany w czasie trwania sesji. Zestaw
obejmuje liczby, litery, a także inne znaki. Zestawy znaków różnią się między sobą w zależności od kraju, w
którym obowiązują, możesz więc użyć tej właściwości jeśli chcesz umieścić na twojej witrynie zawartość
międzynarodową.
CodePage
jest właściwością sesji, tak więc jej ustawienia będą obowiązywały we wszystkich stronach twojej
aplikacji ASP. Właściwość tą wpisywać i odczytywać, a przyjmuje ona następującą formę:
Session.CodePage = CPValue
gdzie
CPValue
jest liczbą odnoszącą się do strony kodowej, której chcesz użyć. Spójrz na ten kod:
<%
Session.CodePage = 1252
Response.Write "Używana strona kodowa: " & Session.CodePage & "<P>"
Response.Write "1é ć ç ę ë ě í î ď đ Ę Î Đ" & "<P>"
Session.CodePage = 932
Response.Write " Używana strona kodowa: " & Session.CodePage & "<P>"
Response.Write "1é ć ç ę ë ě í î ď đ Ę Î Đ" & "<P>"
%>
Po pierwsze, ustalamy angielską stronę kodową dla całej sesji:
Session.CodePage = 1252
Następnie wartość strony kodowej wpisywana jest do przeglądarki:
Response.Write "Używana strona kodowa: " & Session.CodePage & "<P>"
Teraz wpisywane do przeglądarki niektóre niestandardowe znaki:
Response.Write "1é ć ç ę ë ě í î ď đ Ę Î Đ" & "<P>"
W kolejnym wierszu kodu ustawiana jest japońska strona kodowa:
Session.CodePage = 932
Do przeglądarki wpisywana jest wartość właściwości
CodePage
:
Response.Write "Używana strona kodowa: " & Session.CodePage & "<P>"
jak również ponownie niektóre znaki niestandardowe:
Response.Write "1é ć ç ę ë ě í î ď đ Ę Î Đ" & "<P>"
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
242
Właściwość LCID
Właściwość
LCID
obiektu
Session
pozwala na określenie sposobu dynamicznego wyświetlania tekstu w
zależności od lokalizacji. Dotyczy ona wyświetlania takich rzeczy jak czas, liczby oraz waluta.
Ponieważ jest to właściwość sesji, raz ustawiona obowiązuje dla wszystkich stron twojej aplikacji ASP.
Właściwość tą można zapisywać i odczytywać, a przyjmuje ona następującą formę:
Session.LCID = 1049
Session.LCID = 6154
Session.LCID = LocaleID
gdzie
LocaleID
jest liczbą typu long reprezentującym daną lokalizację.
Właściwość ta dostarcza dodatkowego mechanizmu internacjonalizacji twojej witryny. Używasz jej w celu
właściwego sformatowania zawartości twojej strony. Zwróć uwagę na przykładowy blok kodu:
<%
Session.LCID = 1033
Response.Write "Format amerykański: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Session.LCID = 2057
Response.Write "Format brytyjski : " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Response.Write "Format rosyjski: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Session.LCID = 1032
Response.Write "Format grecki: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Session.LCID = 2049
Response.Write "Format iracki: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Session.LCID = 3073
Response.Write "Format egipski: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Response.Write "Format panamski: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
%>
Pierwszą ustawioną przez kod lokalizacją są Stany Zjednoczone:
Session.LCID = 1033
Następnie kod wyświetla aktualną datę i godzinę, jak również walutę w formacie obowiązującym w Stanach
Zjednoczonych:
Response.Write "Format amerykański: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
ASP – Kompendium programisty
243
Tutaj ustawioną lokalizacją jest Wielka Brytania:
Session.LCID = 2057
a następnie wyświetlana jest data, godzina oraz waluta w formacie brytyjskim:
Response.Write "Format brytyjski : " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Podobnie kod wyświetla format rosyjski:
Session.LCID = 1049
Response.Write "Format rosyjski: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Następnie format grecki:
Session.LCID = 1032
Response.Write "Format grecki: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Tutaj iracki:
Session.LCID = 2049
Response.Write "Format iracki: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Następne wyświetlany jest egipski format daty, godziny i waluty:
Session.LCID = 3073
Response.Write "Format egipski: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
To samo jeśli chodzi o format panamski:
Session.LCID = 6154
Response.Write "Format panamski: " & Now & " " _
& formatcurrency(1234.56) & "<P>"
Wyjście kodu zaprezentowano na rysunku 8.7.
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
244
Rysunek 8.7. Wyjście kodu wykorzystującego właściwość
LCID
Właściwość SessionID
Serwer IIS musi mieć sposoby na wewnętrzne śledzenie przechodzenia gości przez twoją witrynę. Jednym z
takich sposobów jest wykorzystanie właściwości
SessionID
. Kiedy używasz aplikacji ASP, serwer IIS
przydziela losową liczbę typu long wszystkim gościom wchodzącym na twoją witrynę.
Domyślna wartość tej właściwości jest ustawiana przez Konsolę zarządzania Microsoftu serwera IIS. Przejdź
do twojej aplikacji ASP i wybierz Właściwości (Properties). Następnie przejdź do zakładki Katalog (Directory)
i naciśnij przycisk Konfiguracja (Configuration). Przejdź do zakładki Opcje aplikacji (App Options), a wtedy
powinieneś ujrzeć dialog, który został zaprezentowany na rysunku 8.8.
Właściwość ta służy tylko do odczytu, ponieważ jest używana wewnętrznie przez serwer IIS w celu
identyfikacji wszystkich gości podczas trwania ich sesji. Właściwość ma następującą składnię:
TheID = Session.SessionID
TheID
jest zmienną, w której chcesz umieścić numer identyfikacyjny.
Przypis
SessionID nie jest niepowtarzalnym numerem przez cały czas. Jeśli ponownie uruchomisz swój serwer, to ten sam numer może
być przydzielony ponownie. Nie używaj więc tego identyfikatora jako klucza głównego tabeli.
Właściwość TimeOut
Sesja rozpoczyna się w chwili, gdy gość uzyskuje dostęp do jednej ze stron aplikacji ASP lub gdy uzyskuje
dostęp do strony wywołującej kod jednej z twoich stron ASP. Jednym z sposobów, w jaki sesja może się
skończyć to brak żądania dostępu gościa do strony twojej aplikacji ASP w pewnym określonym (w minutach)
zakresie czasu. Ilość minut ustalana jest przez właściwość
TimeOut
. Właściwość ta może być zapisywana i
odczytywana, a zapamiętuje ona czas w minutach, jaki może upłynąć pomiędzy kolejnymi żądaniami dostępu
do aplikacji ASP bez jej przeterminowania.
ASP – Kompendium programisty
245
Rysunek 8.8. Ustawianie domyślnej wartości właściwości
TimeOut
Pole tekstowe Czas trwania sesji (Session TimeOut) zawiera domyślną wartość właściwości
TimeOut
. Możesz
unieważnić tą wartość w kodzie przy użyciu właściwości
TimeOut
. Właściwość może być zapisywana lub
odczytywana i przyjmuje następujący format:
Session.TimeOut = NumMinutes
gdzie
NumMinutes
jest ilością minut pomiędzy żądaniami dostępu, których upłynięcie powoduje zakończenie
sesji.
Kiedy sesja się kończy, wszystkie jej obiekty i zmienne zostają uwolnione i ich wartości przestają być
dostępne. Jeśli goście żądają dostępu do strony po przekroczeniu czasu ważności, będzie to zinterpretowane
jako pierwsze żądanie, co spowoduje rozpoczęcie nowej sesji.
Metoda obiektu Session
Obiekt
Session
posiada jedną tylko metodę, która pozwala na podjęcie działania w związku z tym obiektem.
Metoda ta jest omówiona poniżej, a podsumowuje ją tabela 8.3.
Tabela 8.3. Metoda Obiektu
Session
Metoda Przeznaczenie
Abandon
Jawne zakończenie sesji odwiedzającego.
Metoda Abandon
Jak to było widać w ostatnim podrozdziale, sesje gości kończą się po upłynięciu pomiędzy żądaniami
ustalonego czasu mierzonego w minutach. Innym sposobem na zakończenie sesji jest wywołanie w kodzie
metody
Abandon
.
Metoda
Abandon
obiektu
Session
pozwala na natychmiastowe zakończenie sesji gościa. Jest to pomocne
sytuacjach, gdy goście podejmują działanie kończące jakiś proces, w który byli zaangażowani. Na przykład,
jeśli masz witrynę e-commerce, goście mogą przeszukiwać katalog twoich produktów i umieszczać niektóre z
nich w koszyku. Aby zarządzać ich stanem używasz obiektu
Session
wraz z identyfikatorem klienta, tak więc
mogą oni dokładać produkty do koszyka oraz usuwać je stamtąd — a ty przez cały czas utrzymujesz ich stan.
W którymś momencie mogą oni opuścić twój sklep online. Kiedy podejmą takie działanie oznacza to, że
zakończyli swe zakupy, a ty powinieneś przetworzyć ich zamówienie. Musisz zakończyć ich sesję. Dokonasz
tego przy użyciu metody
Abandon
.
Metoda
Abandon
ma następującą składnię:
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
246
Session.Abandon
Spójrz na przykład na ten kod:
<%
Session("UserName") = "Jim Smith"
Response.Write Session("UserName")
Session.Abandon
%>
Tutaj tworzona jest zmienna sesji o nazwie
UserName
:
Session("UserName") = "Jim Smith"
Wartość tej zmiennej jest wpisywana do przeglądarki:
Response.Write Session("UserName")
Sesja kończy się:
Session.Abandon
Kiedy już wykonywanie kodu strony jest zakończone, zmienna sesji przestaje być dostępna. Kiedy wywołana
zostaje metoda
Abandon
, uruchamiane jest zdarzenie
Session_OnEnd
i wszystkie zmienne sesji oraz obiekty
zostają uwolnione.
Obiekt Application
Jak mogłeś się nauczyć z tego rozdziału, aplikacja ASP jest połączeniem stron ASP oraz pliku global.asa we
wspólnej strukturze katalogu. Obiekt
Application
pozwala na programową kontrolę twojej aplikacji.
Przy użyciu metod i zbiorów dostępnych w obrębie tego obiektu, możesz tworzyć zmienne i obiekty widziane
w całej aplikacji w czasie trwania wszystkich sesji, jak również metody pozwalające na kontrolę zmian stanu
zmiennych.
Zbiory obiektu Application
Obiekt
Application
ma dwa zbiory, które możesz wykorzystać do kontroli zmiennych i obiektów widzianych w
całej aplikacji ASP. Zbiory te omówiono poniżej, a sumarycznie prezentuje je tabela 8.4.
Tabela 8.4. Zbiory obiektu
Application
Zbiór Opis
Contents
Zbiór wszystkich zmiennych dostępnych na poziomie aplikacji,
wyłączając te tworzone ze znacznikiem
Object
.
StaticObjects
Zbiór wszystkich obiektów poziomu aplikacji, które utworzone
były przy użyciu znacznika
Object
w pliku global.asa.
Zbiór Contents
Zbiór
Contents
jest grupą zmiennych, którą udostępniasz każdej ze stron twojej aplikacji ASP w czasie trwania
dowolnej sesji. Zmienne te mają zasięg aplikacji, są więc dostępne dla każdej strony ASP i nie są
ASP – Kompendium programisty
247
współużytkowane przez wszystkich gości. Kod uruchamiany z osobna dla każdego gościa odwołuje się do tego
samego zbioru zmiennych aplikacji.
Ustalenia wartości danej pozycji zbioru
Contents
dokonuje się w następujący sposób:
Application.Contents("CurrentDiscount") = .9
Składnia polecenia, zarówno dla ustawiania, jak i wyszukiwania pozycji zbioru
Contents
rozpoczyna się
słowem
Application
, a następnie w cudzysłowie (ponieważ jest to pozycja zbioru) określana jest nazwa
pozycji, do której się odwołujesz.
Podobnie jak zbiór
Contents
obiektu
Session
, również zbiór obiektu
Application
nie wywoła stanu błędu
związanego z użyciem instrukcji
Option Explicit
, jeśli zmienna nie była wywoływana wcześniej. Jest to w
pełni zrozumiałe, ponieważ sednem użycia zbioru
Contents
w dowolnym obiekcie jest tworzenie zmiennych
dostępnych w obrębie szerszej ilości stron.
Zmienne aplikacji dostarczają mechanizmu tworzenia i ustalania wartości zmiennych w jednym położeniu, do
których następnie będzie można się odwoływać w wielu innych miejscach. Dzięki temu można modyfikować
kod w prostszy sposób. Weźmy następujący przykład:
<%
Application("MinQuantity") = 2
Application("CurrentDiscount") = .9
Application("MinShipHand") = 12
Application("MinQuantity") = 2
Application("ShipHandPercent") = .07
%>
Utworzyliśmy tutaj cztery zmienne aplikacji. Ich wartości będą dostępne dla wszystkich stron aplikacji ASP w
czasie trwania każdej sesji.
Pierwsza utworzona zmienna nosi nazwę
CurrentDiscount
, a przypisujemy wartość 0.9:
Application("CurrentDiscount") = .9
Następnie tworzona jest zmienna
MinShipHand
, która zapamiętuje minimalną płatność za transport i obsługę
przy realizacji jednego zamówienia, wynoszącą w tym wypadku 12 dolarów:
Application("MinShipHand") = 12
Trzecia zmienna aplikacji,
MinQuantity
, zapamiętuje minimalną ilość kupowanych produktów:
I wreszcie czwarta zmienna aplikacji,
ShipHandPercent
, przechowuje naliczany procent za transport i obsługę:
Application("ShipHandPercent") = .07
Teraz możemy odwoływać się do tych zmiennych w innych stronach aplikacji ASP:
<%
Option Explicit
Dim OrderTotal
Dim SandH
Dim TotalDue
OrderTotal = Session("OrderTotal") * Application("CurrentDiscount")
SandH = OrderTotal * Application("ShipHandPercent")
If SandH < Application("MinShipHand") Then
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
248
SandH = Application("MinShipHand")
End If
TotalDue = SandH + OrderTotal
%>
Ten prosty blok kodowy jest przykładem sposobu obliczenia całkowitej sumy zamówienia. Zauważ, że nie ma
w tym kodzie na sztywno zakodowanych liczb. Kod wykorzystuje zmienne aplikacji w celu określenia opłaty.
Wstępnie jednak kompilator zostaje poinformowany o deklaracji naszych zmiennych:
Option Explicit
Dim TotalDue
Suma zamówienia jest obliczana przy użyciu zapamiętanej zniżki w zmiennej aplikacji
CurrentDiscount
:
W końcu obliczana jest kwota do zapłaty, będąca sumą należności ze zniżką oraz płatności za transport i
obsługę:
Następnie tworzymy zmienną zapamiętującą sumę zamówienia podlegającą zniżce:
Dim OrderTotal
Następna tworzymy zmienną zapamiętującą kwotę należną za transport i obsługę:
Dim SandH
oraz ostatnią zmienną, przechowującą ostateczną kwotę do zapłaty:
OrderTotal = Session("OrderTotal") * Application("CurrentDiscount")
Następnie należna kwota za transport i obsługę obliczana jest jako określony w zmiennej aplikacji
ShipHandPercent
procent wartości zmiennej
OrderTotal
:
SandH = OrderTotal * Application("ShipHandPercent")
Mamy również określoną minimalną płatność za transport i obsługę. Instrukcja
If
porównuje płatność bieżącą z
jej wartością minimalną, zapisaną w zmiennej aplikacji:
If SandH < Application("MinShipHand") Then
Jeśli obliczona płatność za transport i obsługę jest mniejsza od wartości minimalnej, do zmiennej wpisywana
jest ta wartość minimalna:
SandH = Application("MinShipHand")
End If
TotalDue = SandH + OrderTotal
Możesz również tworzyć obiekty zbioru
Contents
, ale tutaj bądź bardzo ostrożny. Pamiętaj, że zmienne
aplikacji oraz obiekty utrzymują się przez cały czas trwania aplikacji ASP, więc wszystkie zasoby
wykorzystywane przez obiekt będą również w użyciu przez cały czas, a ten może okazać się bardzo długi.
Kiedy tworzysz obiekt obejmujący zasięgiem aplikację, podobny do tego:
Set Application("Gconn") = Server.CreateObject("adodb.connection")
ASP – Kompendium programisty
249
przemyśl to, co będzie realizował ten wiersz kodu. Przez cały czas trwania twojej aplikacji, który wynieść może
tygodnie, utrzymywałbyś stałe połączenie z bazą danych.
Ponieważ
Contents
jest zbiorem, możemy przejść kolejno przez wszystkie jego pozycje korzystając z
następującego kodu:
<%
Option Explicit
Dim MyApp
For Each MyApp in Application.Contents
Response.Write "Nazwa zmiennej aplikacji: " & MyApp _
& " Wartość: " & Application(MyApp) & "<P>"
Next
%>
Po pierwsze, sygnalizujemy zamiar deklarowania zmiennych:
Option Explicit
Następnie deklarujemy zmienną, która będzie zapamiętywała odwołanie do każdej pozycji zbioru podczas
przechodzenia przez pętlę:
Dim MyApp
Później nasz blok
For...Each
przechodzi kolejno przez wszystkie pozycje zbioru
Contents
:
For Each MyApp in Application.Contents
Do przeglądarki wpisywana jest nazwa każdej zmiennej aplikacji wraz z wartością:
Response.Write "Nazwa zmiennej aplikacji: " & MyApp _
& " Wartość: " & Application(MyApp) & "<P>"
Następnie kod przechodzi w pętli do kolejnej pozycji zbioru:
Next
Wyjście omówionego wcześniej, przykładowego kodu przetwarzającego kwotę zamówienia zaprezentowano na
rysunku 8.9.
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
250
Rysunek 8.9. Wyjście kodu przechodzącego przez pozycje zbioru
Contents
Zbiór StaticObjects
Podobnie jak obiekt
Session
, również obiekt
Application
posiada zbiór
StaticObjects
, który jest tworzony
poprzez plik global.asa. Pamiętaj, że plik ten jest częścią aplikacji ASP. Daje on możliwość napisania kodu,
który uruchamiany jest w chwili rozpoczęcia bądź zakończenia działania aplikacji ASP. Ponadto plik
umożliwia napisanie kodu uruchamianego na początku lub pod koniec sesji.
Takie obiekty tworzysz przy użyciu znacznika
Object
, a stają się one dostępne poprzez zbiór
StaticObjects
.
Deklarujemy je w pliku global.asa w następujący sposób:
<OBJECT RUNAT=Server SCOPE=Application ID=Gconn PRODIG=
"adodb.connection">
</OBJECT>
Powyższy wiersz kodu tworzy obiekt o zasięgu aplikacji o nazwie
Gconn
, który jest obiektem połączenia ADO.
Po utworzeniu obiektu możesz odnosić się do pozycji zbioru
StaticObjects
w każdej ze stron aplikacji ASP w
czasie trwania dowolnej sesji:
<%
Option Explicit
Dim RSUser
Gconn.open "ASPBook", "sa", "yourpassword"
%>
set RSUser = Sconn.Execute("select * from Users")
Zauważ, że sposób odwołania się do zbioru
StaticObjects
różni się od sposobu odwoływania się do zbioru
Contents
. Nazwa pozycji zbioru określana jest bez poprzedzenia jej jakimkolwiek obiektem. W tym
przykładzie po prostu używana jest nazwa obiektu
Gconn
:
Gconn.open "ASPBook", "sa", "yourpassword"
Możesz również użyć bloku
For...Each
w celu przejścia kolejno przez wszystkie pozycje zbioru
StaticObjects
:
ASP – Kompendium programisty
251
<%
Option Explicit
Dim MyAppSO
For Each MyAppSO in Application.StaticObjects
Response.Write "Obiekt aplikacji: " & MyAppSO & "<P>"
Next
%>
Po pierwsze pojawia się instrukcja
Option Explicit
, jak tego wymaga deklaracja zmiennych:
Option Explicit
Następnie tworzona jest zmienna, która będzie zapamiętywała odwołanie do pozycji zbioru:
Next
Dim MyAppSO
Później rozpoczynamy iterację w strukturze bloku
For…Each
:
For Each MyAppSO in Application.StaticObjects
Do przeglądarki wpisywana jest nazwa pozycji zbioru
StaticObjects
:
Response.Write "Obiekt aplikacji: " & MyAppSO & "<P>"
Metody obiektu Application
Obiekt
Application
posiada dwie metody, których używa w celu kontrolowania odwołań do pozycji zbioru
Contents
. Zostały one omówione w tym podrozdziale, a sumarycznie przedstawia je tabela 8.5.
Tabela 8.5. Metody obiektu
Application
Metoda Przeznaczenie
Lock
Blokuje zmienną aplikacji tak, aby inne sesje nie mogły jej
modyfikować.
Unlock
Uwalnia blokadę zmiennych aplikacji.
Metoda Lock
Jednym z problemów pojawiających się przy dużej zajętości witryny lub nawet w wypadkach gdy ruch nie jest
aż tak wielki, jest możliwość modyfikacji zmiennych aplikacji przez większą ilość skryptów w jednym czasie.
Pamiętaj, że zmienna poziomu aplikacji jest dostępna dla wszystkich sesji. Jeśli więc obsługujesz setki
równoczesnych sesji staje się prawdopodobne, że więcej niż jedna z nich będzie próbowała zmienić wartość
zmiennej aplikacji w tym samym czasie.
Na przykład możesz śledzić liczbę udanych wywołań strony przy użyciu zmiennej aplikacji. Kiedy aplikacja
jest uruchamiana, mógłbyś ustawić początkową wartość zmiennej według jakiegoś pola bazy danych, używając
przy tym kodu podobnego do tego:
<%
Option Explicit
Dim conn
Dim RSPageHits
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
252
set conn = server.createobject ("adodb.connection")
set RSPageHits = conn.Execute("select Hits from RSPageHits")
conn.open "ASPBook", "sa", "yourpassword"
Application("PageHits") = RSPageHits("Hits")
%>
Wymagana jest deklaracja zmiennych:
Option Explicit
Tworzona jest zmienna zapamiętująca połączenie z bazą danych:
Dim conn
Następnie tworzymy kolejną zmienną, która będzie wyszukiwała w bazie danych informacje o udanych
wywołaniach:
Dim RSPageHits
Zmienna
Conn
będzie spełniała rolę obiektu
Connection
:
set conn = server.createobject ("adodb.connection")
Zestawiane jest połączenie bazą danych:
conn.open "ASPBook", "sa", "yourpassword"
Zapytanie wyszukuje w bazie dane o udanym wywołaniu:
set RSPageHits = conn.Execute("select Hits from RSPageHits")
Tworzona jest zmienna aplikacji
PageHits
, zapamiętującą liczbę udanych wywołań strony:
Application("PageHits") = RSPageHits("Hits")
Teraz, za każdy razem kiedy strona jest wywoływana, zmienna aplikacji
PageHits
jest inkrementowana:
<%
Application("PageHits") = Application("PageHits") + 1
%>
Tu spotykamy się z sednem problemu. Jeśli wielu gości uzyska dostęp do strony równocześnie, istnieje
możliwość, że więcej niż jedna sesja będzie próbowała zmienić wartość zmiennej aplikacji w tym samym
czasie. Metoda
Lock
radzi sobie z tego typu problemami blokując zmienne aplikacji tak, aby w jednym czasie
tylko jedna sesja mogła zmodyfikować ich wartość. Metoda ma następującą składnię:
Application.Lock
Możemy zmodyfikować nasz kod zawierając w nim metodę
Lock
, dając w ten sposób możliwość zmiany
wartości zmiennej tylko jednej sesji naraz:
<%
Application.Lock
ASP – Kompendium programisty
253
Application("PageHits") = Application("PageHits") + 1
%>
W tym przypadku wszystkie zmienne aplikacji zostaną zablokowane, dopóki kompilator nie zakończy
przetwarzania kodu strony. Jak się jednak przekonasz, kolejna metoda uwalnia blokadę.
Do tej pory rozdział omawiał sposoby tworzenia aplikacji ASP. Przyjrzeliśmy się plikom składającym się na
aplikację: plikom ASP oraz plikowi global.asa znajdującym się w strukturze tego samego katalogu.
Zwróciliśmy uwagę na obiekty
Session
i
Application
oraz sposoby tworzenia zmiennych i obiektów
dostępnych w obrębie całej aplikacji ASP.
Metoda Unlock
Istnieją dwa sposoby zwolnienia blokady zmiennych aplikacji. O pierwszej z nich już wspomnieliśmy:
pozwolić kodowi działać aż do końca, a wtedy blokada zostanie zwolniona. Jeśli jednak przetworzenie kodu
zabiera zbyt dużo czasu, możesz zakończyć je uwalniając zmienne aplikacji, na które oczekują inne sesje. Z
tego powodu powinieneś zablokować twoje zmienne aplikacji przed ich modyfikacją i uwolnić je po
modyfikacji.
Zwolnienia blokady dokonuje się przy użyciu metody
Unlock
, która ma następującą składnię:
Application.Unlock
Powinniśmy więc zmodyfikować naszą przykładową stronę zliczającą udane wywołania, umieszczając w niej
następujący, blokowany kod:
<%
Application.Lock
Application("PageHits") = Application("PageHits") + 1
Application.Unlock
%>
Tuż przed modyfikacją blokowane są zmienne aplikacji:
Application.Lock
Następnie dokonujemy modyfikacji zmiennej:
Application("PageHits") = Application("PageHits") + 1
Po dokonaniu zmian blokada jest zwalniana:
Application.Unlock
Plik global.asa
W tej części rozdziału zajmiemy specjalnym plikiem używalnym przez aplikacje ASP, global.asa. Po pierwsze,
jest to plik tekstowy. Możesz go utworzyć przy użyciu twego ulubionego edytora tekstu lub możesz w tym celu
skorzystać z jednego z narzędzi rozbudowy stron.
Plik ten musi nosić nazwę global.asa i musi znajdować się w katalogu głównym aplikacji ASP. Składa się on z
czterech zdarzeń, dla których możesz stworzyć procedury oraz ze znaczników
Object
.
Struktura pliku global.asa przedstawia się następująco:
<OBJECT RUNAT=Server SCOPE=Application ID=Aconn PRODIG="adodb.
connection">
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
254
</OBJECT>
<OBJECT RUNAT=Server SCOPE=Session ID=SobjMail PRODIG="CDONTS.
NewMail">
</OBJECT>
<SCRIPT LANGUAGE="VBScript" RUNAT="Server">
Sub Application_OnStart
'kod procedury
End Sub
Sub Session_OnStart
'kod procedury
End Sub
Sub Session_OnEnd
Sub Application_OnStart
End Sub
Możesz stworzyć kod uruchamiany przy rozpoczęciu sesji:
'kod procedury
End Sub
Sub Application_OnEnd
'kod procedury
End Sub
</SCRIPT>
Na samym początku pliku znajdują się obiekty poziomu aplikacji, deklarowane przy użyciu znacznika
Object
:
<OBJECT RUNAT=Server SCOPE=Application ID=Aconn PRODIG="adodb.
connection">
</OBJECT>
W drugiej kolejności mogą znaleźć się obiekty poziomu sesji, również tworzone przy użyciu znacznika
Object
:
<OBJECT RUNAT=Server SCOPE=Session ID=SobjMail PRODIG="CDONTS.
NewMail">
</OBJECT>
Następnie znacznik
Script
wskazuje używany język programowania oraz na miejsce uruchamiania kodu:
<SCRIPT LANGUAGE="VBScript" RUNAT="Server">
Dalej możesz umieścić kod, który będzie uruchomiony w chwili wystąpienia określonego zdarzenia. Możesz
stworzyć kod uruchamiany przy starcie aplikacji:
'kod procedury
Sub Session_OnStart
'kod procedury
End Sub
ASP – Kompendium programisty
255
Poza tym kod działający na końcu sesji:
Sub Session_OnEnd
'kod procedury
End Sub
Oraz na końcu aplikacji:
Sub Application_OnEnd
'kod procedury
End Sub
Strona kończy się znacznikiem
Script
:
</SCRIPT>
Zdarzenia pliku global.asa
W obrębie pliku global.asa możesz stworzyć kod uruchamiany w różnych momentach trwania aplikacji ASP.
Zdarzenia te omówiono poniżej, a sumarycznie przedstawia je tabela 8.6.
Tabela 8.6. Zdarzenia aplikacji i sesji
Zdarzenie Moment
zadziałania
Application_OnStart
Zdarzenie uruchamiane w chwili żądania dostępu do
pierwszej strony aplikacji ASP.
Application_OnEnd
Kod zdarzenia uruchamiany jest w chwili zamknięcia
serwera IIS.
Session_OnStart
Uruchamiane w chwili, gdy dowolny gość wywołuje swoją
pierwszą stronę aplikacji ASP.
Session_OnEnd
Kod procedury uruchamiany jest po upłynięciu czasu
trwania sesji lub w chwili wywołania metody
Abandon
.
Struktura procedury zdarzenia przedstawia się następująco:
Sub NameOfEvent
'kod zdarzenia
End Sub
Pierwszy wiersz procedury rozpoczyna się słowem kluczowym
Sub
, po którym następuje nazwa procedury. W
kolejnych wierszach zawarty jest kod uruchamiany w przypadku wystąpienia danego zdarzenia. Ostatni wiersz
procedury zawiera kluczowe słowa
End Sub
.
Zdarzenie Application_OnStart
Kiedy odwiedzający żąda dostępu do strony twojej aplikacji ASP po raz pierwszy od uruchomienia serwera,
zadziała zdarzenie
Application_OnStart
. Zdarzenie to jest uruchamiane przed jakimkolwiek innym kodem
żądanej strony, jak również przed uruchomieniem zdarzenia
Session_OnStart
.
Zdarzenie
Application_OnStart
uruchamiane jest tylko jeden raz i nie stanie się to ponownie, dopóki aplikacja
nie zakończy swego działania. Kod tego zdarzenia może uzyskiwać dostęp do obiektów
Application
i
Server
.
Obiekty
Request
,
Response
i
Session
nie są osiągalne w tym wypadku.
Zdarzenie ma następującą składnię:
Sub Application_OnStart
'kod procedury
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
256
End Sub
Typowo zdarzenie to używane jest podczas inicjacji programu. Jest to kod, który chcesz uruchomić jeden tylko
raz, przy starcie twojej aplikacji. Często wymaga to tworzenia zmiennych i obiektów aplikacji. To zdarzenie
jest wykorzystywane również przez kod powiadomienia.
We wcześniejszej części rozdziału zwróciliśmy uwagę na stronę obliczającą całkowitą należność za
zamówienie. Kod używał zmiennych aplikacji deklarowanych w stronie ASP w celu określenia całkowitej
kwoty zamówienia. Te zmienne powinny być inicjowane w zdarzeniu
Application_OnStart
:
Sub Application_OnStart
Application("CurrentDiscount") = .9
Application("MinShipHand") = 12
Application("MinQuantity") = 2
Application("ShipHandPercent") = .07
End Sub
Nie musimy martwić się tutaj o blokowanie zmiennych aplikacji, ponieważ zdarzenie to jest uruchamiane i
działa przed jakimkolwiek innym kodem aplikacji ASP.
Kolejnym dobrym przykładem zastosowania tego zdarzenia jest dostosowywanie programu do potrzeb
użytkownika. Powiedzmy, że tworzysz aplikację ASP, która używana będzie przez wiele organizacji. Chcesz
dostarczyć im minimum informacji na temat stron ASP, aby swobodnie mogli korzystać z tego narzędzia.
Jednak aplikacja ASP może być dostosowywana na potrzeby wielu klientów, chcesz więc, aby mieli możliwość
zrobienia tego we własnym zakresie. Jedynym sposobem na dokonanie tego jest stworzenie serii zmiennych
konfiguracyjnych w zdarzeniu
Application_OnStart
. Pozwoli to twoim użytkownikom na centralną
modyfikację możliwości programu. Weźmy na przykład:
Sub Application_OnStart
Application("DNS") = "OC"
Application("UserName") = "Admin"
Application("Password") = "yourpassword"
Application("AllowNew") = "Yes"
Application("AllowEnroll") = "Yes"
Application("Path2Logo") = "./images/logo.gif"
Application("AllowDrop") = "No"
Application("ChatMode") = "External"
End Sub
Ten kod pozwala na dostosowanie aplikacji ASP, będącej szkołą online. Po pierwsze użytkownicy określają
nazwę DNS-a łączącego się z bazą danych szkoły:
Application("DNS") = "OC"
Mogą określić również użytkownika logującego się do bazy danych:
Application("UserName") = "Admin"
oraz hasło tego użytkownika:
Application("Password") = "yourpassword"
Następnie mogą kontrolować sposób funkcjonowania programu. Czy chcą udzielać dostępu nowym uczniom?
Jeśli tak, należy umieścić następujący wiersz kodu:
ASP – Kompendium programisty
257
Application("AllowNew") = "Yes"
Czy chcą, aby uczniowie mogli zapisać się na kurs? Jeśli tak, kod będzie taki:
Application("AllowEnroll") = "Yes"
Następnie klienci określają położenie ich logo firmowego:
Application("Path2Logo") = "./images/logo.gif"
Mogą określić, czy zezwolą na porzucenie kursu przez ucznia:
Application("AllowDrop") = "No"
Na końcu typ używanego programu do pogawędek:
if Application("AllowEnroll") = "Yes" then
%>
Application("ChatMode") = "External"
W twojej dokumentacji mógłbyś podać użytkownikom stosowne instrukcje, traktujące o znaczeniu i
wartościach tych zmiennych aplikacji. Wtedy mógłbyś w kodzie kontrolować opcje strony w oparciu o ich
preferencje. Oto na przykład kod strony rekrutacji uczniów na kursy:
<%
Option Explicit
Dim conn
Dim RSCourses
set conn = server.createobject ("adodb.connection")
conn.open Application("DNS"), Application("UserName"), _
Application("Password")
set RSCourses = conn.execute ("SELECT CourseID, CourseName, " _
& CourseDescription FROM OCCourses")
%>
<P ALIGN="CENTER"><B><FONT COLOR="#0000A0" SIZE="+3"
FACE="Arial,Helvetica">Wybierz kurs</B></FONT>
<%
do until RSCourses.EOF
<A HREF="../html/enrolldrop.asp?CourseID=
<% Response.Write RSCourses("CourseID") %>">
<IMG HEIGHT=52 WIDTH=56 SRC="../assets/images/p048.gif"
BORDER=0 ALT="Enroll" ></A>
<P><B><FONT FACE="Arial,Helvetica">
<% Response.Write RSCourses("CourseName") %> -
<% Response.Write RSCourses("CourseDescription") %></B></FONT>
<%
RSCourses.MoveNext
loop
end if
%>
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
258
Na wstępie stwierdzamy, że będziemy deklarować nasze zmienne:
Option Explicit
Następnie tworzymy zmienną, która będzie używana do połączenia z bazą danych:
Dim conn
oraz zmienną wyszukującą informacje o kursie:
Dim RSCourses
Tutaj sprawdzamy preferencje określone w zdarzeniu
Application_OnStart
aby się przekonać, czy w ogóle
należy wyświetlić informacje dotyczące rekrutacji:
if Application("AllowEnroll") = "Yes" then
Jeśli wpisano wartość
"Yes"
, wtedy powinniśmy wyświetlić te informacje. Możemy więc utworzyć obiekt
połączenia:
set conn = server.createobject ("adodb.connection")
Zwróć uwagę na to, że zmienne aplikacji używane są do określenia DNS-a, nazwy użytkownika oraz hasła —
danych potrzebnych do połączenia z bazą danych:
conn.open Application("DNS"), Application("UserName"), _
Application("Password")
Informacja o kursach jest wyszukiwana w bazie danych:
set RSCourses = conn.execute ("SELECT CourseID, CourseName, " _
& CourseDescription FROM OCCourses")
Zauważ, że ten HTML jest częścią instrukcji
If
. Nie będzie on wykonany, jeśli w zmiennej
AllowEnroll
znajdzie co innego niż
"Yes"
:
<P ALIGN="CENTER"><B><FONT COLOR="#0000A0" SIZE="+3"
FACE="Arial,Helvetica">Wybierz kurs</B></FONT>
Następnie rozpoczynamy przechodzenie w pętli przez wszystkie kursy znajdujące się w bazie danych:
do until RSCourses.EOF
Każdy kurs wpisywany jest do przeglądarki jako łącze pozwalające gościowi zapisać się na wybrany z nich:
<A HREF="../html/enrolldrop.asp?CourseID=
<% Response.Write RSCourses("CourseID") %>">
<IMG HEIGHT=52 WIDTH=56 SRC="../assets/images/p048.gif"
BORDER=0 ALT="Enroll" ></A>
<P><B><FONT FACE="Arial,Helvetica">
<% Response.Write RSCourses("CourseName") %> -
<% Response.Write RSCourses("CourseDescription") %></B></FONT>
ASP – Kompendium programisty
259
Następnie przechodzimy w pętli do przetwarzania następnego kursu:
RSCourses.MoveNext
loop
i kończymy blok
If
:
end if
Zdarzenie Application_OnEnd
Jak stwierdzono wcześniej, aplikacja rozpoczyna swe działanie w chwili, gdy gość uzyskuje dostęp do jednej ze
stron twojej witryny. Odpowiedni na ten moment kod tworzysz w obrębie zdarzenia
Application_OnStart
.
Możesz również określić kod, który będzie uruchamiany przy zakończeniu działania aplikacji.
Aplikacja kończy swe działanie w chwili, gdy serwer jest wyłączany, możesz więc stworzyć kod
zawiadomienia o porządkowaniu lub jakiegoś innego typu. Uważaj jednak na to, co umieszczasz w tym
miejscu, ponieważ czasami twoja aplikacja zatrzyma się z powodu błędu lub problemu z serwerem. Jeśli tak się
stanie, twój końcowy kod nigdy nie zostanie uruchomiony. Z tego powodu osobiście nie używam tego
zdarzenia.
Zdarzenie ma następującą składnię:
Sub Application_OnEnd
'kod procedury
End Sub
Wiersz komentarza
"kod procedury"
możesz zastąpić dowolnym kodem uruchamianym w czasie wystąpienia
tego zdarzenia.
Zdarzenie Session_OnStart
Jednym z wielce użytecznych zastosowań zdarzenia
Session_OnStart
jest uniemożliwienie gościom wejścia na
którąkolwiek ze stron twojej witryny, zanim nie wejdą na określoną przez ciebie stronę. Możesz na przykład
wymagać od użytkowników przejścia przez twoją stronę główną, nim odwiedzą jakąkolwiek inną część twej
witryny. Być może chcesz, aby logowali się tam przed przejściem dalej.
Za każdym razem, gdy gość uzyskuje dostęp do twojej aplikacji ASP, uruchamiane jest zdarzenie
Session_OnStart
, a wtedy rozpocznie działanie dowolny kod umieszczony w tym zdarzeniu. Zdarzenie
Session_OnStart
następuje po zdarzeniu
Application_OnStart
, ale przed jakimkolwiek innym kodem strony
ASP wywoływanej przez odwiedzającego.
Kiedy zdarzenie
Session_OnStart
zostanie uruchomione, wszystkie obiekty ASP stają się dla ciebie dostępne i
możesz je wykorzystać w kodzie. Zdarzenie to ma następującą składnię:
Sub Session_OnStart
'kod procedury
End Sub
Zazwyczaj w tym miejscu umieszcza się kod inicjacji użytkownika, łączący w sobie takie rzeczy jak tworzenie
rekordu w bazie danych na potrzeby sesji, uruchomienie koszyka na zakupy, ustawienie preferencji oraz
tworzenie zmiennych i obiektów sesji wykorzystywanych w tym zdarzeniu.
Poniżej zaprezentowano, w jak prosty sposób można tego dokonać przy użyciu zdarzenia
Session_OnStart
:
Sub Session_OnStart
Response.Redirect "./welcome.asp"
End Sub
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
260
Pamiętaj, że zdarzenie
Session_OnStart
jest uruchamiane przed jakimkolwiek innym kodem stron aplikacji
ASP, tak więc bez względu na to, jaką stronę ASP gość wpisze w przeglądarce, będą musieli najpierw
odwiedzić stronę powitania.
Weź pod uwagę na prosty przykład użycia takiego kodu. Przykładowa witryna ma dwie strony: stronę
powitania oraz jakąś inną. Kiedy goście wpiszą w przeglądarce adres innej strony, nie zobaczą jej. W zamian
ujrzą stronę powitania ukazaną na rysunku 8.10. Goście nie mogą więc przejść wprost do jakiejś innej strony
witryny. Muszą najpierw wejść na stronę powitania w celu zalogowania się lub po prostu w celu przejścia przez
witrynę w sposób przez ciebie wymagany.
Rysunek 8.10. Powitalna strona próbnej witryny
Jeśliby jednak goście wpisaliby w przeglądarce adres innej strony, wtedy ujrzeliby ją, ponieważ ich sesja
właśnie się rozpoczęła. Spójrz na rysunek 8.11.
Rysunek 8.11. Wygląd drugiej strony próbnej witryny
ASP – Kompendium programisty
261
Zdarzenie Session_OnEnd
Sesja rozpoczyna się w momencie uzyskania przez gościa dostępu do pierwszej strony twojej aplikacji ASP.
Kończy się natomiast, gdy wywołasz metodę
Abandon
lub gdy czas jej trwania upłynie z powodu braku
kolejnego żądania dostępu do strony w wymaganej liczbie minut.
Kiedy sesja się skończy, uruchamiane jest zdarzenie
Session_OnEnd
, w którym możesz programowo
wykorzystać obiekty
Application
,
Server
i
Session
, ale obiekty
Request
i
Response
nie są w tym momencie
dostępne. Zdarzenie ma następującą składnię:
Sub Session_OnEnd
'kod procedury
End Sub
W to zdarzenie możesz włączyć kod porządkowania. Możesz wpisać do bazy danych datę i godzinę
zakończenia sesji gościa. Mógłbyś użyć również tego zdarzenia do zakończenia przetwarzania zadań, które
stale pozostają otwarte lub do wysłania jakichś zawiadomień pocztą elektroniczną (jeśli jest to wymagane) przy
użyciu obiektów CDO, które omówiono w następnym rozdziale.
Poniżej przedstawiono przykład tego, co można włączyć do zdarzenia
Session_OnEnd
. Ta procedura umieszcza
nazwę komputera gościa w bazie danych, możesz więc rozpoznawać tożsamość gości twojej witryny. Wartość
ta nie jest normalnie dostępna poprzez serwer IIS, ponieważ zwykle otrzymujesz jedynie adres IP gościa. Kod
wykorzystuje niezależne narzędzie, które przeprowadza przeszukiwanie w tył adresu IP w celu określenia
nazwy komputera. Gdyby kod ten nie był umieszczony w zdarzeniu
Session_OnEnd
, wystąpiłby problem
związany ze zbyt długim czasem przetwarzania kodu i wstrzymaniem wyświetlenia żądanej strony w
przeglądarce gościa. Teraz jednak, gdy kod ten znalazł się w zdarzeniu
Session_OnEnd
, odwiedzający nie muszą
czekać na przetworzenie tego kodu:
Sub Session_OnEnd
Dim conn
Dim objDNS
Dim hostname
Dim GMT
set objDNS = server.createobject("INet.DNS.1")
objDNS.ip = request.servervariables("remote_addr")
If objDNS.Host <> "" Then
hostname = objDNS.Host
Else
hostname = request.servervariables("remote_addr")
End If
GMT = Cstr (dateadd("h", 6, now()))
set conn = server.createobject ("adodb.connection")
conn.open "IISLog", "sa", "yourpassword"
SQL = "update iislog..sessions set session_end = '" & GMT _
& "', hostname = '" & hostname & "'"
SQL = SQL & " where Session_id = " & cstr(Session("session_id"))
conn.Execute SQL
End Sub
Po pierwsze deklarowane są pewne zmienne, które będą używane w tym zdarzeniu. Jedna z nich będzie
zapamiętywała kopię narzędzia przeszukiwania w tył DNS:
Dim objDNS
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
262
Następnie tworzona jest zmienna zapamiętująca połączenie z bazą danych:
Dim conn
Tworzona również jest zmienna przechowująca nazwę komputera gościa:
set objDNS = server.createobject("INet.DNS.1")
hostname = request.servervariables("remote_addr")
conn.open "IISLog", "sa", "yourpassword"
Dim hostname
oraz zmienna przechowująca czas Greenwich (GMT):
Dim GMT
Wykorzystywany jest obiekt
Server
do stworzenia kopii narzędzia przeszukiwania w tył:
Do właściwości
IP
tego obiektu wpisywany jest adres IP systemu gościa:
objDNS.ip = request.servervariables("remote_addr")
Do właściwości
Host
obiektu
DNS
jest teraz wpisywana nazwa komputera gościa. Jeśli jest to nazwa nieznana,
ustawioną wartością będzie pusty ciąg:
If objDNS.Host <> "" Then
Jeśli nie, oznacza to, że nazwa komputera została odnaleziona:
hostname = objDNS.Host
W innym wypadku nazwa komputera nie została odnaleziona i wykorzystany będzie jedynie adres IP:
Else
End If
Chcemy również zapamiętać w bazie danych datę i godzinę zakończenia sesji odwiedzającego. Czas
zapamiętywany jest w formacie GMT, który powstaje tutaj (USA) po dodaniu sześciu godzin do czasu strefy
lokalnej, obowiązującego na serwerze:
GMT = Cstr (dateadd("h", 6, now()))
Następnie zestawiane jest połączenie z bazą danych:
set conn = server.createobject ("adodb.connection")
(Użyty tutaj obiekt
Connection
zostanie szczegółowo omówiony w rozdziale 14).
Instrukcja
SQL
zbudowana jest przy użyciu nazwy komputera oraz czasu zakończenia sesji. Te wartości będą
wprowadzone do rekordu bazy danych korespondującego z numerem identyfikacyjnym sesji gościa
(
Session_ID
):
SQL = "update iislog..sessions set session_end = '" & GMT _
ASP – Kompendium programisty
263
& "', hostname = '" & hostname & "'"
SQL = SQL & " where Session_id = " & cstr(Session("session_id"))
conn.Execute SQL
Deklaracje obiektów w pliku global.asa
Wspomniane znaczniki umieszczone są poza znacznikami
Script
w pliku global.asa i mają następujący format:
<OBJECT RUNAT=Server SCOPE=TheScope ID=Name PRODIG="App.Class">
conn.Execute "insert into WICustomers (SessionDateTime) values ('"_
set RSSession = conn.Execute("select SessionID from WICustomers "_
Ta instrukcja
SQL
jest następnie wykonywana w celu modyfikacji bazy danych:
Jak mogliśmy się przekonać z treści poprzednich podrozdziałów poświęconych obiektom
Application
i
Session
, na tych poziomach obiekty możemy tworzyć poprzez znaczniki
Object
w pliku global.asa. Te obiekty
są udostępniane w kodzie przez zbiór
StaticObjects
zarówno obiektu
Application
, jak i
Session
.
</OBJECT>
Tekst
TheScope
należy zastąpić słowem
Session
, gdybyś chciał stworzyć obiekt poziomu sesji lub słowem
Application
, gdybyś tworzył obiekt poziomu aplikacji. Tekst
Name
należy zamienić na nazwę obiektu, do której
będziesz się odwoływał w kodzie. Zamiast ciągu
App.Class
w deklaracji musi znaleźć się nazwa serwera oraz
klasa, którą chcesz utworzyć.
Na przykład poniżej tworzymy obiekt poziomu aplikacji o nazwie
Aconn
, który będzie obiektem połączenia z
bazą danych ADO:
<OBJECT RUNAT=Server SCOPE=Application ID=Aconn PRODIG="adodb.
connection">
</OBJECT>
A tutaj tworzymy obiekt poziomu sesji o nazwie
SobjMail
o klasie
NewMail
obiektu CDO:
<OBJECT RUNAT=Server SCOPE=Session ID=SobjMail PRODIG="CDONTS.NewMail">
</OBJECT>
Aplikacje ASP w użyciu
Materiał omówiony w tym rozdziale naprawdę przedstawia ASP jako technologię, dzięki której możliwe będzie
tworzenie całościowych rozwiązań na potrzeby twojego firmowego Internetu bądź intranetu. Bez obiektów
Application
i
Session
twoja witryna byłaby niczym więcej, jak tylko serią stron, od przypadku do przypadku
łączących się ze sobą. Jednak dzięki tym obiektom możesz tworzyć prawdziwe aplikacje w pełnym tego słowa
znaczeniu.
Weź pod uwagę stronę e-commerce. Rysunek 8.12. przedstawia prawdziwą stronę, którą administruję. Strona
pokazana na rysunku jest częścią kreatora zamówień. Zapytuje ona gości o konieczne szczegóły na temat
zamawianego produktu. Strona w dużym stopniu bazuje na obiekcie
Session
w celu śledzenia poczynań gości
tak, aby w ich koszyku znalazły się właściwe produkty, jak to widać w kodzie tej strony:
if isempty(Session("SessionID")) then
CurrentDateTime = Now
& CurrentDateTime & "')"
& "where SessionDateTime = '" & CurrentDateTime & "'") Session("SessionID") =
RSSession("SessionID")
Rozdział 8 – Obiekt Session, Obiekt Application, oraz plik global.asa
264
end if
''''''''''
set RSTotal = conn.Execute("select Sum(TotalPrice) as TheTotal from
WIOrderItems "_
& "where SessionID = " & Session("SessionID"))
if RSTotal("TheTotal") * Application("ShipPercent") > Application
("MinShip") then
TopShipping = RSTotal("TheTotal") * Application("ShipPercent")
else
TopShipping = Application("MinShip")
end if
'''''''''''
Response.Redirect "https://www.netstats2000.com/bud/html/"_
& shopping_cart.asp?SessionID=" & Session(SessionID")
W pierwszej części kodu sprawdzamy, czy zmienna sesji o nazwie
SessionID
jest pusta:
if isempty(Session("SessionID")) then
Jeśli zmienna sesji jest pusta oznacza to, że gość umieścił w koszyku swój pierwszy wybrany produkt i należy
stworzyć dla niego odpowiedni rekord. Aktualna data i godzina systemowa będzie częścią rekordu koszyka:
CurrentDateTime = Now
Rekord jest dodawany do bazy danych:
conn.Execute "insert into WICustomers (SessionDateTime) values ('"_
& CurrentDateTime & "')"
Numer identyfikacyjny nowo utworzonego rekordu koszyka jest wyszukiwany w bazie danych:
set RSSession = conn.Execute("select SessionID from WICustomers "_
& "where SessionDateTime = '" & CurrentDateTime & "'")
W zmiennej sesji
SessionID
ustawiana jest wartość z rekordu koszyka:
Session("SessionID") = RSSession("SessionID")
Następna część kodu oblicza koszty wysyłki zamówionych produktów. Po pierwsze obliczany jest całkowity
koszt zamówienia na bazie wyszukanych kosztów poszczególnych produktów w koszyku znajdujących się w
zmiennej
SessionID
:
set RSTotal = conn.Execute("select Sum(TotalPrice) as TheTotal from
WIOrderItems "_
& "where SessionID = " & Session("SessionID"))
Następnie zmienne aplikacji wykorzystywane są do porównania kosztu wysyłki z minimalną wartością tego
kosztu:
if RSTotal("TheTotal") * Application("ShipPercent") > Application
("MinShip") then
ASP – Kompendium programisty
265
Jeśli procentowa wartość kosztu wysyłki jest większa od dwóch, wykorzystujemy ją:
TopShipping = RSTotal("TheTotal") * Application("ShipPercent")
W innym wypadku używamy minimalnego kosztu wysyłki:
TopShipping = Application("MinShip")
Widzisz więc, że dobrze rozplanowana, złożona aplikacja ASP w pełni wykorzystuje funkcje obiektów
Application
i
Session
.
Rysunek 8.12. Kreator zamówień
Rozdział 9. Obiekty CDO dla Windows
NT Server
Uzupełnienie strony ASP o funkcję wysyłania wiadomości e-
mail
Obiekt danych współpracujących dla Windows NT Server (Collaborative Data Objects, CDONTS, CDO dla
NTS) pozwala na tworzenie kopii umożliwiających wysyłanie wiadomości e-mail z twoich stron lub aplikacji
ASP. Biblioteka CDONTS ukazuje główną klasę, którą możemy stworzyć, NewMail, dostarczającą łatwych w
użyciu metod i właściwości pozwalających na wysyłanie wiadomości e-mail z twoich stron ASP. Treść tego
rozdziału koncentruje się na tym obiekcie.
CDONTS zaprojektowano tak, aby działał w systemie Windows NT Server dysponującym serwerem IIS wersji
4.0 lub późniejszej. Biblioteka nie wymaga uruchomienia serwera wymiany (Exchange Server). Jeśli posiadasz
serwer wymiany w twoim systemie, musi on być zainstalowany po IIS, aby również biblioteka CDONTS była
poprawnie zainstalowana. Jeśli nie posiadasz serwera wymiany, będziesz musiał korzystać z serwera SMTP
dostarczanego wraz z IIS w celu poprawnego funkcjonowania biblioteki CDONTS. Powinieneś zobaczyć
witrynę SMTP w serwerze IIS, co pokazano na rysunku 9.1.
Rysunek 9.1. Witryna SMTP w serwerze IIS
Jeśli nie posiadasz Microsoft Exchange’a, możesz tutaj skonfigurować witrynę SMTP przeglądając jej
właściwości. Jeśli nie jest ona widoczna w IIS, to prawdopodobnie nie wybrałeś tego składnika w czasie
instalacji IIS. Uruchom ponownie instalację i dodaj ten składnik.
ASP – Kompendium programisty
267
Obiekt NewMail
W kilku przykładach użytych już w tej książce mogłeś widzieć obiekt
NewMail
w działaniu. Przy jego użyciu
możesz wysyłać podstawowe wiadomości e-mail w trzech prostych wierszach kodu twojej strony ASP:
Set objMail = Server.CreateObject("CDONTS.NewMail")
objMail.Send "bob@na.com", "Julie@na.com, "Witamy!", _
"Witamy w naszej firmie Julio. Cieszymy się, że tu jesteś — Bob"
Set objMail = Nothing
To wszystko, trzy wiersze. Najpierw tworzysz obiekt
NewMail
z biblioteki
CDONTS
:
Set objMail = Server.CreateObject("CDONTS.NewMail")
Następnie używasz metody
Send
w celu wysłania wiadomości e-mail. Pierwszy parametr metody
Send
określa
wysyłającego wiadomość; drugi parametr to adresat wiadomości; trzeci to temat wiadomości; ostatni to sama
jej treść:
objMail.Send "bob@na.com", "Julie@na.com, "Witamy!", _
"Witamy w naszej firmie Julio. Cieszymy się, że tu jesteś! — Bob"
W końcu zwalniasz zasoby obiektu
NewMail
:
Set objMail = Nothing
Wiadomość e-mail wysyłana jest do odbiorcy. Powyższy kod wygeneruje wiadomość pokazaną na rysunku 9.2.
Dzięki zastosowaniu obiektu
NewMail
możesz jednak zrobić znacznie więcej niż to, co pokazano na tym
prostym przykładzie. W dalszej części tego rozdziału przyjrzymy się dokładnie właściwościom i metodom
obiektu
NewMail
.
Rysunek 9.2. Wiadomość e-mail wysłana przy użyciu metody
Send
obiektu
NewMail
Rozdział 9 – Obiekt CDO dla Windows NT Server
268
Właściwości obiektu NewMail
Właściwości obiektu
NewMail
pozwalają na dostosowanie do potrzeb klienta sposobu wysyłania wiadomości e-
mail. Tabela 9.1. przedstawia sumarycznie te właściwości, które zostały tutaj omówione.
Tabela 9.1. Właściwości obiektu
NewMail
Właściwość Przeznaczenie
To
Adres e-mail odbiorcy
From
Adres e-mail nadawcy
Subject
Temat wiadomości
Body
Treść wiadomości
CC
Odbiorcy listu typu DW
BCC
Odbiorcy zamaskowanego listu typu DW (UDW)
Importance
Ustawia poziom ważności wiadomości
BodyFormat
Określa format tekstu wiadomości, zwykły tekst lub HTML
MailFormat
Określa kodowanie wiadomości, tekstowe lub MIME
ContentBase
Baza adresu URL dla wszystkich łącz w wiadomości
ContentLocation
Określa ścieżkę dostępu do wszystkich łączy URL w treści
wiadomości
Value
Dodaje nagłówki do wiadomości
Version
Zwraca wersję biblioteki CDONTS
Właściwość To
Właściwość
To
pozwala na określenie adresu e-mail odbiorcy. Właściwość ta ma następującą formę:
ObjMail.To = ListOfRecipients
ObjMail
w tym kodzie musi być obiektem klasy
NewMail
biblioteki CDONTS. Zmienna
ListOfRecipients
jest
adresem poczty elektronicznej osoby lub osób, do których chcesz wysłać wiadomość. Możesz zaadresować
wiadomość do jednej osoby w następujący sposób:
ObjMail.To = "harris@na.com"
Możesz również wysłać wiadomość do wielu odbiorców, oddzielając każdy z adresów średnikiem, jak to
pokazano poniżej:
ObjMail.To = "harris@na.com;julie@na.com;ruth@na.com"
W tym momencie e-mail wysłany zostanie pod trzy adresy. Zwróć uwagę na to, że możemy określić odbiorcę
wiadomości za pomocą właściwości
To
lub używając parametru metody
Send
, tak więc poprzedni wiersz
mógłby być zastąpiony przez taki kod:
objMail.Send "bob@na.com", "harris@na.com;julie@na.com;ruth@na.com", _
"Witamy!", "Witamy wszystkich w firmie. Cieszymy się z waszej obecności! –—- Bob"
Jeśli korzystasz z właściwości
To
, po prostu nie wpisuj drugiego parametru metody
Send
:
ObjMail.To = "harris@na.com;julie@na.com;ruth@na.com"
objMail.Send "bob@na.com", , "Witamy!", _
"Witamy wszystkich w firmie. Cieszymy się z waszej obecności! –—- Bob"
ASP – Kompendium programisty
269
Jeśli używasz zarówno właściwości
To
, jak i parametru metody
Send
, wiadomość zostanie wysłana pod
wszystkie adresy z obu list. Tak więc ten kod:
objMail.Send "bob@na.com", "nancy@na.com", "Witamy!", _
ObjMail.To = "harris@na.com;julie@na.com;ruth@na.com"
"Witamy wszystkich w firmie. Cieszymy się z waszej obecności! –—- Bob"
wysłałby e-mail do czterech odbiorców: trzech z nich określono we właściwości
To
i jednego w drugim
parametrze metody
Send
.
Właściwość From
Właściwość
From
zapamiętuje adres poczty elektronicznej nadawcy. Właściwość ta ma następującą formę:
ObjMail.From = EmailAddressOfSender
ObjMail
musi być tutaj ważnym obiektem
NewMail
biblioteki CDONTS. Zmienna
EmailAddressOfSender
musi
być pełnym adresem e-mail, na przykład:
ObjMail.From = "marg@na.com"
W tej właściwości możesz określić jednego tylko nadawcę. Innymi słowy nie możesz zastosować średników w
celu określenia wielu nadawców; jeśli tak zrobisz, wystąpi błąd w przeglądarce, który prezentuje rysunek 9.3.
Rysunek 9.3. Wiadomość o wystąpieniu błędu, który wywołany został określeniem wielu nadawców
Do określenia nadawcy możesz użyć właściwości
From
lub zamiennie parametru metody
Send
. Tak więc ten
kod:
objMail.To = "julie@na.com;jill@na.com"
objMail.From = "bob@na.com"
objMail.Send , , "Wiadomość próbna", _
"Ta wiadomość została wysłana do wszystkich z listy."
Rozdział 9 – Obiekt CDO dla Windows NT Server
270
jest funkcjonalnym zamiennikiem tego kodu:
objMail.To = "julie@na.com;jill@na.com"
objMail.Send "bob@na.com", , "Wiadomość próbna", _
"Ta wiadomość została wysłana do wszystkich z listy."
Jeśli podasz parametr zarówno w metodzie
Send
, jak i właściwości
From
, w wysłanej wiadomości pojawi się
nadawca określony poprzez metodę
Send
.
Właściwość Subject
Właściwości
Subject
możesz użyć do określenia tematu wiadomości. Ma ona następujący format:
ObjMail.Subject = TheSubject
ObjMail
musi być ważnym obiektem
NewMail
serwera CDONTS.
TheSubject
jest ciągiem reprezentującym
temat wiadomości. Użycie takiego kodu:
ObjMail.Subject = "Witamy!"
spowoduje, że tematem wiadomości będzie tekst
"Witamy!"
. Temat wiadomości możesz określić przy użyciu
właściwości
Subject
, jak również wykorzystując w tym celu trzeci parametr metody
Send
. Tak więc taki kod:
objMail.To = "julie@na.com;jill@na.com"
objMail.From = "bob@na.com"
objMail.Subject = "Witamy!"
objMail.Send , , , _
"Ta wiadomość została wysłana do wszystkich z listy."
można zastąpić takim, wywołującym te same rezultaty:
objMail.To = "julie@na.com;jill@na.com"
objMail.From = "bob@na.com"
objMail.Send , , "Witamy!", _
"Ta wiadomość została wysłana do wszystkich z listy."
Jeśli zastosujesz zarówno właściwość
Subject
, jak i trzeci parametr metody
Send
, użyty zostanie ten określony
przez metodę
Send
.
Właściwość Body
Właściwość Body określa tekst wiadomości lub jej HTML, jak będziesz mógł się przekonać nieco później.
Właściwość ta ma następującą formę:
ObjMail.Body = BodyText
ObjMail
musi być ważnym obiektem
NewMail
biblioteki CDONTS.
BodyText
jest treścią wiadomości. Taki kod:
ObjMail.Body = "Ta wiadomość została wysłana do wszystkich z listy."
spowoduje, że wiadomość będzie zawierała powyższy tekst. Do określenia treści wiadomości możesz użyć
właściwości
Body
lub czwartego parametru metody
Send
, tak więc to:
objMail.To = "julie@na.com;jill@na.com"
ASP – Kompendium programisty
271
objMail.From = "bob@na.com"
objMail.Subject = "Witamy!"
objMail.Body = "Dziękujemy za odwiedzenie naszej witryny!"
ObjMail.Send
jest funkcjonalnie tożsame z tym:
objMail.To = "julie@na.com;jill@na.com"
objMail.From = "bob@na.com"
objMail.Subject = "Witamy!"
ObjMail.Send , , , "Dziękujemy za odwiedzenie naszej witryny!"
Kiedy tworzysz wiadomości e-mail w twoim kodzie przekonasz się, że musisz je sformatować przy użyciu
nowych wierszy w celu zaznaczenia przerw w tekście. Możesz to zrobić wykorzystując funkcję
Chr
, której
parametrem jest liczba, a wartością zwracaną znak odpowiadający tej liczbie. Jeśli chciałbyś wstawić nowy
wiersz, kod będzie taki:
Chr(13)
Jeśli chcesz wstawić znak tabulacji:
Chr(9)
Kolejnym znakiem, który być może będziesz chciał wstawić w tekst wiadomości to cudzysłów. Możesz to
zrobić wstawiając tekst w cudzysłowie w cudzysłów podwójny.
Weź pod uwagę następujący blok kodu, zawierający cudzysłowy i nowe wiersze w treści wiadomości:
<%
Option Explicit
Dim objMail
Dim TheMessage
Set objMail = Server.CreateObject("CDONTS.NewMail")
objMail.To = "julie@na.com;jill@na.com"
objMail.From = "bob@na.com"
objMail.Subject = "Witamy!"
TheMessage = "Cześć:" & chr(13) & chr(13) _
& "Dziękujemy za odwiedzenie naszej witryny!" & chr(13) & chr(13) _
& """Cenimy sobie Twoją firmę!"""
objMail.Body = TheMessage
objMail.Send
response.write "gotowe"
Set objMail = Nothing
%>
Po pierwsze zaznaczamy, że będziemy deklarować nasze zmienne:
Option Explicit
Następnie tworzona jest zmienna, która będzie przechowywała nasz obiekt
NewMail
:
Dim objMail
Rozdział 9 – Obiekt CDO dla Windows NT Server
272
Kolejna zmienna przeznaczona jest do przechowywania tekstu wiadomości:
Dim TheMessage
Następnie wykorzystujemy metodę
CreateObject
obiektu
Server
do stworzenia kopii obiektu
NewMail
:
Set objMail = Server.CreateObject("CDONTS.NewMail")
Określamy adresata wiadomości:
objMail.To = "julie@na.com;jill@na.com"
nadawcę:
objMail.From = "bob@na.com"
i temat wiadomości:
objMail.Subject = "Witamy!"
Tekst wiadomości zapamiętywany jest w zmiennej
TheMessage
. Zauważ, że użyto tutaj funkcji
Chr
do
stworzenia nowych wierszy, a poza tym podwójnego cudzysłowu dla zaznaczenia cudzysłowu w cudzysłowie:
TheMessage = "Cześć:" & chr(13) & chr(13) _
& "Dziękujemy za odwiedzenie naszej witryny!" & chr(13) & chr(13) _
& """Cenimy sobie Twoją firmę!"""
Dla właściwości
Body
ustawiana jest wartość zmiennej
TheMessage
:
objMail.Body = TheMessage
Wiadomość jest wysyłana:
objMail.Send
a obiekt zwalnia pamięć:
Set objMail = Nothing
Stworzony w ten sposób e-mail przedstawiono na rysunku 9.4. Zwróć uwagę na położenie cudzysłowu oraz
nowych wierszy.
ASP – Kompendium programisty
273
Rysunek 9.4. E-mail zawierający znaki specjalne
Właściwość CC
Właściwość
CC
pozwala określić odbiorców wiadomości, nie będących odbiorcami głównymi. Odbiorcy listu
typu DW (ang. CC — Carbon Copy) widzą tą samą wiadomość, co odbiorcy główni, są jednak
wyszczególnieni w nagłówku wiadomości jako adresaci drugorzędni.
Właściwość przyjmuje następującą formę:
ObjMail.CC = CCList
ObjMail
musi być zatwierdzoną kopią klasy
NewMail
biblioteki CDONTS.
CCList
jest ciągiem zawierającym
listę adresów poczty elektronicznej. Możesz określić pojedynczego odbiorcę listu typu DW:
ObjMail.CC = "joe@na.com"
lub większą ich liczbę oddzielając każdego z nich średnikiem:
ObjMail.CC = "joe@na.com;kate@na.com"
Właściwość BCC
Poprzez właściwość
BCC
możesz określić odbiorców zamaskowanego listu typu DW (UDW, ang. BCC — Blind
Carbon Copy). Adresat UDW otrzymuje tą samą wiadomość, co odbiorca główny i odbiorca DW, ale ci dwaj
ostatni nie są powiadamiani o adresie e-mail odbiorców listu UDW. Dzięki tej właściwości możesz chronić
prywatność poszczególnych osób.
Właściwość ma następującą formę:
ObjMail = BCCList
ObjMail
musi być zatwierdzoną kopią klasy
NewMail
biblioteki CDONTS.
BCCList
to ciąg łączący w sobie listę
adresów e-mail odbiorców zamaskowanego listu typu DW. Możesz określić pojedynczego odbiorcę listu
UDW:
Rozdział 9 – Obiekt CDO dla Windows NT Server
274
ObjMail.BCC = "joe@na.com"
lub, przy użyciu średników, wielu odbiorców:
ObjMail.BCC = "joe@na.com;kate@na.com"
Właściwość Importance
Różne aplikacje poczty elektronicznej pozwalają określać poziom ważności wysyłanych przez ciebie
wiadomości. Sposób wyświetlania tego znacznika ważności różni się w zależności od systemu. Za pomocą
właściwości
Importance
możesz określić w kodzie ważność wiadomości.
Składnia właściwości przedstawia się następująco:
ObjMail.Importance = Value
ObjMail
musi być ważną kopią obiektu
NewMail
. Dopuszczalne wartości
Value
przedstawia tabela 9.2.
Tabela 9.2. Wartości właściwości
Importance
Wartość Znaczenie
0 Niska
ważność
1 Normalna
ważność
(domyślna)
2 Wysoka
ważność
Możemy więc włączyć właściwość
Importance
do naszego bloku kodu:
<%
Option Explicit
Dim objMail
Dim TheMessage
Set objMail = Server.CreateObject("CDONTS.NewMail")
objMail.To = "julie@na.com "
objMail.From = "bob@na.com"
objMail.Subject = "Witamy!"
TheMessage = "Cześć:" & chr(13) & chr(13) _
& "Dziękujemy za odwiedzenie naszej witryny!" & chr(13) & chr(13) _
& """Cenimy sobie Twoją firmę!"""
objMail.Body = TheMessage
objMail.Importance = 2
objMail.Send
Set objMail = Nothing
response.write "gotowe"
%>
Kiedy ważność wiadomości jest wysoka, program obsługujący pocztę odbiorcy zazwyczaj czyni taką
wiadomość bardziej widoczną. Zwróć uwagę na zmianę, jaka zaszła w wyglądzie wiadomości prezentowanej
przez program Outlook z powodu nadania jej priorytetu ważności, co pokazano na rysunku 9.5.
ASP – Kompendium programisty
275
Rysunek 9.5. Wiadomość wykorzystująca właściwość
Importance
Właściwości BodyFormat i MailFormat
Wszystkie omówione do tej pory wiadomości miały format tekstowy. Możemy jednak wysyłać również
wiadomości e-mail w formacie HTML, korzystając przy tym z właściwości
BodyFormat
i
MailFormat
.
Właściwość
BodyFormat
ma następującą składnię:
ObjMail.BodyFormat = Value
ObjMail
jest obiektem
NewMail
serwera CDONTS. Wartość (
Value
) może wynosić domyślnie 1 co oznacza, że
treść wiadomości jest zwykłym tekstem. Wartość właściwości ustawiona na 0 oznacza, że treść wiadomości
zawiera HTML.
Aby wysłać wiadomość w formacie HTML, musisz również użyć właściwości
MailFormat
, która określa typ
kodowania wiadomości. Składnia właściwości przedstawia się następująco:
ObjMail.MailFormat = Value
ObjMail
musi być obiektem
NewMail
. Wartość (
Value
) może wynosić 0 lub 1. Domyślną wartością jest 1, co
oznacza, że zastosowano kodowanie tekstowe. Dla wiadomości HTML musisz użyć wartości 0 co oznacza, że
zastosowano kodowanie MIME.
Poniższy przykładowy kod wysyła wiadomość HTML o wysokiej ważności.
<%
Option Explicit
Dim objMail
Dim TheMessage
Set objMail = Server.CreateObject("CDONTS.NewMail")
objMail.To = "tim@na.com"
objMail.From = "bob@na.com"
objMail.Subject = "Zwariowaliśmy!"
TheMessage = "<HTML>" _
& "<HEAD>" _
Rozdział 9 – Obiekt CDO dla Windows NT Server
276
& "<TITLE>Mamy wyprzedaż</TITLE>" _
& "</HEAD>" _
& "<BODY>" _
& "<H1><CENTER>Wszystko tańsze o<STRIKE>30%</STRIKE> 50% !</CENTER></H1>" _
& "<HR>" _
& "<P>Stój więc! <A HREF=""http://www.na.com"">kliknij tutaj!</A></P>" _
& "</BODY>" _
& "</HTML>"
objMail.Body = TheMessage
objMail.Importance = 2
objMail.BodyFormat = 0
objMail.MailFormat = 0
objMail.Send
Set objMail = Nothing
%>
Po pierwsze stwierdzamy, że będziemy deklarować nasze zmienne:
Option Explicit
Następnie deklarujemy zmienną obiektu
NewMail
:
Dim objMail
oraz zmienną, która będzie przechowywała treść wiadomości HTML:
Dim TheMessage
Tworzymy kopię zmiennej
objMail
:
Set objMail = Server.CreateObject("CDONTS.NewMail")
a następnie określamy odbiorcę wiadomości:
objMail.To = "tim@na.com"
Następnie określamy nadawcę wiadomości poprzez właściwość
From
:
objMail.From = "bob@na.com"
Wiadomości nadawany jest tytuł:
objMail.Subject = "Zwariowaliśmy!"
Następnie budujemy treść naszej wiadomości w postaci czystego HTML-a. Używamy tutaj rozmaitych
znaczników HTML. Zwróć uwagę na użyte w tekście cudzysłowy:
TheMessage = "<HTML>" _
& "<HEAD>" _
& "<TITLE>Mamy wyprzedaż</TITLE>" _
& "</HEAD>" _
& "<BODY>" _
ASP – Kompendium programisty
277
& "<H1><CENTER>Wszystko tańsze o<STRIKE>30%</STRIKE> 50% !</CENTER></H1>" _
& "<HR>" _
& "<P>Stój więc! <A HREF=""http://www.na.com"">kliknij tutaj!</A></P>" _
& "</BODY>" _
& "</HTML>"
Dalej ustalamy treść wiadomości HTML:
objMail.Body = TheMessage
Ustawiamy ważność wiadomości:
objMail.Importance = 2
Zaznaczamy, że treścią jest HTML:
objMail.BodyFormat = 0
Użyty format kodowania to MIME:
objMail.MailFormat = 0
Metoda
Send
wysyła wiadomość e-mail:
objMail.Send
W końcu uwalniamy zasoby wiadomości:
Set objMail = Nothing
Odbiorca powinien otrzymać wiadomość pokazaną na rysunku 9.6.
Rozdział 9 – Obiekt CDO dla Windows NT Server
278
Rysunek 9.6. Wiadomość HTML
Pamiętaj jednak, że nie wszystkie programy poczty elektronicznej potrafią przeglądać wiadomości HTML.
Niektóre z nich mogą wyświetlić jedynie tekst wiadomości podobny do tego pokazanego na rysunku 9.7.
Program próbuje tutaj pokazać tekst wiadomości, zauważ jednak jak zmieniło się jej znaczenie. W dokumencie
HTML skreśliliśmy 30% na rzecz 50%. Tutaj nie widać tej różnicy.
Rysunek 9.7. Wiadomość HTML przeglądana przez klienta nie obsługującego HTML-a
Właściwości ContentBase i ContentLocation
Właściwości
ContentBase
i
ContentLocation
pozwalają ci określić w HTML-u położenie względnych odwołań.
Właściwość
ContentBase
normalnie zapamiętuje wyższy poziom lokalizacji adresów URL, a właściwość
ContentLocation
zapamiętuje ścieżkę katalogu.
Właściwość
ContentBase
ma następującą składnię:
ObjMail.ContentBase = Path
ObjMail
musi być ważną kopią klasy
NewMail
. Wartość
Path
jest zazwyczaj ścieżką domeny. Zapis może więc
być następujący:
ObjMail.ContentBase = "http://www.whatever.com/"
Jeśli wpisałbyś tylko taką wartość, to ścieżki w twojej wiadomości HTML wykorzystają ją jako odniesienie
względne podczas lokalizacji obrazków i łącz.
Możesz również użyć właściwości
ContentLocation
w celu określenia katalogu poniżej nazwy domeny, gdzie
ulokowano łącza i pliki. Składnia właściwości
ContentLocation
przedstawia się tak:
ObjMail.ContentLocation = Path
ObjMail
jest kopią klasy
NewMail
. Wartość
Path
określa ścieżkę do plików i łącz. Jeśli na przykład napiszesz
taki kod:
ObjMail.ContentLocation = "emailreports/December/"
to znacznik obrazka w treści wiadomości HTML wykorzysta obydwie właściwości,
ContentBase
i
ContentLocation
, w celu określenia fizycznego położenia obrazka.
ASP – Kompendium programisty
279
Właściwość Value
W zależności od posiadanego przez odbiorcę programu obsługującego pocztę, istnieje wiele rozmaitych
ustawień wiadomości. Możesz dodać te ustawienia przy użyciu właściwości
Value
.
Właściwość
Value
uzupełnia wiadomość e-mail o dodatkowy nagłówek i ma następujący format:
ObjMail.Value(HeaderName) = HeaderValue
ObjMail
musi być zatwierdzonym obiektem
NewMail
.
HeaderName
jest kopią nagłówka, którego chcesz użyć w
wiadomości, a
HeaderValue
jest wartością tego nagłówka. Na przykład wiele klientów poczty uwzględnia adres
e-mail nadawcy, jak również zwrotny adres odpowiedzi
Reply-To
. Jeśli odbiorca kliknie przycisk Odpowiedz
(Reply) w swojej aplikacji poczty, program użyje adresu wskazanego przez tą funkcję zamiast adresu nadawcy
z właściwości
From
.
Zwróćmy na przykład uwagę na następujący kod:
<%
Option Explicit
Dim objMail
Set objMail = Server.CreateObject("CDONTS.NewMail")
objMail.To = "kate@na.com"
objMail.From = "bob@na.com"
objMail.Subject = "Zwariowaliśmy!"
objMail.Body = "Wyślij mi e-mail ze szczegółami!"
objMail.Importance = 2
objMail.Value("Reply-To") = "Sprzedaż<sales@na.com>"
objMail.Send
Set objMail = Nothing
%>
Po pierwsze informujemy kompilator o deklaracji naszych zmiennych:
Option Explicit
Następnie deklarujemy zmienną
NewMail
:
Dim objMail
Tworzymy kopię obiektu
NewMail
:
Set objMail = Server.CreateObject("CDONTS.NewMail")
Ustawiana jest właściwość
To
:
objMail.To = "kate@na.com"
jak również właściwość
From
:
objMail.From = "bob@na.com"
Dalej określany jest temat i treść wiadomości:
objMail.Subject = "Zwariowaliśmy!"
objMail.Body = "Wyślij mi e-mail ze szczegółami!"
Rozdział 9 – Obiekt CDO dla Windows NT Server
280
Zaznaczamy, że ważność wiadomości jest wysoka:
objMail.Importance = 2
Następnie, przed wysłaniem wiadomości, dodajemy nagłówek
Reply-To
:
objMail.Value("Reply-To") = "Sprzedaż<sales@na.com>"
i uwalniamy zasoby wiadomości:
objMail.Send
Set objMail = Nothing
Kiedy goście klikną przycisk Odpowiedz (Reply) znajdujący się w ich kliencie poczty, wiadomość zostanie
wysłana pod adres
Reply-To
, a nie adres nadawcy określony właściwością
From
, co pokazano na rysunku 9.8.
Rysunek 9.8. Wiadomość wykorzystująca nagłówek
Reply-To
Właściwość Version
Pozostała do omówienia ostatnia właściwość obiektu
NewMail
, właściwość
Version
, która zwraca wersję
biblioteki CDONTS. Ta właściwość, przeznaczona tylko do odczytu, przyjmuje następującą formę:
ObjMail.Version
ObjMail
musi być ważnym obiektem
NewMail
. Zwracaną przez funkcję wartością jest wersja biblioteki, tak więc
poniższy kod:
<%
Option Explicit
Dim objMail
Set objMail = Server.CreateObject("CDONTS.NewMail")
Response.Write "<H2>Ten serwer korzysta z wersji: " _
& objMail.Version & " CDONTS</H2>"
%>
ASP – Kompendium programisty
281
wyświetli używaną wersję CDONTS, jak to pokazano na rysunku 9.9.
Rysunek 9.9. Wyświetlenie właściwości
Version
Metody obiektu NewMail
Metody obiektu
NewMail
umożliwiają podjęcie odpowiednich działań związanych z tym obiektem. Metody te są
omówione poniżej, a ich podsumowanie przedstawia tabela 9.3.
Tabela 9.3. Metody obiektu
NewMail
Metoda Przeznaczenie
Send
Wysyła wiadomość e-mail.
AttachFile
Pozwala na załączenie pliku do wysyłanej
wiadomości.
AttachURL
Załącza pliki, które są częścią wiadomości
HTML.
SetLocaleIDs
Określa informację o lokalizacji.
Metoda Send
Jak mogłeś przekonać się z treści tego rozdziału, metoda
Send
wykorzystywana jest do wysyłania wiadomości
e-mail. Ma ona następującą składnię:
ObjMail.Send From, To, Subject, Body, Importance
ObjMail
musi być obiektem
NewMail
. Wszystkie parametry tej metody są fakultatywne. Jak widziałeś, każdemu
z parametrów odpowiada właściwość, dzięki której możesz określić jego wartość.
Wobec tego kod:
<%
Option Explicit
Dim objMail
Rozdział 9 – Obiekt CDO dla Windows NT Server
282
Set objMail = Server.CreateObject("CDONTS.NewMail")
ObjMail.Send "bob@na.com", "tom@na.com", "Wiadomość testowa", _
"Tekst wiadomości!", 2
Set objMail = Nothing
%>
jest funkcjonalnie tożsamy z tym kodem:
<%
Option Explicit
Dim objMail
Set objMail = Server.CreateObject("CDONTS.NewMail")
objMail.To = "bob@na.com"
objMail.From = "tom@na.com"
objMail.Subject = "Wiadomość testowa"
objMail.Body = "Tekst wiadomości!"
objMail.Importance = 2
objMail.Send
Set objMail = Nothing
%>
Możesz określić każdy z parametrów w metodzie lub we właściwościach. Jeśli chcesz określić wartość
właściwości
Importance
w metodzie, a wszystkie inne parametry osobno jako właściwości, wykorzystaj
przecinki w celu zaznaczenia pustych pozycji, tak jak tutaj:
<%
Option Explicit
Dim objMail
Set objMail = Server.CreateObject("CDONTS.NewMail")
objMail.To = "bob@na.com"
objMail.From = "tom@na.com"
objMail.Subject = "Wiadomość testowa"
objMail.Body = "Tekst wiadomości!"
objMail.Send , , , , 2
Set objMail = Nothing
%>
Z wyjątkiem parametru
To
, wszystkie parametry tej metody unieważniają wartości określone we
właściwościach. Jeśli użyta została zarówno właściwość
To
, jak i parametr metody, wiadomość wysłana
zostanie pod adresy znajdujące się w obydwu miejscach.
Metoda AttachFile
Metoda
AttachFile
łączy w sobie mechanizmy, które pozwolą ci dołączyć pliki do wiadomości e-mail. Metoda
ta ma następującą składnię:
ObjMail.AttachFile FileLocation, FileName, EncodingType
ObjMail
musi być zatwierdzonym obiektem
NewMail
biblioteki CDONTS. Parametr
FileLocation
jest
wymagany i określa fizyczne położenie pliku, natomiast parametr
FileName
jest dodatkowy. Jeśli został podany,
stanowi wyświetlaną w programie poczty nazwę załącznika. Jeśli nie wpiszesz tego parametru, wyświetlana
będzie nazwa pliku. Parametr
EncodingType
również nie jest obowiązkowy, a używa się go do zaznaczenia typu
ASP – Kompendium programisty
283
kodowania. Domyślnie ustawioną wartością 0, co oznacza kodowanie UUEncode. Jeśli ustawisz tutaj wartość
1, wykorzystane zostanie kodowanie Base 64.
Przykładowy kod przedstawiony poniżej załącza do wiadomości plik, któremu nadano nazwę
Company Logo
.
<%
Option Explicit
Dim objMail
Set objMail = Server.CreateObject("CDONTS.NewMail")
objMail.To = "sue@na.com"
objMail.From = "bob@na.com"
objMail.Subject = "Twój plik"
objMail.Body = "Dołączono żądany plik."
objMail.AttachFile "e:\inetpub\logo.gif", "Company Logo"
objMail.Send
Set objMail = Nothing
%>
Na wstępie używamy instrukcji
Option Explicit
, wymaganej podczas deklaracji zmiennych:
Option Explicit
Następnie deklarowany jest obiekt
NewMail
i tworzona jest jego kopia:
Dim objMail
Set objMail = Server.CreateObject("CDONTS.NewMail")
Ustawiane są właściwości
To
i
From
:
objMail.To = "sue@na.com"
objMail.From = "bob@na.com"
Następnie ustawiane są właściwości
Subject
i
Body
:
objMail.Subject = "Twój plik"
objMail.Body = "Dołączono żądany plik."
Używamy metody
AttachFile
, aby dołączyć plik do wiadomości. Pierwszy parametr to ścieżka fizyczna do
załączanego pliku. Drugi jest nazwą, którą przydzielamy plikowi:
objMail.AttachFile "e:\inetpub\logo.gif", "Company Logo"
Wiadomość jest wysyłana i zasoby wykorzystywane przez obiekt są zwalniane:
objMail.Send
Set objMail = Nothing
Wiadomość, którą otrzymuje odbiorca pokazana jest na rysunku 9.10. Zwróć uwagę na nazwę załączonego
pliku.
Rozdział 9 – Obiekt CDO dla Windows NT Server
284
Rysunek 9.10. E-mail z
załącznikiem
Metoda AttachURL
Jeśli wysyłasz wiadomość HTML, możesz chcieć włączyć w jej treść grafiki lub inne pliki. Jednym ze
sposobów na dokonanie tego jest określenie ścieżki do pliku w Internecie przy użyciu odpowiedniego
znacznika, na przykład
Image
. Innym sposobem jest włączenie pliku wprost do samej wiadomości. Robi się to
poprzez metodę
AttachURL
, która pozwala na dodanie pliku do wiadomości tak, że staje się on częścią treści
HTML. Metoda ta ma następującą składnię:
ObjMail.AttachURL PathToFile, FileName, ContentBase, EncodingType
ObjMail
musi być ważnym obiektem
NewMail
biblioteki CDONTS. Parametr
PathToFile
jest wymagany i
określa fizyczne położenie pliku. Parametr
FileName
jest użytą w HTML nazwą pliku i on również jest w
metodzie wymagany. Wpisanie
ContentBase
nie jest wymagane, a stanowi ono bazę adresu URL dla
załącznika. Podobnie nie musisz wpisywać wartości dla
EncodingType
. Jego wartość domyślna wynosi 0, co
oznacza kodowanie UUEncode. Możesz jednak wykorzystać kodowanie Base 64, ustawiając dla tego
parametru wartość 1.
Powiedzmy, że stworzyłeś wiadomość, której treścią jest poniższy HTML:
TheMessage = "<HTML>" _
& "<HEAD>" _
& "<TITLE>Mamy wyprzedaż</TITLE>" _
& "</HEAD>" _
& "<BODY>" _
& <img src=logo.gif>
& "<H1><CENTER>Wszystko tańsze o<STRIKE>30%</STRIKE> 50% !</CENTER></H1>" _
& "<HR>" _
& "<P>Stój więc! <A HREF=""http://www.na.com"">kliknij tutaj!</A></P>" _
& "</BODY>" _
& "</HTML>"
Zauważ, że HTML zawiera znacznik
Image
. Możesz wykorzystać metodę
AttachURL
, aby załączyć tą grafikę do
wiadomości e-mail:
ObjMail.AttachURL "e:\inetpub\logo.gif", "logo.gif"
ASP – Kompendium programisty
285
Od tej pory grafika jest częścią wiadomości HTML.
Metoda SetLocaleID
Metoda
SetLocaleID
jest używana do określenia odpowiednich formatów liczb, waluty, daty i innych,
obowiązujących dla wiadomości. Metoda ma następującą składnię:
ObjMail.SetLocaleID LocaleID
ObjMail
musi być obiektem typu
NewMail
.
LocaleID
jest liczbą typu long i reprezentuje format wyświetlania
wiadomości w zależności od lokalizacji.
Obiekt NewMail w działaniu
Jeśli przeczytałeś ten rozdział, to wpadłeś już zapewne sam na wiele zastosowań obiektu
NewMail
. Umiejętność
uzupełnienia twojej witryny WWW o wiadomości e-mail może podnieść jej jakość na wiele różnych sposobów.
Wiele witryn WWW używa obiektu
NewMail
w celu przenoszenia prośby gości o udzielenie informacji.
Narzędzie, którego ja używam, prezentuje odwiedzającym formularz, w który mogą wpisać swój adres e-mail,
imię i nazwisko, numer telefonu i inne dane oraz swoją wiadomość. Następnie narzędzie zachęca gości do
wybrania z listy tematu pasującego do ich wiadomości. Lista jest elementem formularza wyboru. Gościom
wyświetlana jest tekstowa lista tematów, ale adres e-mail dla danego tematu przesyłany jest razem z
formularzem. Tak więc inna osoba może odpowiadać za każdy z tematów. E-mail może być wysłany również
do wielu osób, w tym wypadku ich adresy należy oddzielić od siebie średnikiem.
Jeśli więc element formularza nosiłby nazwę
Topic
, mógłbyś ustawić według niego właściwość
To
:
ObjMail.To = Request.Form("Topic")
Często również wykorzystuje się obiekt
NewMail
w celu wysłania powiadomienia o wystąpieniu określonego
zdarzenia. Na przykład w witrynach handlowych konieczne jest zapamiętanie w bazie danych informacji o
zamówieniu, ale może również okazać się, że należy wysłać wiadomość do osoby odpowiedzialnej za sklep,
aby poinformować ją o konieczności przetworzenia zamówienia. Pewnie nie będziesz chciał wysyłać pocztą
całego zamówienia, ponieważ może ono zawierać informacje zastrzeżone, jak choćby numery kart
kredytowych.
W rozdziale 7. przyjrzeliśmy się tworzeniu dokumentu Word przy użyciu kopii tego obiektu, wykorzystując
przy tym metodę
CreateObject
obiektu
Server
. Dokument był tam generowany na bazie formularza w postaci
listu wyświetlanego następnie odwiedzającemu. Mógłbyś jednak zmodyfikować ten kod w taki sposób, aby
otrzymywał on dokument pocztą elektroniczną. Pamiętaj, że twoi goście mogą dysponować rozmaitymi
systemami, na których zainstalowano różnego rodzaju narzędzia, tak więc wykorzystanie szerokiej gamy metod
dla jednego zadania może być w tym względzie bardzo użyteczne.
Zastanów się nad wykorzystywaniem wiadomości HTML zamiast zwykłego tekstu. Jest to o wiele lepsze,
zwłaszcza jeśli chodzi o materiały reklamowe, a nie wymaga przecież dużej pracy. Użyj jedynie prostego
narzędzia HTML podczas projektowania strony. Następnie przeglądnij źródło strony i skopiuj oraz wklej je do
twojej strony ASP. Zamień je na ciąg i wpisz go do właściwości
Body
. Ta prosta zmiana może spowodować, że
twój e-mail będzie się wyróżniał spośród wielu innych, które otrzymał odbiorca.
Obiekt
NewMail
można wykorzystywać również do rozrywki, tworząc strony z kartkami pocztowymi lub
kartami urodzinowymi. Te strony pozwalają gościowi wysyłać wiadomości do przyjaciół lub kolegów. E-mail
informuje odbiorcę o tym, że otrzymali kartę urodzinową, kartkę pocztową lub jakąś inną, którą mogą odebrać
na twojej witrynie. Następnie klikają łącze znajdujące się w treści wiadomości e-mail, które przenosi ich na
twoją witrynę. Tam widzą wiadomość pozostawioną przez pierwszego jej gościa. Technika ta nie tylko pozwala
gościom powrócić na witrynę, ale również wprowadza na nią nowych gości — a wszystko, czego przy tym
potrzebuje, to formularz dla pierwszego gościa, gdzie mógłby wybrać typ kartki i jej tekst. Następnie użyć
Rozdział 9 – Obiekt CDO dla Windows NT Server
286
można obiektu
NewMail
w celu wysłania wiadomości do odbiorcy kartki. Kiedy goście powrócą na witrynę,
ujrzą stronę ASP zawierającą informacje przekazane przez pierwszego przeglądającego.
Łącząc ze sobą omówione do tej pory obiekty dysponujesz prawie nieograniczonymi możliwościami tworzenia
aplikacji ASP.
Rozdział 10.
Składniki ASP
Obiekty zwiększające możliwości stron ASP
Serwer IIS posiada rozmaite składniki, które wspierają proces tworzenia stron ASP. Jeden z nich, obiekt CDO,
poznaliśmy w poprzednim rozdziale. Ale IIS wyposażono również w zbiór mniejszych składników, z których
możesz skorzystać w kodzie podczas realizacji różnego rodzaju zadań. W tym rozdziale skoncentrujemy się na
tych pomniejszych składnikach. Tabela 10.1. prezentuje te składniki oraz to, gdzie można je wykorzystać.
Tabela 10.1. Składniki ASP
Składnik Przeznaczenie
Browser
Capabilities
Dostarcza informacji o używanej przez gościa przeglądarce
oraz o jej możliwościach.
Ad Rotator
Dostarcza metod pozwalających na umieszczanie banerów w
witrynie.
Page Counter
Pozwala na wyświetlanie i śledzenie liczby gości strony.
Counters
Dostarcza mechanizmów pozwalających na zachowywanie
liczby, która ma być inkrementowana poprzez aplikację
ASP.
Content Linking
Pozwala na stworzenie serii stron zorganizowanych na
kształt książki i zaspokaja wszystkie potrzeby związane z
poruszaniem się po tych stronach.
Content Rotator
Pozwala na włączenie do strony lub do jej elementu
zawartości losowej.
MyInfo
Dostarcza obiektu wraz z licznymi właściwościami, których
możesz użyć w celu zapamiętania informacji o tobie i twojej
firmie.
Składnik Browser Capabilities
Składnik Browser Capabilities dostarcza informacji o przeglądarce gościa oraz o systemie, którym dysponuje.
Poniżej zaprezentowano proste wywołanie tego składnika:
set BC = server.createobject("MSWC.BrowserType")
Browser = BC.Browser & " " & BC.Version
FramesSupport = BC.Frames
Platform = BC. Platform
Kopia składnika
Browser Capabilities
jest tworzona przy użyciu metody
CreateObject
:
set BC = server.createobject("MSWC.BrowserType")
Rozdział 10 – Składniki ASP
288
Wywołanie tworzy kopię klasy
BrowserType
serwera
MSWC
i wpisuje ją do zmiennej obiektowej
BC
. Po
wywołaniu w zmiennej
Browser
ustawiana jest nazwa i wersja przeglądarki używanej przez gościa:
Browser = BC.Browser & " " & BC.Version
W zmiennej
FramesSupport
ustawiana jest wartość informująca o tym, czy przeglądarka gościa obsługuje
ramki:
FramesSupport = BC.Frames
Dodatkowo w zmiennej
Platform
zapisywana jest nazwa systemu operacyjnego gościa. Jest to realizowane przy
użyciu właściwości
Platform
obiektu
Browser Capabilities
:
Platform = BC.Platform
Składnik
Browser Capabilities
działa w bardzo prosty sposób. Wyszukuje zmienną nagłówka HTPP o nazwie
User Agent
, która zawiera kodowany w pewnym stopniu wiersz z informacjami o gościu. Wyszukana wartość
jest następnie wykorzystywana do połączenia w pliku .ini o nazwie browscap.ini, który jest plikiem tekstowym
zawierającym informacje konfiguracyjne dla wielu rozmaitych systemów operacyjnych i przeglądarek. Plik
browscap.ini musi znajdować się w tym samym katalogu, co plik biblioteki składnika browscap.dll.
Jeśli używasz Internet Explorera w systemie Windows NT, zawartość twojej zmiennej
User Agent
może
wyglądać tak:
Mozilla/4.0 (compatible; MSIE 4.01; Windows NT)
Składnik przegląda plik browscap.ini w poszukiwaniu takiego zapisu:
[Mozilla/4.0 (compatible; MSIE 4.01; Windows NT)*]
Poniżej znajduje się następująca informacja o konfiguracji systemowej:
parent=IE 4.0
minorver=01
platform=WinNT
Zwróć uwagę na pierwszy wiersz określający przodka (parent). Informuje on o obecności w pliku browscap.ini
pozycji o nazwie IE 4.0. Biblioteka użyje informacji zapisanych tutaj, a w przypadku braku którejś z nich,
użyje wartości w przodku tego typu.
W katalogu nadrzędnym zapisana zostanie konfiguracja dla tego jednego systemu:
browser=IE
Version=4.0
majorver=#4
minorver=#0
frames=TRUE
tables=TRUE
cookies=TRUE
backgroundsounds=TRUE
vbscript=TRUE
javascript=TRUE
javaapplets=TRUE
ActiveXControls=TRUE
ASP – Kompendium programisty
289
Win16=False
beta=False
AK=False
SK=False
Response.Write "Dźwięki tła: " & BC.backgroundsounds & "<BR>"
AOL=False
crawler=False
CDF=True
Jeśli korzystałeś z przeglądarki Netscape Navigator w systemie Windows 95, nagłówek zwróci tą wartość:
Mozilla/4.0 * (Win95; U)
Składnik
Browser Capabilities
będzie szukał tej wartości w pliku browscap.ini i znajdzie taki zapis:
parent=Netscape 4.0
platform=Win95
Zauważ, że w pozycji przodka znajduje się teraz nazwa Netscape 4.0. Składnik poszuka tej wartości dla innych
właściwości i znajdzie następujące pozycje:
browser=Netscape
version=4.0
majorver=#4
minorver=#0
frames=TRUE
tables=TRUE
cookies=TRUE
backgroundsounds=FALSE
vbscript=FALSE
javascript=TRUE
javaapplets=TRUE
ActiveXControls=FALSE
beta=False
Możesz użyć składnika
Browser Capabilities
przy pisaniu kodu, który określa możliwości systemu gościa.
Spójrz na ten przykładowy kod:
<%
Option Explicit
Dim BC
set BC = server.createobject("MSWC.BrowserType")
Response.Write "Przeglądarka: " & BC.Browser & " " & BC.Version & "<BR>"
Response.Write "Platforma: " & BC.Platform & "<BR>"
Response.Write "DHTML: " & BC.dhtml & "<BR>"
Response.Write "Ramki: " & BC.frames & "<P>"
Response.Write "Tabele: " & BC.tables & "<BR>"
Response.Write "Cookies: " & BC.cookies & "<BR>"
Response.Write "VBScript: " & BC.vbscript & "<P>"
Response.Write "JavaScript: " & BC.javascript & "<BR>"
Response.Write "Dodatki Java: " & BC.javaapplets & "<BR>"
Rozdział 10 – Składniki ASP
290
Response.Write "Obiekty sterujące ActiveX: " & BC.activexcontrols & "<BR>"
Response.Write "AOL: " & BC.AOL & "<P>"
Response.Write "Beta: " & BC.Beta & "<BR>"
Response.Write "CDF: " & BC.cdf
%>
Na wstępie kod stwierdza, że deklarowane będą zmienne:
Option Explicit
Następnie tworzymy zmienną o nazwie
BC
:
Dim BC
W zmiennej
BC
tworzona jest kopia składnika
Browser Capabilities
:
set BC = server.createobject("MSWC.BrowserType")
Do przeglądarki wpisywana jest nazwa i wersja przeglądarki gościa:
Response.Write "Przeglądarka: " & BC.Browser & " " & BC.Version & "<BR>"
Dalej do przeglądarki wpisywana jest platforma, system operacyjny gościa:
Response.Write "Platforma: " & BC.Platform & "<BR>"
Teraz z kolei do przeglądarki wpisywana jest informacja o tym, czy przeglądarka obsługuje dynamiczny
HTML. Możliwe dla tej właściwości wartości to prawda (
True
), fałsz (
False
) oraz nieznany (
Unknown
):
Response.Write "DHTML: " & BC.dhtml & "<BR>"
Następny zapis odpowiada na pytanie, czy przeglądarka wyświetla ramki. Możliwe wartości dla tej właściwości
to
True
,
False
i
Unknown
:
Response.Write "Ramki: " & BC.frames & "<P>"
Tutaj składnik
Browser Capabilities
informuje o tym, czy przeglądarka wyświetla tabele. Możliwe wartości to
True
,
False
i
Unknown
:
Response.Write "Tabele: " & BC.tables & "<BR>"
Czy przeglądarka gościa obsługuje znaczniki cookie? Możliwe wartości dla tej właściwości to
True
,
False
i
Unknown
. Pamiętaj, że przeglądarka może obsługiwać cookies, ale gość może dysponować narzędziem
blokującym te znaczniki:
Response.Write "Cookies: " & BC.cookies & "<BR>"
Czy przeglądarka potrafi odtwarzać dźwięki tła? Możliwe wartości dla tej właściwości to
True
,
False
i
Unknown
:
Response.Write "Dźwięki tła: " & BC.backgroundsounds & "<BR>"
ASP – Kompendium programisty
291
Czy przeglądarka potrafi przetwarzać VBScript po stronie klienta? Zwróć uwagę na to, że mówimy tutaj o
stronie klienta, co nie ma nic wspólnego ze stronami ASP, które są przetwarzane przez twój serwer. Możliwe
wartości dla tej właściwości to
True
,
False
i
Unknown
:
Rysunek 10.1. przedstawia wyjście tej strony w systemie Windows 98 używającym przeglądarki Netscape
Navigator 4.0.
Response.Write "VBScript: " & BC.vbscript & "<P>"
To samo pytanie tyczy się JavaScriptu. Ponownie odnosimy się do możliwości po stronie klienta. Możliwe
wartości dla tej właściwości to
True
,
False
i
Unknown
:
Response.Write "JavaScript: " & BC.javascript & "<BR>"
Czy przeglądarka obsługuje dodatki Javy? Odpowiedź na to pytanie zawarta jest we właściwości
JavaApplets
składnika
Browser Capabilities
:
Response.Write "Dodatki Javy: " & BC.javaapplets & "<BR>"
Czy przeglądarka może współpracować ze składnikami ActiveX po stronie klienta? Możliwe wartości dla tej
właściwości to
True
,
False
i
Unknown
:
Response.Write "Obiekty sterujące ActiveX: " & BC.activexcontrols & "<BR>"
Czy gość używa AOL? Możliwe wartości dla tej właściwości to
True
,
False
i
Unknown
:
Response.Write "AOL: " & BC.AOL & "<P>"
Czy przeglądarka jest wersji beta? Możliwe wartości dla tej właściwości to
True
,
False
i
Unknown
:
Response.Write "Beta: " & BC.Beta & "<BR>"
I wreszcie, czy przeglądarka obsługuje format CDF? Możliwe wartości dla tej właściwości to
True
,
False
i
Unknown
:
Response.Write "CDF: " & BC.cdf
Rozdział 10 – Składniki ASP
292
Rysunek 10.1. Wyjście kodu wykorzystującego składnik
Browser Capabilities
Rysunek 10.2. Wyjście kodu wykorzystującego składnik
Browser Capabilities
Rysunek 10.2 prezentuje wyjście kodu w systemie Windows NT z uruchomionym Internet Explorerem 5.0.
Najważniejszą możliwością wykorzystania tego kodu jest kierowanie gości do właściwej wersji twojej witryny
WWW. Może ona zawierać witrynę optymalizowaną dla Internet Explorera, drugą dla Netscape Navigatora,
trzecią dla WebTV i kolejną dla pozostałych typów przeglądarek. Możesz to zrobić wykorzystując kod taki jak
ten:
<%
Option Explicit
Dim BC
ASP – Kompendium programisty
293
set BC = server.createobject("MSWC.BrowserType")
If BC.Browser = "IE" then
Response.redirect "./IE/index.asp"
ElseIf BC.Browser = "Netscape" then
Response.redirect "./Netscape/index.asp"
ElseIf BC.Browser = "WebTV" then
Response.redirect "./WebTV/index.asp"
Else
Response.redirect "./other/index.asp"
End If
%>
Na wstępie wymagana jest deklaracja zmiennych:
Option Explicit
Tworzona jest zmienna o nazwie
BC
:
Dim BC
Zmienna wykorzystana jest do stworzenia kopii obiektu
Browser Capabilities
:
set BC = server.createobject("MSWC.BrowserType")
Następnie zapytujemy właściwość
Browser
obiektu
Browser Capabilities
, czy używana przeglądarka to
Internet Explorer:
If BC.Browser = "IE" then
Jeśli tak, to gość jest readresowany do podkatalogu zawierającego strony dla tej przeglądarki:
Response.redirect "./IE/index.asp"
W innym wypadku kod sprawdza, czy używana przeglądarka to Netscape Navigator:
ElseIf BC.Browser = "Netscape" then
Jeśli to prawda, gość odsyłany jest do katalogu Netscape:
Response.redirect "./Netscape/index.asp"
Coraz bardziej popularną przeglądarką staje się WebTV. Jeśli szerokie grono twych gości korzysta z tego
narzędzia, stanowczo musisz dysponować witryną w wersji odpowiadającej ich potrzebom:
ElseIf BC.Browser = "WebTV" then
Jeśli jest to ich typ przeglądarki, są readresowani do podkatalogu
WebTV
:
Response.redirect "./WebTV/index.asp"
w przeciwnym razie gości odsyła się do domyślnego widoku twojej witryny:
Rozdział 10 – Składniki ASP
294
Response.redirect "./other/index.asp"
Kolejnym powodem do readresowania twoich gości do określonej wersji witryny są różnice w technologiach.
Jeśli martwisz się o to, czy starsze przeglądarki będą mogły korzystać z twojej witryny, to metodą na
zróżnicowanie wyglądu twojej witryny jest sprawdzenie obsługi tabel i ramek. Zwróć uwagę na ten kod:
<%
Option Explicit
Dim BC
set BC = server.createobject("MSWC.BrowserType")
If BC.Tables = "True" and BC.Frames = "True" then
Response.Redirect "./full/index.asp"
ElseIf BC.Tables = "True" then
Response.Redirect "./noframes/index.asp"
Else
Response.Redirect "./none/index.asp"
End If
%>
Jak zwykle wymagana jest deklaracja zmiennych:
Option Explicit
Tworzona jest zmienna
BC
:
Dim BC
i ustawiany jest w niej obiekt
Browser Capabilities
:
set BC = server.createobject("MSWC.BrowserType")
Zaczynamy od pytania podstawowego. Czy przeglądarka obsługuje tabele i ramki?
If BC.Tables = "True" and BC.Frames = "True" then
Jeśli przeglądarka obsługuje zarówno jedno, jak i drugie, gość odsyłany jest tutaj:
Response.Redirect "./full/index.asp"
Następnie cofamy się o jeden poziom w technologii. Ramki pojawiły się później niż tabele, usuwamy więc z
równania pytanie o ramki i sprawdzamy, czy przeglądarka obsługuje przynajmniej tabele:
ElseIf BC.Tables = "True" then
Jeśli tak jest, wykorzystujemy metodę
Redirect
obiektu
Response
w celu odesłania gości do odpowiedniego
miejsca:
Response.Redirect "./noframes/index.asp"
W innym wypadku przeglądarka gościa nie obsługuje żadnej z tych technologii i wtedy odsyłamy go do
podstawowej wersji naszej witryny:
ASP – Kompendium programisty
295
Else
Response.Redirect "./none/index.asp"
Pamiętaj, że składnik szuka pozycji
User Agent
w pliku .ini i dopasowuje ją do wartości zmiennej
User Agent
zwróconej przez nagłówek HTPP. Plik .ini jest jedynie plikiem tekstowym zawierającym zbiór różnego rodzaju
wydruków, co oznacza, że jeśli nie będziesz się nim zajmował — plik szybko stanie się przestarzały.
Faktycznie, jeśli instalujesz nowy IIS, prawdopodobnie będzie on dysponował przestarzałą wersją pliku .ini.
Jeśli więc korzystasz z tego narzędzia, musisz dokładać starań, aby plik był stale aktualny.
Jednym z miejsc, w których możesz otrzymać uaktualnienie jest cyScape, Inc.
(http://www.cyscape.com/browscap). Firma często udostępnia nową wersję pliku browscap.ini wraz z
dodatkami i poprawkami. Możesz zgłosić chęć otrzymywania uaktualnienia przez e-mail, wtedy firma
powiadamia cię o pojawieniu się nowych wersji pliku. cyScape dysponuje również własną wersją składnika
Browser Capabilities
, która zawiera dodatkowe właściwości, inne niż te omówione w bieżącym podrozdziale.
Modyfikacja pliku browser.ini
Możesz również sam uaktualnić plik. Pamiętaj, że jest to tylko plik tekstowy, który musi mieć określony
format. Jeśli chcesz go zmodyfikować, najpierw stwórz sobie jego kopię zapasową. Wtedy możesz wykorzystać
poniższy opis w celu modyfikacji poszczególnych sekcji pliku.
Komentarzem w pliku jest każdy wiersz rozpoczynający się średnikiem:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Definicja mojej przeglądarki ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Każda część pliku zawiera albo nagłówek
User Agent
, albo definicję przodka. Mógłbyś na przykład
zdefiniować przeglądarkę, której nie było na liście, a dla której zwracany byłby następujący ciąg w
User Agent
:
[My Browser/1.2.2beta (Windows 95)]
Zwróć uwagę na to, że definicja sekcji jest umieszczona w nawiasie kwadratowym. W następnej kolejności
pojawiają się właściwości sekcji. Kontynuuj ich wypisywanie dopóki nie pojawi się kolejny nagłówek sekcji.
Mógłbyś zdefiniować właściwości twojej sekcji w następujący sposób:
parent=MyBrowser 1.0
platform=Win95
beta=True
Zwróć uwagę na szczególną pozycję o nazwie
parent
(przodek), która informuje o tym, że gdzieś w pliku .ini
znajduje się pozycja
MyBrowser 1.0
. Przejdź do tej pozycji i użyj wszystkich właściwości o ile nie określiłem
jakiejś w tej sekcji. W następnej kolejności określona została platforma oraz typ przeglądarki, beta.
Gdzieś w pliku .ini musimy dodać sekcję określającą przodka. Pasuje ona dokładnie do nazwy użytej tutaj, a
wygląda następująco:
[MyBrowser 1.0]
browser=MyBrowser
version=1.0
majorver=#1
minorver=#0
frames=FALSE
tables=TRUE
cookies=TRUE
backgroundsounds=FALSE
Rozdział 10 – Składniki ASP
296
vbscript=TRUE
javascript=FALSE
javaapplets= FALSE
Platform=Windows95
beta=False
Zauważ, że niektóre pozycje są powtórzone tutaj, w przodku. Te, których użyto w rzeczywistej definicji
unieważniają pozycje przodka, który po prostu zapamiętuje domyślne wartości nie zdefiniowane ponownie
przez pozycję potomka.
Składnik Ad Rotator
Składnik Ad Rotator udostępnia narzędzi do zarządzania paskami reklamowymi (banerami) pojawiającymi się
na stronie WWW. Składnik będzie losowo wyświetlał pasek na stronie ASP za każdym razem, kiedy ktoś
uzyskuje do niej dostęp. Składnik używa oddzielnego pliku harmonogramu, który stworzony jest w celu
określenia częstości wyświetlania jednych banerów względem drugich. Wywołanie składnika
Ad Rotator
wygląda następująco:
set objAdRot = server.createobject("MSWC.AdRotator")
Response.Write objAdRot.GetAdvertisement("./html/AdFiles/AdFile.txt)
Pierwszy wiersz tworzy kopię klasy
AdRotator
będącej klasą
MSWC
, umieszczając ją w zmiennej obiektowej o
nazwie
objAdRot
:
set objAdRot = server.createobject("MSWC.AdRotator")
Następnie wywoływana jest metoda
GetAdvertisement
w celu wyszukania informacji o pasku reklamowym,
który będzie wyświetlany. Zwracana wartość wpisana zostaje do przeglądarki przy użyciu metody
Write
obiektu
Response
:
Response.Write objAdRot.GetAdvertisement("./html/AdFiles/AdFile.txt)
A oto ta wpisywana do przeglądarki wartość:
<A HREF="http://www.netstats2000.com/nmaha/html/AdFiles/AdRedirect.
asp?
url= http://www.netstats2000.com/nmaha/html/AdFiles/HA.html
&image= http://www.netstats2000.com/nmaha/html/AdFiles/ha.gif" >
<IMG SRC=" http://www.netstats2000.com/nmaha/html/AdFiles/ha.gif"
ALT="Get your organization online" WIDTH=468 HEIGHT=60 BORDER=0>
Metodzie
GetAdvertisement
przekazywany jest jeden parametr, ścieżka do pliku Schedule, zawierającego listę
wyświetlanych banerów oraz informacje o częstości wyświetlania każdego z nich. Plik Schedule zawiera
również działania, jakie należy podjąć w chwili, gdy gość kliknie baner, a także rozmiar prezentowanego
obrazka. Metoda
GetAdvertisement
sprawdza wszystkie wartości pliku Schedule i wytwarza pokazane powyżej
wyjście.
Zawartość pliku Schedule w tym autentycznym przykładzie zaprezentowano tutaj:
Redirect http://www.netstats2000.com/nmaha/html/AdFiles/AdRedirect.asp
width 468
height 60
border 0
ASP – Kompendium programisty
297
*
http://www.netstats2000.com/nmaha/html/AdFiles/ha.gif
http://www.netstats2000.com/nmaha/html/AdFiles/HA.html
Get your organization online
10
http://www.netstats2000.com/nmaha/html/AdFiles/sgianim.gif
http://www.silkgraph.com
Silkscreen Graphics Inc.
10
http://www.netstats2000.com/nmaha/html/AdFiles/forrent.gif
border 0
Dalej w pliku znajduje się lista banerów z ich harmonogramem. Pierwszy wiersz każdej pozycji banera jest
ścieżką dostępu do niego:
mailto:mcecchi@ibm.net
Space For Rent
10
Pierwsza sekcja pliku Schedule zawiera informacje konfiguracyjne. Pierwszy wiersz określa ścieżkę do strony,
do której goście są odsyłani po kliknięciu paska reklamowego:
Redirect http://www.netstats2000.com/nmaha/html/AdFiles/AdRedirect.asp
Za pomocą zbioru
QueryString
stronie przekazywana jest nazwa klikniętego obrazka oraz adres, do którego
należy po tej akcji przejść.
Drugi i trzeci wiersz pierwszej sekcji określa szerokość i wysokość paska reklamowego:
width 468
height 60
Czwarty wiersz określa jego obwódkę:
Spójrz na poprzedni HTML wytworzony przez metodę
GetAdvertisement
, a zobaczysz w nim informacje
konfiguracyjne. Pojedyncza gwiazdka zakańcza sekcję konfiguracyjną:
*
http://www.netstats2000.com/nmaha/html/AdFiles/ha.gif
Potem pojawia się lokalizacja WWW, do której ostatecznie goście będą readresowani po kliknięciu banera:
http://www.netstats2000.com/nmaha/html/AdFiles/HA.html
W trzecim wierszu znajduje się tekst etykietki:
Get your organization online
Czwarty wiersz zawiera proporcjonalną liczbę określającą częstość wyświetlania jednego banera w stosunku do
innych:
10
Rozdział 10 – Składniki ASP
298
Wyjście wytworzone przez tą pozycję pliku obrotu banera pokazane jest na rysunku 10.3. Zwróć uwagę na
baner znajdujący się na szczycie tego rysunku. Jest on tworem pierwszej pozycji pliku obrotu, tak więc tekst
etykiety zgadza się z tym, co pokazano na rysunku, a na pasku statusu widać adres URL, z którym łączy się
baner.
Rysunek 10.3. Pierwszy obrót paska reklamowego
Jeśli spojrzysz wstecz na całość pliku Schedule, zauważysz, że opisana wyżej struktura się powtarza. Następny
punkt wyświetli grafikę:
http://www.netstats2000.com/nmaha/html/AdFiles/sgianim.gif
Relatywna liczba wyświetleń tej grafiki w porównaniu z innymi jest taka:
Jeśli gość kliknie tą grafikę, zostaje odesłany do następującego adresu URL:
http://www.silkgraph.com
Tekst etykietki dla grafiki:
Silkscreen Graphics Inc.
10
Ta pozycja wyświetli widok strony pokazany na rysunku 10.4. Zauważ, że grafika odpowiada treści pliku
obrotu. Poza tym zwróć uwagę, że jest to ta sama strona, na której prezentowany był poprzedni baner. Za
każdym razem, gdy strona jest przeglądana, pojawia się na niej inna grafika, mianowicie ta, która dawno nie
była wyświetlana.
ASP – Kompendium programisty
299
Rysunek 10.4. Drugie ogłoszenie z pliku obrotu
Ponadto każda strona miała zaplanowaną tą samą proporcję wyświetleń, 10, ale tak być nie musi. Możesz dla
jednej strony ustawić wartość 20, a dla pozostałych dwóch 10. Oznaczałoby to, że pierwsza strona ukazywałaby
się dwa razy częściej niż dwie pozostałe.
Pamiętaj, że pierwszy wiersz pliku Schedule określa miejsce, do którego odsyłani są goście, gdy klikną pasek
reklamowy:
Redirect http://www.netstats2000.com/nmaha/html/AdFiles/AdRedirect.asp
width 468
Ta strona ASP normalnie nie zawiera wyjścia. Daje ci ona możliwość zapisywania kliknięć banera (click-
through) w bazie danych w celu dalszej analizy. Poniżej przedstawiono przykład takiego kodu.
<%
set conn = server.createobject ("adodb.connection")
conn.open "EmpDir", "sa", "yourpassword"
conn.execute "insert into Referrals (ReferredTo) values ('" _
& Request.QueryString("url") & "')"
response.redirect(Request.QueryString("url"))
%>
Na początku kod łączy się z bazą danych:
set conn = server.createobject ("adodb.connection")
conn.open "EmpDir", "sa", "yourpassword"
Następnie kod dodaje rekord do tabeli o nazwie
Referrals
, zawierający nazwę banera klikniętego przez gościa:
conn.execute "insert into Referrals (ReferredTo) values ('" _
& Request.QueryString("url") & "')"
Rozdział 10 – Składniki ASP
300
W końcu goście są readresowani do miejsca położenia klikniętego banera w witrynie WWW:
response.redirect(Request.QueryString("url"))
Pomyśl o innych polach, które chciałbyś zawrzeć w tej pozycji. Na przykład prawdopodobnie będziesz chciał
zapisywać datę i godzinę kliknięcia banera przez gościa. Możesz również wykorzystać składnik
Browser
Capabilities
, omówiony we wcześniejszym podrozdziale, w celu zapisywania obszernych informacji na temat
narzędzi gościa, który kliknął pasek reklamowy.
Z drugiej strony może chciałbyś dysponować stroną, na której reklamujący się mogliby sprawdzić ile razy ich
baner był kliknięty. Taką stronę prezentuje rysunek 10.5.
Rysunek 10.5. Przykładowa strona raportu kliknięć
Domyślnie strona ładuje się wyświetlając datę w skali rocznej. Kiedy goście klikną przycisk Wyświetl raport,
zobaczą wynik ich zapytania pokazany na rysunku 10.6.
ASP – Kompendium programisty
301
Rysunek 10.6. Wynik zapytania o ilość kliknięć
Kod strony wyśle zapytanie do bazy danych o oparciu o informacje przesłane w formularzu. Kod strony
również musi wyświetlać informacje w skali rocznej. Główny blok kodowy jest następujący:
<%
Option Explicit
Dim conn
Dim RSHits
Dim TheMessage
Dim StartDate
Dim EndDate
If Not IsEmpty(Request.Form("DisplayReport")) Then
set conn = server.createobject ("adodb.connection")
conn.open "EmpDir", "sa", "yourpassword"
set RSHits = conn.Execute("select Count(ReferralID) as TheCount " _
& "from Referrals " _
& "where UserName = '" & Request.Form("UserName") & "' " _
& "and HitDate >= '" & Request.Form("StartDate") & "' " _
& "and HitDate <= '" & Request.Form("EndDate") & "' ")
TheMessage = " W tym okresie zarejestrowano" _
& RSHits("TheCount") & " kliknięć."
else
TheMessage ="Wprowadź nazwę użytkownika oraz graniczne daty, dla" _
& "dla którego chcesz poznać liczbę kliknięć."
End If
StartDate = "1/1/" & Year(Date)
EndDate = Date
%>
Na wstępie wykorzystujemy dyrektywę
Option Explicit
:
Rozdział 10 – Składniki ASP
302
Option Explicit
Następne deklarujemy zmienną zapamiętującą połączenie z bazą danych:
Dim conn
Dim RSHits
Kolejne dwie zmienne będą przechowywały domyślną datę początkową:
Dim EndDate
conn.open "EmpDir", "sa", "yourpassword"
Dalej deklarujemy zmienną przechowującą informacje z bazy danych:
Zmienna wiadomości będzie wyświetlała w przeglądarce instrukcje lub wynik zapytania:
Dim TheMessage
Dim StartDate
i datę końcową:
Strona ma dwa stany. W stanie początkowym strona właśnie została wyświetlona i goście muszą ujrzeć
instrukcje postępowania. W stanie przesyłania goście wysyłają formularz, a my musimy go przetworzyć. Stan
strony określamy sprawdzając w zbiorze
Form
, czy przycisk wyświetlający raport (
DisplayReport
) został
naciśnięty.
If Not IsEmpty(Request.Form("DisplayReport")) Then
Jeśli element zbioru formularza nie jest pusty, formularz został przesłany. W tym wypadku musimy połączyć
się z bazą danych, aby ustalić liczbę kliknięć. Tworzony jest obiekt
Connection
:
set conn = server.createobject ("adodb.connection")
który łączy się z żądaną bazą danych:
Uruchamiane jest zapytanie, które zwraca liczbę rekordów dla poszczególnego użytkownika pomiędzy
wybranymi przez niego datami:
set RSHits = conn.Execute("select Count(ReferralID) as TheCount " _
& "from Referrals " _
& "where UserName = '" & Request.Form("UserName") & "' " _
& "and HitDate >= '" & Request.Form("StartDate") & "' " _
& "and HitDate <= '" & Request.Form("EndDate") & "' ")
Następnie do zmiennej wpisywany jest wyświetlany gościom tekst, który zawiera wyszukane w bazie danych
informacje o kliknięciach:
TheMessage = " W tym okresie zarejestrowano" _
& RSHits("TheCount") & " kliknięć."
ASP – Kompendium programisty
303
Jeśli formularz nie został przesłany, w zmiennej wiadomości ustawiana jest instrukcja postępowania:
else
TheMessage ="Wprowadź nazwę użytkownika oraz graniczne daty, dla" _
& "dla którego chcesz poznać liczbę kliknięć."
W każdym z przypadków musimy utworzyć zmienne
StartDate
i
EndDate
. Jako datę początkową ustawiamy
pierwszy dzień bieżącego roku:
StartDate = "1/1/" & Year(Date)
a jako datę końcową bieżącą datę systemu:
EndDate = Date
Następnie używamy wbudowanej w HTML metody
Write
obiektu
Response
w celu wysłania zmiennej
wiadomości do przeglądarki:
<P><B><% Response.Write TheMessage %></B>
Wartość daty początkowej wpisywana jest w pole tekstowe StartDate:
<INPUT TYPE=TEXT NAME="StartDate" VALUE="<% Response.Write
StartDate %>"
SIZE=40 MAXLENGHT=50>
Następnie ustalamy domyślną datę końcową w parametrze wartości:
<INPUT TYPE=TEXT NAME="EndDate" VALUE="<% Response.Write EndDate %>"
SIZE=40 MAXLENGHT=50>
Składnik Page Counter
Składnik Page Counter pozwala w prosty sposób śledzić i wyświetlać liczbę trafnych wywołań strony WWW.
Ten składnik nie jest instalowany domyślnie wraz z serwerem IIS. Jest on częścią zestawu IIS Resource Kit,
który możesz znaleźć na witrynie Microsoftu lub, jeśli zamawiasz Microsoft Technet, znajduje się na CD-
ROM-ie. Składnik możesz zainstalować kopiując plik z płyty CD-ROM położony w \IIS Resource
Kit\Component\Page Counter\DLL\i386\PageCnt.dll, a następnie umieszczając go w twoim katalogu
WinNT\System32. Wtedy możesz zarejestrować składnik przy użyciu polecenia Uruchom (Run) z menu Start,
wprowadzając tekst
Regsvr32 PageCnt.dll
.
Powinieneś ujrzeć wiadomość o pomyślnym zarejestrowaniu składnika, którą zaprezentowano na rysunku 10.7.
Po zarejestrowaniu biblioteki możesz zacząć korzystać ze składnika w kodzie. Składnik tworzy się podobnie
jak inne składniki, to znaczy przy użyciu metody
CreateObject
obiektu
Server
.
Rysunek 10.7. Pomyślna rejestracja składnika
Page Counter
Rozdział 10 – Składniki ASP
304
Dokumentacja Microsoftu prezentuje dwa sposoby tworzenia obiektu. Odkryłem, że jeden z nich nie działa, ale
przyjrzyjmy się obydwu sposobom na wypadek, gdyby przyszłe wersje używały innych niefunkcjonalnych
składni. Poniższa deklaracja aktualnie nie działa:
Set MyPageCounter = Server.CreateObject("MSWC.PageCounter")
Zmienna
MyPageCounter
zawiera kopię składnika
Page Counter
. Druga składnia do tworzenia kopii tego
składnika używa innego ciągu aplikacji i klasy:
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
Tu również zmienna
MyPageCounter
jest obiektem klasy
Page Counter
.
Biblioteka .dll tworzy wewnętrzny plik tekstowy i zapamiętuje, ile razy strona była przeglądana. Składnik
okresowo wrzuca te informacje do pliku tekstowego, tak więc dane zostaną zachowane nawet gdy serwer
zostanie wyłączony. Kiedy składnik jest inicjowany, ładuje wartości trafnych wywołań różnych stron.
Aby zapisać wywołanie na stronie musisz użyć metody
PageHit
składnika
Page Counter
:
<%
Option Explicit
Dim MyPageCounter
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
MyPageCounter.PageHit
%>
Najpierw instrukcja
Option Explicit
:
Option Explicit
Następnie tworzona jest zmienna przechowująca obiekt
Page Counter
:
Dim MyPageCounter
W zmienną wpisywany jest składnik
Page Counter
:
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
Metoda
PageHit
obiektu
Page Counter
używana jest do inkrementacji liczby dla określonej strony:
MyPageCounter.PageHit
tak więc stan licznika dla tej strony wewnętrznie zwiększany jest o jeden. Składnik zapamiętuje nazwę strony i
jej położenie wraz z wartością zapewniającą stronie niepowtarzalność.
Licznik stron nie byłby wiele wart, jeśli nie mógłbyś wyświetlać jego zawartości. W tym celu składnik zawiera
metodę
Hits
. Metoda ta ma następującą składnię:
TheCount = MyPageCounter.Hits(OptPageName)
Zmienna
MyPageCounter
musi zatwierdzonym obiektem
Page Counter
. Zwracaną wartością polecenia jest liczba
trafnych wywołań strony, która znajdzie się w zmiennej
TheCount
. Metoda pobiera jeden nieobowiązkowy
parametr — nazwę i wirtualną ścieżkę do strony, której ilość wywołań chcemy poznać. Jeśli nie podasz tego
parametru, metoda zwróci ilość wywołań bieżącej strony.
Spójrzmy na przykładową witrynę, która korzysta z tego składnika. Na początku strona powitania, którą
pokazano na rysunku 10.8.
ASP – Kompendium programisty
305
Rysunek 10.8. Strona powitania przykładowej witryny
Strona powitania zapamiętuje liczbę swoich wywołań, ale informacji tej nie wyświetla. Następna strona
przykładowej witryny również zapamiętuje liczbę swoich wywołań, a ponadto wyświetla informacje o
wywołaniach obydwu stron witryny. Ta strona pokazana jest na rysunku 10.9. Zauważ, że wyświetlane
informacje faktycznie dotyczą obu stron.
Rysunek 10.9. Strona wyświetlająca informacje o ilości wywołań
Kod strony powitania inkrementuje licznik wywołań dla tej strony. Blok kodowy jest taki:
<%
Option Explicit
Rozdział 10 – Składniki ASP
306
Dim MyPageCounter
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
MyPageCounter.PageHit
%>
Dim MyPageCounter
End If
Po pierwsze informujemy kompilator o tym, że deklarowane będą zmienne:
Option Explicit
Następnie deklarujemy zmienną licznika stron:
Dim MyPageCounter
i tworzymy jej kopię:
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
Licznik strony powitania jest inkrementowany:
MyPageCounter.PageHit
Kod strony informacyjnej inkrementuje licznik tej strony, a następnie wyświetla informacje o trafnych
wywołaniach obu stron. Główny blok kodowy wygląda następująco:
<%
Option Explicit
Dim CompInfoCount
Dim WelcomeCount
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
MyPageCounter.PageHit
If MyPageCounter.Hits = 1 Then
CompInfoCount = "1 raz"
else
CompInfoCount = MyPageCounter.Hits & " razy"
If MyPageCounter.Hits("/aspbook/c10/pc/html/welcome.asp") = 1 Then
WelcomeCount = "1 raz"
else
WelcomeCount = MyPageCounter.Hits("/aspbook/c10/pc/html/welcome.asp") _
& " razy"
End If
%>
Pierwszy wiersz kodu to instrukcja
Option Explicit
:
Option Explicit
Następnie deklarowana jest zmienna obiektu licznika stron:
Dim MyPageCounter
ASP – Kompendium programisty
307
Tworzona jest zmienna, która będzie przechowywała liczbę wywołań strony informacyjnej:
Dim CompInfoCount
Ta zmienna będzie zapamiętywała liczbę wywołań strony powitania:
Dim WelcomeCount
Następnie tworzona jest kopia obiektu licznika stron:
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
CompInfoCount = "1 raz"
%>.
Metoda
PageHit
używana jest do inkrementacji liczby wywołań tej strony:
MyPageCounter.PageHit
Następnie musimy stworzyć wiadomości tekstowe, informujące o ilości wywołań obu stron. Metoda
Hits
obiektu
Page Counter
wyszukuje tą wartość. Najpierw jednak patrzymy na ilość wywołań tej strony:
If MyPageCounter.Hits = 1 Then
Kod tego bloku
If
nadaje odpowiednią formę gramatyczną słowu “raz”:
Zauważ, że używamy metody
Hits
bez parametru, ponieważ na razie zajmujemy się ilością wywołań bieżącej
strony:
else
CompInfoCount = MyPageCounter.Hits & " razy"
End If
Dalej te same czynności są realizowane dla strony powitania. Zauważ, że teraz metoda
Hits
zawiera parametr,
wirtualną ścieżkę do strony, której ilość wywołań chcemy poznać:
If MyPageCounter.Hits("/aspbook/c10/pc/html/welcome.asp") = 1 Then
WelcomeCount = "1 raz"
else
WelcomeCount = MyPageCounter.Hits("/aspbook/c10/pc/html/welcome.asp") _
& " razy"
End If
Następnie w HTML-u wypisywana jest informacja o wywołaniach wspólnie z dwoma ciągami:
<P>Ta strona była przeglądana <% response.write CompInfoCount %>.
<BR>Strona powitania była przeglądana <% response.write WelcomeCount
Składnik
Page Counter
ma jeszcze jedną metodę,
Reset
, która wpisuje do licznika strony ponownie wartość
zero. Metoda ma następującą składnię:
MyPageCounter.Reset OptPage
Rozdział 10 – Składniki ASP
308
Zmienna
MyPageCounter
musi być zatwierdzonym obiektem
Page Counter
. Metoda posiada jeden
nieobowiązkowy parametr. Określa on wirtualną ścieżkę do strony, której licznik chcesz wyzerować. Jeśli nie
podasz tego parametru, wyzerowany zostanie licznik strony bieżącej.
Uzupełnijmy naszą przykładową witrynę o tą metodę, dodając do niej stronę raportu wyszczególniającą ilość
wywołań każdej ze stron i pozwalającą gościowi na kasowanie liczników. Taką stronę pokazano na rysunku
10.10. Zawiera ona w pierwszej kolumnie nazwy wszystkich stron, a dalej ilość ich wywołań i łącza
pozwalające na wyzerowanie licznika każdej ze stron. Kliknięcie łącza spowoduje wpis do licznika wartości 0,
a strona zostanie ponownie wyświetlona. Jeśli na przykład klikniesz łącze Wyczyść dla strony informacyjnej, jej
licznik zostanie skasowany, jak to pokazano na rysunku 10.11. Kod strony raportu musi dodać jeden do ilości
swoich wywołań, skasować licznik żądanej strony i ponownie wyświetlić ilość wywołań dla każdej strony.
Główny blok kodowy jest taki:
<%
Option Explicit
Dim MyPageCounter
Dim CompInfoCount
Dim WelcomeCount
Dim HitReportCount
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
MyPageCounter.PageHit
If not isempty(Request.QueryString("ClearPage")) Then
If Request.QueryString("ClearPage") = "Welcome" Then
MyPageCounter.Reset("/aspbook/c10/pc/html/welcome.asp")
ElseIf Request.QueryString("ClearPage") = "CI" Then
MyPageCounter.Reset("/aspbook/c10/pc/html/company_info.asp")
ElseIf Request.QueryString("ClearPage") = "Report" Then
MyPageCounter.Reset
End If
End If
If MyPageCounter.Hits("/aspbook/c10/pc/html/company_info.asp") = 1 Then
CompInfoCount = "1 raz"
else
CompInfoCount = MyPageCounter.Hits("/aspbook/c10/pc/html/company_info.asp") & " razy"
End If
If MyPageCounter.Hits("/aspbook/c10/pc/html/welcome.asp") = 1 Then
WelcomeCount = "1 raz"
else
WelcomeCount = MyPageCounter.Hits("/aspbook/c10/pc/html/welcome.asp") & " razy"
End If
If MyPageCounter.Hits = 1 Then
HitReportCount = "1 raz"
else
HitReportCount = MyPageCounter.Hits & " razy"
End If
%>
ASP – Kompendium programisty
309
Rysunek 10.10. Strona raportu wywołań
Rysunek 10.11. Strona raportu po wyzerowaniu licznika
Na wstępie pojawia się instrukcja
Option Explicit
:
Option Explicit
Następnie tworzona jest zmienna dla obiektu
Page Counter
:
Dim MyPageCounter
Potrzebujemy również zmiennych do zapamiętania ilości wywołań każdej ze stron:
Rozdział 10 – Składniki ASP
310
Dim CompInfoCount
Dim WelcomeCount
Dim HitReportCount
Tworzona jest kopia obiektu
Page Counter
:
Set MyPageCounter = Server.CreateObject("IISSample.PageCounter")
Zapisywane jest wywołanie strony raportu:
MyPageCounter.PageHit
Następnie kod sprawdza, czy któryś licznik powinien być wyzerowany. Łącza służące do kasowania liczników
przekazują nazwę strony poprzez pole
ClearPage
za pomocą zbioru
QueryString
(będziesz się mógł o tym
przekonać nieco później). Jeśli więc pole to nie jest puste, należy skasować licznik strony:
If not isempty(Request.QueryString("ClearPage")) Then
Jeśli wartością pola będzie ciąg
Welcome
, musi być skasowany licznik strony powitania:
If Request.QueryString("ClearPage") = "Welcome" Then
Zwróć uwagę na to, że metoda
Reset
, odnosząca się do strony raportu, nie posiada parametru. Jest to
spowodowane tym, że kasujemy ilość wywołań strony bieżącej, tak więc parametr nie jest potrzebny:
else
Zauważ, że metoda
Reset
musi przekazać parametr określający wirtualną ścieżkę strony, której licznik jest
kasowany, ponieważ metoda ta odnosi się do strony innej niż bieżąca:
MyPageCounter.Reset("/aspbook/c10/pc/html/welcome.asp")
Podobne sprawdzenie i akcja realizowane są dla strony informacyjnej:
ElseIf Request.QueryString("ClearPage") = "CI" Then
MyPageCounter.Reset("/aspbook/c10/pc/html/company_info.asp")
ElseIf Request.QueryString("ClearPage") = "Report" Then
MyPageCounter.Reset
Następnie kod przygotowuje odpowiedni tekst informacji o wywołaniach strony informacyjnej:
If MyPageCounter.Hits("/aspbook/c10/pc/html/company_info.asp") = 1 Then
CompInfoCount = "1 raz"
CompInfoCount = MyPageCounter.Hits("/aspbook/c10/pc/html/company_info.asp") & " razy"
End If
To samo robione jest dla strony powitania:
If MyPageCounter.Hits("/aspbook/c10/pc/html/welcome.asp") = 1 Then
WelcomeCount = "1 raz"
else
WelcomeCount = MyPageCounter.Hits("/aspbook/c10/pc/html/welcome.asp") & " razy"
ASP – Kompendium programisty
311
End If
jak również dla strony raportu:
If MyPageCounter.Hits = 1 Then
HitReportCount = "1 raz"
else
<TD WIDTH=164><P><A HREF="./hitreport.asp?ClearPage=Report">
HitReportCount = MyPageCounter.Hits & " razy"
End If
Tabela HTML musi być wypełniona właściwym tekstem dla każdej strony.
<TD WIDTH=164><P>Strona powitania</TD>
<TD WIDTH=164><P><% response.write WelcomeCount %></TD>
<TD WIDTH=164><P><A HREF="./hitreport.asp?ClearPage=Welcome">
<B>Wyczyść</B></A></TD>
<TD WIDTH=164><P>Strona informacyjna</TD>
<TD WIDTH=164><P><% response.write CompInfoCount %></TD>
<TD WIDTH=164><P><A HREF="./hitreport.asp?ClearPage=CI">
<B>Wyczyść</B></A></TD>
<TD WIDTH=164><P>Strona raportu wywołań</TD>
<TD WIDTH=164><P><% response.write HitReportCount %></TD>
<B>Wyczyść</B></A></TD>
Zauważ, że pierwsza komórka tabeli HTML zawiera jedynie nazwę strony:
<TD WIDTH=164><P>Strona powitania</TD>
Następnie do przeglądarki wpisywana jest informacja o trafnych wywołaniach:
<TD WIDTH=164><P><% response.write WelcomeCount %></TD>
Zwróć również uwagę, że łącze kasowania licznika odnosi się do tej samej strony. Ponadto poprzez zbiór
QueryString
przekazywana jest wraz z łączem nazwa tej strony, której licznik należy wyzerować:
<TD WIDTH=164><P><A HREF="./hitreport.asp?ClearPage=Welcome">
<B>Wyczyść</B></A></TD>
Składnik Counters
Składnik Counters stanowi prosty interfejs do przechowywania liczb całkowitych, które możesz odczytywać,
zapisywać, usuwać i inkrementować we wszystkich stronach twojej witryny, a nawet w granicach aplikacji
ASP. Tak jak to było w wypadku ostatniego składnika, również ten jest częścią zestawu IIS Resource Kit. Oto
jego lokalizacja:
\IIS Resource Kit\Component\Counters\DLL\i386\counters.dll
Umieść plik w twoim katalogu WinNT\System32, a następnie zarejestruj składnik przy użyciu polecenia
Uruchom (Run) z menu Start, wprowadzając zapis Regsvr32 counters.dll. Po pomyślnym zarejestrowaniu
składnika, możesz zacząć z niego korzystać.
Składnię do tworzenia składnika
Counters
przedstawiono poniżej:
Rozdział 10 – Składniki ASP
312
set MyCounter = Server.CreateObject("MSWC.Counters")
Kopia składnika
Counters
tworzona jest przy użyciu metody
CreateObject
obiektu
Server
. Metodzie
przekazuje się ciąg zawierający aplikację i klasę —
MSWC.Counters
. Obiekt klasy
Counters
jest zwracany w
zmiennej
MyCounter
.
Składnik
Counters
przechowuje wartości liczników w pliku tekstowym położonym w tym samym miejscu, co
plik biblioteki. Wartości te dostępne są w każdej stronie twojej witryny WWW, nawet jeśli witryna
umiejscowiona jest w innej aplikacji ASP.
Takie zmienne mają zasięg przekraczający zasięg wszystkich innych omówionych do tej pory. Zwróciliśmy już
uwagę na zmienne obiektu
Session
, które są dostępne dla wszystkich stron aplikacji ASP, lecz w czasie trwania
określonej sesji. Przyjrzeliśmy się również zmiennym obiektu
Application
osiągalnym dla wszystkich stron i w
czasie trwania wszystkich sesji, ale w obrębie jednej aplikacji ASP. Natomiast zmienne licznika przekraczają te
ograniczenia, ponieważ są dostępne dla wszystkich stron bez względu na to, do której aplikacji ASP należą.
Licznik tworzy się wyszukując jego wartości lub je ustawiając. Wyszukiwanie wartości licznika realizuje się
przy użyciu metody
Get
składnika
Counters
:
TheValue = MyCounter.Get(NameOfCounter)
Dim MyCounter
Zmienna
MyCounter
musi być kopią zmiennej składnika
Counters
. Metoda
Get
pobiera jeden parametr, którym
jest nazwa licznika. Metoda zwraca aktualną wartość licznika i umieszcza ją w zmiennej
TheValue
. Jeśli licznik
o podanej nazwie nie istnieje, zostaje utworzony i zwracana jest wartość 0.
W tym przykładzie:
<%
Option Explicit
set MyCounter = Server.CreateObject("MSWC.Counters")
Response.Write MyCounter.Get("Product10Views")
%>
w przeglądarce wyświetlona zostanie wartość licznika
Product10Views
. Jeśli taki licznik nie istnieje, zostaje
utworzony, a w przeglądarce wyświetlana jest liczba 0.
Aby wpisać do licznika jakąś określoną wartość, możesz wykorzystać metodę
Set
. Ustawia ona w liczniku
wskazaną przez ciebie wartość, a jeśli licznik o podanej nazwie nie istnieje, składnik tworzy nowy licznik.
Metoda ma następującą wartość:
MyCounter.Set NameOfCounter, ValueOfCounter
Zmienna
MyCounter
musi być ważnym obiektem
Counters
. Metodzie
Set
przekazywane są dwa parametry:
pierwszy jest nazwą licznika, którego wartość chcemy ustawić, drugi jest tą właśnie wartością.
Na przykład:
<%
Option Explicit
Dim MyCounter
set MyCounter = Server.CreateObject("MSWC.Counters")
MyCounter.Set "AllPageViews", 123
%>
Ten kod wpisze wartość 123 do licznika o nazwie
AllPageViews
. Jeśli taki licznik nie istnieje, zostaje
utworzony i wpisywana jest do niego żądana wartość.
Kolejną metodą składnika jest metoda
Increment
, która zwiększa wartość licznika o jeden. Metoda ma
następującą składnię:
ASP – Kompendium programisty
313
MyCounter.Increment NameOfCounter
%>
Zmienna
MyCounter
musi być zatwierdzoną kopią składnika
Counters
.
NameOfCounter
jest nazwą
inkrementowanego licznika.
Zwróć uwagę na ten przykład:
<%
Option Explicit
Dim MyCounter
set MyCounter = Server.CreateObject("MSWC.Counters")
MyCounter.Increment "AllPageViews"
Tutaj stan licznika
AllPageViews
jest zwiększany o jeden, jeśli więc jego wartość wynosiła wcześniej 123, teraz
będzie to 124.
Składnik
Counters
ma jeszcze jedną metodę,
Remove
, która usuwa licznik z pliku liczników. Jeśli po użyciu tej
metody następuje odwołanie do usuniętego licznika, jest on tworzony na nowo, a jego wartość wynosi 0 (jeśli
licznik jest tworzony przy użyciu metody
Set
).
Metoda ma następującą składnię:
MyCounter.Remove NameOfCounter
Zmienna
MyCounter
musi być zatwierdzoną kopią składnika
Counters
. Metoda pobiera jeden parametr — nazwę
usuwanego licznika.
Na przykład:
<%
Option Explicit
Dim MyCounter
set MyCounter = Server.CreateObject("MSWC.Counters")
MyCounter.Remove "AllPageViews"
%>
W tym kodzie licznik
AllPageViews
jest usuwany z pamięci. Jeśli usunięty licznik jest następnie wywoływany
przy użyciu metody
Set
lub
Get
, jest tworzony ponownie.
W następnym bloku kodu użyto wszystkich omówionych metod, aby zademonstrować działanie składnika.
<%
Option Explicit
Dim MyCounter
set MyCounter = Server.CreateObject("MSWC.Counters")
Response.Write "<B>Teraz tworzony jest nowy licznik.<P>"
Response.Write "Jego wartość wynosi: "
Response.Write MyCounter.Get("Counter1") & "<P>"
MyCounter.Set "Counter1", 33
Response.Write "Teraz wpisana została do niego wartość: "
Response.Write MyCounter.Get("Counter1") & "<P>"
MyCounter.Increment "Counter1"
Response.Write "Licznik został inkrementowany: "
Response.Write MyCounter.Get("Counter1") & "<P>"
MyCounter.Remove "Counter1"
Rozdział 10 – Składniki ASP
314
Response.Write " Licznik został usunięty. " & "<P>"
MyCounter.Set "Counter2", 250
Response.Write "Ustawiona została wartość nowego licznika : "
Response.Write MyCounter.Get("Counter2") & "<P>"
%>
Na początku umieszczamy instrukcję
Option Explicit
:
Option Explicit
Tworzona jest zmienna przechowująca obiekt
Counters
:
Dim MyCounter
Tworzona jest kopia zmiennej:
set MyCounter = Server.CreateObject("MSWC.Counters")
Poprzez wywołanie metody
Get
tworzony jest licznik i wyświetlana jest jego początkowa wartość:
Response.Write "<B>Teraz tworzony jest nowy licznik.<P>"
Response.Write "Jego wartość wynosi: "
Response.Write MyCounter.Get("Counter1") & "<P>"
W ten sam licznik wpisywana jest liczba 33:
Wykorzystana zostaje metoda
Remove
w celu usunięcia licznika
Counter1
:
MyCounter.Set "Counter1", 33
która następnie wyświetlana jest w przeglądarce przy użyciu metody
Get
:
Response.Write "Teraz wpisana została do niego wartość: "
Response.Write MyCounter.Get("Counter1") & "<P>"
Licznik
Counter1
jest inkrementowany:
MyCounter.Increment "Counter1"
Wartość licznika ponownie jest wyświetlana w przeglądarce:
Response.Write "Licznik został inkrementowany: "
Response.Write MyCounter.Get("Counter1") & "<P>"
MyCounter.Remove "Counter1"
Response.Write " Licznik został usunięty. " & "<P>"
Następnie tworzony jest drugi licznik, który będzie wyświetlany w kolejnej stronie, znajdującej się w obrębie
innej aplikacji ASP:
MyCounter.Set "Counter2", 250
ASP – Kompendium programisty
315
a wartość tego licznika prezentowana jest tutaj:
Response.Write "Ustawiona została wartość nowego licznika : "
Response.Write MyCounter.Get("Counter2") & "<P>"
Wyjście strony przedstawia rysunek 10.12.
Rysunek 10.12. Wyjście kodu licznika
Pamiętaj, że liczniki mają zasięg przekraczający zakres jednej aplikacji ASP, tak więc w kolejnej stronie
należącej do innej aplikacji ASP możemy odwoływać się do licznika stworzonego w tym kodzie:
<%
Option Explicit
Dim MyCounter
set MyCounter = Server.CreateObject("MSWC.Counters")
Response.Write "<B>Ta strona wyszukuje wartość drugiego licznika "
Response.Write "stworzonego w innej aplikacji ASP. "
Response.Write "<P>Jego wartość: "
Response.Write MyCounter.Get("Counter2") & ".<P>"
%>
Na wstępie pojawia się instrukcja
Option Explicit
:
Option Explicit
Następnie tworzona jest zmienna licznika:
Dim MyCounter
i jej kopia:
set MyCounter = Server.CreateObject("MSWC.Counters")
Rozdział 10 – Składniki ASP
316
Wartość licznika utworzonego w innej stronie, wyszukana poprzez metodę
Get
, jest wpisywana do
przeglądarki:
Response.Write "<P>Jego wartość: "
Response.Write "<B>Ta strona wyszukuje wartość drugiego licznika "
Response.Write "stworzonego w innej aplikacji ASP. "
Response.Write MyCounter.Get("Counter2") & ".<P>"
Wyjście tej strony, będącej częścią innej aplikacji ASP, pokazane zostało na rysunku 10.13.
Rysunek 10.13. Wyjście drugiej pokazowej strony licznika
Składnik Content Linking
Składnik jest częścią standardowej instalacji IIS. Jego plik biblioteki nosi nazwę nextlink.dll. Podstawą
działania składnika jest plik tekstowy zawierający informacje o wszystkich stronach, które chcesz połączyć
oraz o kolejności, w jakiej te strony mają być połączone. W tym specjalnym pliku tekstowym podajesz nie
tylko nazwę strony, ale również jej adres URL. Plik nie musi nosić jakiejś określonej, specjalnej nazwy — musi
być jedynie dostępny w strukturze katalogu tej witryny WWW, w której będzie wykorzystany.
Każde pole oddzielone jest od siebie znakiem tabulacji, a każda pozycja musi umieszczona w osobnym wierszu
tekstowego pliku indeksu. Pierwsze pole każdego wiersza przechowuje adres URL danej strony. Drugie pole
jest nazwą lub opisem strony. Trzecie, które nie jest wymagane, może zawierać dowolny komentarz, który po
prostu jest ignorowany przez składnik.
Składnik Content Linking pozwala na połączenie stron w taki sposób, aby mogły być przeglądane w seriach,
sekwencyjnie. Przykładowo książka składa się ze stron ułożonych sekwencyjnie, a plik pomocy składa się z
serii stron. Jeśli masz taki scenariusz, to często będziesz chciał dysponować łączami, które dynamicznie
przenosiłyby gości do strony następnej lub z powrotem, do poprzedniej. Być może będziesz chciał również
mieć tabelę zawartości dla serii stron. Składnik
Content Linking
łączy w sobie metody umożliwiające
realizację takich funkcji.
Każdy wiersz pliku tekstowego ma następującą strukturę:
PageURL Description Comment
Spójrz na ten przykładowy plik indeksu:
ASP – Kompendium programisty
317
TOC.asp Table of Contents Page
Page1.asp Page 1 of Chapter 1
Page2.asp Page 2 of Chapter 1
Zauważ, że adres URL i opis są od siebie oddzielone znakiem tabulacji. Ponadto zwróć uwagę na kolejność
pozycji. Jest to ważne, ponieważ metody nawigacyjne używają tej kolejności w celu określenia, która strona
jest następna, a która poprzednia. Stwierdziłem, że najlepszym miejscem na zapisanie tego pliku jest katalog, w
którym umieszczone są używające go strony. Dzięki temu prostsze staje się używanie metod, ponieważ ścieżkę
dostępu do strony można przestawić za pomocą samej jej nazwy.
W twoim kodzie możesz stworzyć kopię składnika
Content Linking
, który będzie używał tego pliku
tekstowego w celu określenia koniecznych do podjęcia działań. Aby stworzyć kopię składnika
Content
Linking
, należy użyć takiego kodu:
Set MyCL = Server.CreateObject("MSWC.NextLink")
Jak to było w wypadku innych składników, do tworzenia kopii
Content Linking
używamy metody
CreateObject
obiektu
Server
. Tutaj kopia zostanie umieszczona w zmiennej obiektowej
MyCL
. Od tej chwili
możesz używać pliku tekstowego wraz z ze stworzonym obiektem do zaspokajania potrzeb nawigacyjnych tego
typu aplikacji.
Składnik posiada osiem metod, które omówiono poniżej i sumarycznie przedstawiono w tabeli 10.2.
Tabela 10.2. Metody składnika
Content Linking
Metoda
Działanie
GetListCount
Zwraca liczbę pozycji pliku indeksu.
GetListIndex
Zwraca numer pozycji bieżącej strony w pliku indeksu.
GetNextURL
Zwraca adres URL strony następnej względem strony
bieżącej.
GetNextDescription
Zwraca opis strony następnej względem strony bieżącej.
GetPreviousURL
Zwraca URL strony poprzedniej względem strony
bieżącej.
GetPreviousDescription
Zwraca opis strony poprzedniej względem strony
bieżącej.
GetNthURL
Zwraca URL pozycji indeksu w oparciu o liczbę
przekazaną metodzie.
GetNthDescription
Zwraca opis pozycji indeksu w oparciu o liczbę
przekazaną metodzie.
Metoda
GetListCount
zwraca liczbę pozycji w pliku indeksu. Jej składnia jest następująca:
TheCount = MyCL.GetListCount(Path2IndexFile)
Metodzie przekazywana jest wirtualna ścieżka do pliku indeksu (
Path2IndexFile
), jeśli więc plik ten położony
jest w tym samym miejscu co strona dokonująca wywołania, wprowadzona musi być jedynie nazwa pliku.
Zwracaną przez metodę wartością jest liczba pozycji w pliku indeksu, jeśli więc stworzysz taki kod odnoszący
się do pliku omówionego wcześniej:
Response.Write MyCL.GetListCount("CLList.txt")
to do przeglądarki wpisana zostanie liczba 3.
Następną metodą jest
GetListIndex
, która zwraca numer pozycji bieżącej strony w pliku indeksu. Metoda ma
następującą składnię:
TheIndex = MyCL.GetListIndex(Path2IndexFile)
Rozdział 10 – Składniki ASP
318
Zmienna
MyCL
musi być ważnym składnikiem
Content Linking
. Metodzie przekazywany jest parametr
Path2IndexFile
, który stanowi ścieżkę wirtualną do tekstowego pliku indeksu. Gdybyś poszukiwał strony
Page1.asp w pliku indeksowym opisanym wcześniej, to następujący kod:
Response.Write MyCL.GetListIndex("CLList.txt")
wpisałby do przeglądarki liczbę 2.
Metoda
GetNextURL
zwraca URL następnej pozycji pliku indeksu. Jeśli bieżąca strona jest ostatnią na liście,
metoda
GetNextURL
zwróci pierwszą stronę z listy, przenosząc gościa w pętli na początek. Metoda ma
następującą składnię:
TheURL = MyCL.GetNextURL(Path2IndexFile)
Zmienna
MyCL
musi być ważnym składnikiem
Content Linking
. Parametr
Path2IndexFile
jest ścieżką wirtualną
do pliku indeksu. Metoda zwraca adres URL następnej pozycji w pliku indeksu, jeśli więc znajdowalibyśmy się
na stronie Page1.asp, to ten kod:
Response.Write MyCL.GetNextURL("CLList.txt")
wpisze do przeglądarki Page2.asp.
Metoda
GetNextDescription
wyszukuje pole opisu tej pozycji pliku indeksu, która następuje za bieżącą stroną.
Jeśli bieżącą stroną jest strona ostatnią, wtedy składnik zwraca opis pierwszej strony z listy. Metoda ma
następującą składnię:
TheDescription = MyCL.GetNextDescription(Path2IndexFile)
Zmienna
MyCL
musi być kopią składnika
Content Linking
. Metodzie przekazywana jest ścieżka do pliku
indeksu, a wartością zwracaną jest opis następnej w pliku indeksu strony. Jeśli więc znajdowałbyś się na stronie
Page1.asp z poprzedniego pliku indeksu, to taki kod:
Response.Write MyCL.GetNextDescription("CLList.txt")
wpisałby do przeglądarki następujący tekst:
Page 2 of Chapter 1
Metoda
GetPreviousURL
zwraca URL poprzedniej pozycji w tekstowym pliku indeksu. Jeśli bieżąca strona jest
pierwsza na liście, metoda
GetPreviousURL
zwróci adres URL ostatniej strony z listy, przechodząc w pętli na
koniec pliku. Metoda ma następującą składnię:
TheURL = MyCL.GetPreviousURL(Path2IndexFile)
Zmienna
MyCL
musi być zatwierdzonym składnikiem
Content Linking
. Parametr
Path2IndexFile
jest ścieżką
wirtualną do pliku indeksu. Metoda zwraca URL poprzedniej pozycji pliku indeksu, jeśli więc
znajdowalibyśmy się na stronie Page1.asp i napisalibyśmy taki kod:
Response.Write MyCL.GetNextURL("CLList.txt")
w przeglądarce ukazałby się URL TOC.asp.
Metoda
GetPreviousDescription
wyszukuje pole opisu tej pozycji pliku indeksu, która poprzedza bieżącą
stronę. Jeśli strona bieżąca jest stroną pierwszą, to składnik zwróci opis strony znajdującej się na końcu listy.
Metoda ma następującą składnię:
ASP – Kompendium programisty
319
Response.Write MyCL.GetPreviousDescription("CLList.txt")
Zostały nam do omówienia jeszcze dwie metody,
GetNthURL
i
GetNthDescription
, które również zwracają URL
i opis (odpowiednio) z pliku indeksu. Jednak w tych metodach określasz numer pozycji, która ma być zwrócona
przez funkcję.
Response.Write MyCL.GetNthDescription("CLList.txt", 2)
get_method.asp Metoda Get
increment_method.asp Metoda Increment
TheDescription = MyCL.GetPreviousDescription(Path2IndexFile)
Zmienna
MyCL
musi być kopią składnika
Content Linking
. Metodzie przekazywana jest ścieżka do pliku
indeksu. Zwracaną wartością jest opis strony poprzedniej w pliku indeksu, jeśli więc znajdowałbyś się na
stronie Page1.asp, to następujący wiersz kodu:
wpisałby do przeglądarki tekst:
Table of Contents Page
Metoda
GetNthURL
ma następującą składnię:
TheURL = MyCL.GetNthURL(Path2ToIndexFile, NumericPosition)
Zmienna
MyCL
musi być zatwierdzoną kopią składnika
Content Linking
. Metodzie przekazywane są dwa
parametry: pierwszy z nich to wirtualne położenie tekstowego pliku indeksu; drugi parametr zapamiętuje numer
pozycji, której URL chcesz otrzymać i ten właśnie URL jest zwracany przez metodę.
Jeśli przykładowo stworzyłeś taki kod odnoszący się do pliku indeksu omówionego wcześniej:
Response.Write MyCL.GetNthURL("CLList.txt", 2)
to do przeglądarki zostanie wpisane łącze Page1.asp.
Metoda
GetNthDescription
ma następującą składnię:
TheDescription = MyCL.GetNthDescription(Path2ToIndexFile, NumericPosition)
Zmienna
MyCL
musi być zatwierdzoną kopią składnika
Content Linking
. Metodzie przekazywane są dwa
parametry: pierwszy z nich to wirtualne położenie tekstowego pliku indeksu; drugi parametr zapamiętuje numer
pozycji, której opis chcesz otrzymać i ten właśnie opis jest zwracany przez metodę.
Jeśli stworzyłbyś taki przykładowy kod odnoszący się do omówionego wcześniej tekstowego pliku indeksu:
to jego wynikiem będzie pojawienie się w przeglądarce tekstu
Page 1 of Chapter 1
.
Jeśli połączysz ze sobą te metody, możesz stworzyć całkiem niezłą aplikację ASP umożliwiającą gościom
kolejne przechodzenie przez strony twojej witryny, zarówno w przód, jak i w tył oraz wyświetlającą tabelę
zawartości. Zwróćmy uwagę na taką witrynę WWW, która opisuje omówione w poprzednim podrozdziale
metody składnika
Counters
.
Poniżej przedstawiony jest tekst pliku indeksu, który położony jest w tym samym katalogu co strony ASP:
set_method.asp Metoda Set
remove_method.asp Metoda Remove
get_method.asp Metoda Get
toc.asp Tabela zawartości
Rozdział 10 – Składniki ASP
320
Wyszczególnione zostały cztery metody wraz ze swoimi adresami URL i opisami. Tabelę zawartości,
wytworzoną na podstawie indeksu, prezentuje rysunek 10.14.
Rysunek 10.14. Strona tabeli zawartości witryny wykorzystującej składnik
Content Linking
Zwróć uwagę na to, że kolejność pozycji na rysunku 10.14. jest taka sama jak w tekstowym pliku indeksu.
Kiedy goście klikną łącze Metoda Get, ujrzą stronę pokazaną na rysunku 10.15.
Rysunek 10.15. Strona metody
Get
witryny wykorzystującej składnik
Content Linking
Zwróć uwagę na łącza znajdujące się na stronie metody
Get
. Łącze ze stroną poprzednią odsyła gości do tabeli
zawartości, ponieważ strona metody
Get
je pierwszą stroną na liście. Łącze ze stroną następną wyświetla tekst
Metoda Set, które odsyła gości do strony pokazanej na rysunku 10.16.
ASP – Kompendium programisty
321
Rysunek 10.16. Strona metody
Set
witryny wykorzystującej składnik
Content Linking
Za stroną metody
Increment
pojawia się strona metody
Remove
, pokazana na rysunku 10.17. Zauważ, że łącze
ze stroną następną odsyła gości do tabeli zawartości, ponieważ jest to ostatnia pozycja z listy stron. Łącze z
poprzednią stroną przenosi gości do strony metody
Increment
.
Rysunek 10.17. Strona metody
Remove
witryny wykorzystującej składnik
Content Linking
Kod użyty do stworzenia tej witryny składa się z dwóch części: jedna z nich służy wykonaniu strony tabeli
zawartości; następnie strony wszystkich metod wykorzystują tą samą strukturę kodu w celu wyświetlenia łącz
ze stroną następną i poprzednią.
Pierwszy blok kodu dla tabeli zawartości jest następujący:
Rozdział 10 – Składniki ASP
322
Option Explicit
Następnie tworzona jest zmienna przechowująca obiekt
Content Linking
:
Inna zmienna jest tworzona w celu zapamiętania ilości iteracji w drugim bloku kodu:
Set MyCL = Server.CreateObject("MSWC.NextLink")
<%
Kod wykorzystuje pętlę
For
, w której przechodzi kolejno przez wszystkie pozycje tekstowego pliku indeksu:
<%
Option Explicit
Dim MyCL
Dim TheCount
Dim I
Set MyCL = Server.CreateObject("MSWC.NextLink")
TheCount = MyCL.GetListCount("CLList.txt")
%>
Na początku pojawia się instrukcja
Option Explicit
:
Dim MyCL
Kolejna zmienna będzie przechowywała całkowitą liczbę pozycji w tekstowym pliku indeksu:
Dim TheCount
Dim I
Tworzona jest kopia składnika
Content Linking
:
Do zmiennej
TheCount
wpisywana jest ilość pozycji w tekstowym pliku indeksu:
TheCount = MyCL.GetListCount("CLList.txt")
Następny blok kodu wytwarza tabelę HTML zawierającą wszystkie pozycje wyszczególnione w pliku indeksu.
<%
For I = 1 to TheCount
%>
<TR>
<TD WIDTH=423><P><A HREF="
<% Response.Write MyCL.GetNthURL("CLList.txt", i) %>">
<B><% Response.Write MyCL.GetNthDescription("CLList.txt", i) %>
</B></A>
</TD>
</TR>
Next
%>
ASP – Kompendium programisty
323
For I = 1 to TheCount
Następnie każda pozycja wpisywana jest do tabeli HTML. Adres URL wpisywany jest przy użyciu metody
GetNthURL
, a opis — przy użyciu metody
GetNthDescription
. Kod przechodzi w pętli do następnego rekordu:
Next
Kod wszystkich innych stron jest taki sam. Pierwszy blok kodu tworzy składnik
Content Linking
.
<%
Option Explicit
Dim MyCL
Set MyCL = Server.CreateObject("MSWC.NextLink")
%>
Na początku instrukcja
Option Explicit
:
Option Explicit
Następnie tworzona jest zmienna, która będzie przechowywała składnik
Content Linking
:
W końcu opis łącza ze stroną następną:
<% Response.Write MyCL.GetNextDescription("CLList.txt") %></A></B>
Dim MyCL
Tworzona jest kopia obiektu:
Set MyCL = Server.CreateObject("MSWC.NextLink")
Kolejny blok kodu wpisuje do przeglądarki łącza ze stroną poprzednią i następną.
<P><A HREF="<% Response.Write MyCL.GetPreviousURL("CLList.txt")%>"><B>
<% Response.Write MyCL.GetPreviousDescription("CLList.txt") %></A></B>
<P><A HREF="<% Response.Write MyCL.GetNextURL("CLList.txt") %>"><B>
<% Response.Write MyCL.GetNextDescription("CLList.txt") %></A></B>
Na początku wpisywane jest łącze ze stroną poprzednią:
<P><A HREF="<% Response.Write MyCL.GetPreviousURL("CLList.txt")%>"><B>
Następnie opis łącza ze stroną poprzednią:
<% Response.Write MyCL.GetPreviousDescription("CLList.txt") %></A></B>
Łącze ze stroną następną:
<P><A HREF="<% Response.Write MyCL.GetNextURL("CLList.txt") %>"><B>
Rozdział 10 – Składniki ASP
324
Składnik Content Rotator
Składnik Content Rotator umożliwia prezentowanie innej zawartości za każdym razem, kiedy strona jest
ładowana. Przykładem zastosowania tego składnika może być włączenie do strony cytatu dnia, odmiennych
wiadomości powitania lub porady dnia. Te same funkcje można realizować ładując dane z bazy, jednak ten
składnik dostarcza alternatywnych mechanizmów, które nie wymagają ładowania bazy danych tylko po to, aby
zmienić poradę dnia.
Składnik nie jest częścią standardowej wersji instalacyjnej serwera IIS, można go znaleźć w zestawie IIS
Resource Kit. Biblioteka jest położona w następującym miejscu:
\IIS Resource Kit\Component\Content Rotator\DLL\i386\controt.dll
Umieść plik w twoim katalogu WinNT\System32, a następnie zarejestruj składnik przy użyciu polecenia
Uruchom (Run) z menu Start, wpisując
Regsvr32 controt.dll
.
Kiedy już go zainstalujesz, możesz stworzyć jego kopię za pomocą następującego wiersza kodu:
Set objCR = Server.CreateObject("IISSample.ContentRotator")
Do stworzenia kopii składnika używamy metody
CreateObject
obiektu
Server
. W tym przykładzie zmienna
objCR
będzie stanowiła kopię tego składnika.
Składnik bazuje na oddzielnym pliku tekstowym łączącym w sobie różną zawartość, która ma zostać
wyświetlona. W pliku nadajesz danej treści poziom odniesienia, określający jak często powinna się ona
ukazywać względem reszty zawartości. Możesz również wpisać swój komentarz, a następnie wprowadzić samą
zawartość.
Zawartość umieszczana jest wprost w HTML-u, możesz więc umieścić znaczniki HTML w pozycjach pliku.
Plik powinien być zapisany jako zwykły plik tekstowy w takim miejscu, aby można było go adresować ze
strony, która będzie korzystała z jego zawartości. Przekonałem się, że najlepiej umieścić go w tym samym
katalogu co strona korzystająca z zawartości, wtedy wywołanie pliku jest znacznie prostsze.
Każda pozycja pliku ma następującą strukturę:
%% #Ranking // Komentarz
Tekst zawartości
Każda pozycja rozpoczyna się podwójnym znakiem procentu. Po tym znaczniku może następować ranking (nie
jest wymagany), który określa częstość pojawiania się jednej pozycji względem innych znajdujących się na
liście; jeśli nie określisz rankingu, domyślnie ustalana jest dla niego wartość 1.
Po rankingu lub wartości odniesienia pojawia się komentarz, który również nie jest wymagany. Następny
wiersz to treść pozycji. Może ona obejmować wiele wierszy, które traktowane są jako treść dopóki ponownie
nie pojawi się podwójny znak procentu lub dopóki plik się nie skończy.
Składnik ma dwie metody służące wyszukiwaniu zawartości z pliku. Pierwszą z nich jest metoda
ChooseContent
, zwracająca pozycję z listy zawartości. Pojawienie się zwracanej pozycji jest bardziej
prawdopodobne, jeśli ma ona wyższy ranking. Metoda ma następującą składnię:
TheText = objCR.ChooseContent(Path2ContentFile)
Zmienna
objCR
musi być ważną kopią pliku
Content Rotator
. Metodzie przekazywany jest parametr
Path2ContentFile
. Jest to wirtualna ścieżka do pliku zawartości. Metoda zwraca tekst poszczególnych pozycji z
pliku zawartości.
Druga metoda,
GetAllContent
, zwraca zawartość wszystkich pozycji pliku i wpisuje je wprost do przeglądarki.
Metoda ma następującą składnię:
objCR.GetAllContent(Path2ContentFile)
Zmienna
objCR
musi być zatwierdzoną kopią składnika
Content Rotator
. Parametr
Path2ContentFile
jest
ścieżką do tekstowego pliku zawartości. Metoda wpisuje całą zawartość prosto do przeglądarki. Każda pozycja
zostanie oddzielona linią poziomą (znacznik HR HTML-a).
ASP – Kompendium programisty
325
Spójrzmy na próbną stronę cytatu dnia, która wykorzystuje ten składnik. Kiedy goście wywołają stronę po raz
pierwszy, ujrzą widok pokazany na rysunku 10.18.
Rysunek 10.18. Pierwsza strona cytatu dnia
Jeśli goście klikną łącze Pokaż kolejny cytat, ujrzą tekst pokazany na rysunku 10.19.
Rysunek 10.19. Strona ukazująca się po kliknięciu łącza Pokaż kolejny cytat
Jeśli goście klikną łącze Pokaż wszystkie cytaty, zobaczą stronę pokazaną na rysunku 10.20. Strona używa
tekstowego pliku szeregowania zawartości zawierającego te cytaty, jak to pokazano tutaj:
%% #2 // To jest komentarz
<B><FONT FACE="Arial,Helvetica,Univers,Zurich BT">
Rozdział 10 – Składniki ASP
326
Żyj tak, jak gdyby każdy dzień był twoim pierwszym i ostatnim dniem.
</FONT></B>
%% #3
<I><FONT FACE="Arial,Helvetica,Univers,Zurich BT">
Wspólnie, w pokoju i harmonii, ciche brzmienia szeptały całą noc.
</FONT></I>
%% #1 // Ten cytat ma najmniejszą wartość
<FONT FACE="Arial,Helvetica,Univers,Zurich BT">
Pewnego dnia tego wszystkiego nie będzie.
</FONT>
Rysunek 10.20. Strona ukazująca wszystkie cytaty
Pierwsza pozycja ma ranking 2. Jeśli dodamy do siebie wszystkie liczby rankingu, otrzymamy 6. Z wartością 2
— pierwsza pozycja ma 33 procent (dwie szóste) szans na pojawienie się w przeglądarce:
%% #2 // To jest komentarz
<B><FONT FACE="Arial,Helvetica,Univers,Zurich BT">
Żyj tak, jak gdyby każdy dzień był twoim pierwszym i ostatnim dniem.
</FONT></B>
Zauważ, że pozycja zawiera komentarz, a treść pozycji zajmuje więcej niż jeden wiersz.
Druga pozycja ma poziom 3, więc ma 50 % (trzy szóste) szans na wyświetlenie. Zauważ, że ta pozycja nie ma
komentarza:
%% #3
<I><FONT FACE="Arial,Helvetica,Univers,Zurich BT">
Wspólnie, w pokoju i harmonii, ciche brzmienia szeptały całą noc.
</FONT></I>
ASP – Kompendium programisty
327
Ostatnia pozycja ma poziom 1, powinna więc pojawiać się tylko jeden raz na sześć wyświetleń strony:
%% #1 // Ten cytat ma najmniejszą wartość
<FONT FACE="Arial,Helvetica,Univers,Zurich BT">
Pewnego dnia tego wszystkiego nie będzie.
</FONT>
Kod strony cytatu dnia wyświetla jedną lub wszystkie pozycje pliku, w zależności od tego, jakie łącze kliknął
gość. Pierwszy blok kodu strony tworzy składnik
Content Rotator
.
<%
Option Explicit
Dim objCR
Set objCR = Server.CreateObject("IISSample.ContentRotator")
%>
Kod rozpoczynamy w tradycyjny sposób — od instrukcji
Option Explicit
. Kiedy używasz tej instrukcji
pamiętaj, że musi być ona pierwszym wierszem kodu strony:
Option Explicit
Następnie tworzona jest zmienna
Content Rotator
:
Dim objCR
oraz jej kopia:
Set objCR = Server.CreateObject("IISSample.ContentRotator")
Kolejny blok kodowy pojawia się w tym miejscu strony, w którym ma wystąpić cytat, jest więc osadzony wraz
z HTML-em:
<%
If IsEmpty(Request.QueryString("Show")) Then
Response.Write objCR.ChooseContent("cr.txt")
Else
objCR.GetAllContent("cr.txt")
End If
%>
Dwa łącza u dołu strony odnoszą się do tej samej strony w celu wyświetlenia kolejnego cytatu. Różnią się
jednak pomiędzy sobą. Kiedy gość kliknie łącze wyświetlające na stronie wszystkie cytaty, parametr
przekazywany jest poprzez
QueryString
, dlatego wstępnie wyszukujemy następujące pole w zbiorze:
If IsEmpty(Request.QueryString("Show")) Then
Jeśli pole nie jest puste, należy wyświetlić jeden cytat:
Response.Write objCR.ChooseContent("cr.txt")
Rozdział 10 – Składniki ASP
328
W innym wypadku używamy metody
GetAllContent
w celu wpisania do przeglądarki wszystkich cytatów.
Zauważ, że nie realizujemy tego zadania przy użyciu metody
Write
. Nie ma takiej potrzeby, ponieważ metoda
GetAllContent
sama wpisuje treść wprost do przeglądarki:
Set MyInfo = Server.CreateObject("MSWC.MyInfo")
Else
objCR.GetAllContent("cr.txt")
End If
%>
Składnik MyInfo
We wcześniejszej części tego rozdziału przyjrzeliśmy się składnikowi
Counters
. Powiedzieliśmy sobie o jego
ogromnym zasięgu obejmującym wszystkie sesje oraz wszystkie aplikacje ASP twojego serwera. Wadą tego
składnika było jednak to, że zapamiętywał on tylko liczby. Chociaż składnik
MyInfo
nie dysponuje metodami
Increment
i
Remove
tak jak składnik
Counters
, to jednak pozwala na przechowywanie ciągów dostępnych w
obrębie serwera. Wartości te nie są tracone nawet po wyłączeniu serwera, ponieważ są przechowywane w pliku
poza IIS.
Składnik MyInfo złożony jest z właściwości, które tworzysz poprzez ustalenie ich wartości. Właściwości te są
następnie wyszukiwane przez określenie ich nazwy. Aby stworzyć składnik, użyj następującego wiersza kodu:
Do utworzenia składnika używamy metody
CreateObject
obiektu
Server
. Zmienna
MyInfo
staje się kopią
składnika o tej samej nazwie. Kiedy składnik jest już utworzony, możesz zacząć tworzyć i wykorzystywać
wybrane przez ciebie właściwości.
Na przykład:
<%
Option Explicit
Dim MyInfo
Set MyInfo = Server.CreateObject("MSWC.MyInfo")
MyInfo.CompanyName = "Firma ABC"
Response.Write "<B>" & MyInfo.CompanyName & "<P>"
%>
Na wstępie stwierdzamy, że będziemy deklarować nasze zmienne:
Option Explicit
Następnie deklarujemy zmienną
MyInfo
:
Dim MyInfo
i tworzymy jej kopię:
Set MyInfo = Server.CreateObject("MSWC.MyInfo")
Następnie tworzymy właściwość tego składnika o nazwie
CompanyName
i w tym samym wierszu kodu
ustawiamy jej wartość. Jeśli właściwość o tej nazwie już istnieje, jej wartość zostanie zastąpiona:
MyInfo.CompanyName = "Firma ABC"
ASP – Kompendium programisty
329
Wartość właściwości wpisywana jest do przeglądarki:
Response.Write "<B>" & MyInfo.CompanyName & "<P>"
Wyjście tego kodu pokazano na rysunku 10.21. Pamiętaj jednak, że właściwość ma ogromny zasięg, możemy
więc stworzyć również taką stronę, jaką pokazano poniżej, która znajduje się na naszym serwerze w zupełnie
innej aplikacji ASP.
<%
Option Explicit
Dim MyInfo
Set MyInfo = Server.CreateObject("MSWC.MyInfo")
Response.Write "<B>Ten tekst znajduje się w innej aplikacji ASP:" _
& MyInfo.CompanyName & "<P>"
%>
Tutaj właściwość wpisuje do przeglądarki tekst z innej aplikacji ASP, aby zademonstrować swój zasięg.
Wyjście kodu prezentuje rysunek 10.22.
Rysunek 10.21. Wyjście pierwszej strony używającej składnika
MyInfo
Rozdział 10 – Składniki ASP
330
Rysunek 10.22. Wyjście kodu wykorzystującego właściwość
CompanyName
strony znajdującej się w innej
aplikacji ASP