asp kompendium programisty UPEZGDJTT2X5DJTDXYAGESBVI24QY6E47OBFLXY

background image

Spis Treści

SPIS TREŚCI........................................................................................................................................................ 1
ROZDZIAŁ 1. TWORZENIE DYNAMICZNYCH APLIKACJI INTERNETOWYCH............................. 6

C

ZYM BYŁA SIEĆ

WWW ..................................................................................................................................... 6

Specyfikacja HTML 2 ..................................................................................................................................... 7
Specyfikacja HTML 3.2 .................................................................................................................................. 8
Specyfikacja HTML 4 ..................................................................................................................................... 8

Z

AWARTOŚĆ STATYCZNA A ZAWARTOŚĆ DYNAMICZNA

...................................................................................... 8

T

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

S

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

Współpraca z serwerem internetowym .................................................................................................... 28

N

IE TYLKO

IIS

SYSTEMU

NT ............................................................................................................................. 29

ROZDZIAŁ 2. SERWER IIS WIDZIANY Z PERSPEKTYWY TWÓRCY STRON................................ 30

C

ZYM JEST

IIS? ................................................................................................................................................. 30

O

TRZYMYWANIE KOPII

IIS ................................................................................................................................ 31

K

ONSOLA ZARZĄDZANIA

M

ICROSOFTU

............................................................................................................. 31

W

ŁAŚCIWOŚCI USŁUG

WWW ........................................................................................................................... 33

Właściwości witryny WWW .......................................................................................................................... 34
Właściwości związane z wydajnością........................................................................................................... 36
Właściwości filtrów ISAPI............................................................................................................................ 36
Właściwości katalogu macierzystego ........................................................................................................... 37
Dokumenty.................................................................................................................................................... 38
Błędy klienta ................................................................................................................................................. 39

W

ITRYNY

WWW

W SERWERZE

IIS ................................................................................................................... 40

D

ODAWANIE WITRYNY

WWW.......................................................................................................................... 42

W

ŁAŚCIWOŚCI WITRYNY

WWW ....................................................................................................................... 45

Wiele witryn pod jednym adresem IP........................................................................................................... 45
Zakładka właściwości witryny WWW........................................................................................................... 47
Właściwości katalogu macierzystego ........................................................................................................... 48

E

KSPLORACJA WITRYNY

.................................................................................................................................... 48

Katalogi wirtualne........................................................................................................................................ 49
Właściwości folderu i pliku .......................................................................................................................... 51

A

PLIKACJE

ASP ................................................................................................................................................ 52

Zmienne trwałe i zakresowe ......................................................................................................................... 52
Zdarzenia...................................................................................................................................................... 53
Tworzenie aplikacji ASP............................................................................................................................... 53
Konfigurowanie aplikacji ASP ..................................................................................................................... 55

background image

Spis Treści

2

W

ITRYNY

FTP................................................................................................................................................... 57

ROZDZIAŁ 3. NARZĘDZIA PRACY............................................................................................................. 60

P

RZEGLĄD APLIKACJI DO TWORZENIA STRON

.................................................................................................... 60

N

OTATNIK

......................................................................................................................................................... 60

F

RONT

P

AGE

2000.............................................................................................................................................. 62

Środowisko pracy ......................................................................................................................................... 62
Tworzenie sieci Web..................................................................................................................................... 68
Przeglądanie strony...................................................................................................................................... 70
Dodawanie strony......................................................................................................................................... 71
Praca ze stroną............................................................................................................................................. 72

N

ET

O

BJECTS

F

USION

......................................................................................................................................... 74

Środowisko pracy ......................................................................................................................................... 74
Tworzenie witryny WWW przy użyciu programu Fusion ............................................................................. 80
Praca ze stroną............................................................................................................................................. 80

N

ET

O

BJECTS

S

CRIPT

B

UILDER

........................................................................................................................... 81

Środowisko programowe .............................................................................................................................. 81
Praca z kodem w programie ScriptBuilder .................................................................................................. 87
Weryfikacja kodu w programie ScriptBuilder.............................................................................................. 92

M

ICROSOFT

V

ISUAL

I

NTER

D

EV

6.0................................................................................................................... 94

O

STATNIE SŁOWO O NARZĘDZIACH

.................................................................................................................... 96

ROZDZIAŁ 4. PODSTAWY ASP .................................................................................................................... 97

K

ONSTRUKCJA KODU

ASP................................................................................................................................. 97

Znacznik <% = X %> .................................................................................................................................. 97
<% Pojedyncza linia kodu %> .................................................................................................................... 98
<% Blok kodu %>........................................................................................................................................ 99
< Script> Kod </Script> ........................................................................................................................... 100
HTML w kodzie .......................................................................................................................................... 101

S

KRYPT W SKRYPCIE

........................................................................................................................................ 103

Dyrektywa przetwarzania........................................................................................................................... 105
Pliki Include ............................................................................................................................................... 106

Po co ich używać .................................................................................................................................... 106
Włączanie pliku...................................................................................................................................... 106
Plik Include — struktura i przykład ....................................................................................................... 106
Wywoływanie procedur.......................................................................................................................... 108

K

OD

ASP

W UŻYCIU

........................................................................................................................................ 108

Komentarze, puste miejsca i wielkość liter................................................................................................. 108
Zmienne ...................................................................................................................................................... 111
Typy danych................................................................................................................................................ 112
Zakres i trwałość ........................................................................................................................................ 113
Operatory ................................................................................................................................................... 114
Warunki ...................................................................................................................................................... 116
Pętle............................................................................................................................................................ 121
Konwersja zmiennych................................................................................................................................. 125
Funkcje daty i czasu ................................................................................................................................... 127
Zatwierdzanie obecności i typów danych................................................................................................... 131
Techniki zatwierdzania danych .................................................................................................................. 133
Formatowanie liczb, dat i kwot pieniężnych .............................................................................................. 135
Operowanie ciągami .................................................................................................................................. 139
Liczby losowe ............................................................................................................................................. 145
Procedury ................................................................................................................................................... 146

ROZDZIAŁ 5. OBIEKT REQUEST.............................................................................................................. 148

H

IERARCHIA I MODELE OBIEKTÓW

ASP .......................................................................................................... 148

background image

ASP – Kompendium programisty

3

Czym są hierarchie obiektów? ................................................................................................................... 148
Model obiektów ASP................................................................................................................................... 149

O

DBIERANIE INFORMACJI OD ODWIEDZAJĄCEGO

............................................................................................. 151

Zbiory obiektu Request............................................................................................................................... 151

Zbiór Form ............................................................................................................................................. 151
Zbiór QueryString .................................................................................................................................. 154
Zbiór ServerVariables ............................................................................................................................ 157
Zbiór Cookies ......................................................................................................................................... 159
Zbiór ClientCertificate............................................................................................................................ 160

W

ŁAŚCIWOŚĆ OBIEKTU

R

EQUEST

.................................................................................................................... 161

Właściwość TotalBytes ............................................................................................................................... 161

M

ETODA OBIEKTU

R

EQUEST

........................................................................................................................... 162

Metoda BinaryRead.................................................................................................................................... 162

O

BIEKT

R

EQUEST W DZIAŁANIU

...................................................................................................................... 163

Przykład certyfikatu klienta........................................................................................................................ 163
Procesor e-mail dla formularza ................................................................................................................. 168
Procesor bazy danych dla formularza........................................................................................................ 172
Witryna logowania ..................................................................................................................................... 174

ROZDZIAŁ 6. OBIEKT RESPONSE............................................................................................................ 180

W

YSYŁANIE INFORMACJI DO GOŚCI

................................................................................................................. 180

Z

BIÓR OBIEKTU

R

ESPONSE

.............................................................................................................................. 180

Zbiór cookie................................................................................................................................................ 181

W

ŁAŚCIWOŚCI OBIEKTU

R

ESPONSE

................................................................................................................. 184

Właściwość Buffer ...................................................................................................................................... 184
Właściwość CacheControl ......................................................................................................................... 186
Właściwość Charset.................................................................................................................................... 186
Właściwość ContentType............................................................................................................................ 186
Właściwość Expires.................................................................................................................................... 187
Właściwość ExpiresAbsolute...................................................................................................................... 188
Właściwość IsClientConnected .................................................................................................................. 190
Właściwość PICS........................................................................................................................................ 191
Właściwość Status ...................................................................................................................................... 192

M

ETODY OBIEKTU

R

ESPONSE

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

O

BIEKT

R

ESPONSE W DZIAŁANIU

..................................................................................................................... 199

Readresowanie i obiekt wyboru ................................................................................................................. 199
Pasek zaawansowania................................................................................................................................ 203
Strona preferencji....................................................................................................................................... 207

ROZDZIAŁ 7. OBIEKT SERVER................................................................................................................. 212

W

EJŚCIE NA SZCZYT

........................................................................................................................................ 212

W

ŁAŚCIWOŚĆ OBIEKTU

S

ERVER

...................................................................................................................... 212

Właściwość ScriptTimeout ......................................................................................................................... 213

M

ETODY OBIEKTU

S

ERVER

.............................................................................................................................. 214

Metoda CreateObject ................................................................................................................................. 215
Metoda HTMLEncode ................................................................................................................................ 218
Metoda MapPath........................................................................................................................................ 219

background image

Spis Treści

4

Metoda URLEncode ................................................................................................................................... 221

O

BIEKT

S

ERVER W DZIAŁANIU

........................................................................................................................ 222

Automatyzacja biura................................................................................................................................... 222

ROZDZIAŁ 8. OBIEKT SESSION, OBIEKT APPLICATION ORAZ PLIK GLOBAL.ASA............... 232

A

PLIKACJE

ASP .............................................................................................................................................. 232

T

WORZENIE APLIKACJI

ASP ............................................................................................................................ 233

O

BIEKT

S

ESSION

.............................................................................................................................................. 235

Zbiory obiektu Session................................................................................................................................ 235

Zbiór Contents........................................................................................................................................ 235
Zbiór StaticObjects................................................................................................................................. 239

Właściwości obiektu Session ...................................................................................................................... 240

Właściwość CodePage............................................................................................................................ 241
Właściwość LCID .................................................................................................................................. 242
Właściwość SessionID ........................................................................................................................... 244
Właściwość TimeOut ............................................................................................................................. 244

Metoda obiektu Session .............................................................................................................................. 245

Metoda Abandon .................................................................................................................................... 245

O

BIEKT

A

PPLICATION

...................................................................................................................................... 246

Zbiory obiektu Application......................................................................................................................... 246

Zbiór Contents........................................................................................................................................ 246
Zbiór StaticObjects................................................................................................................................. 250

Metody obiektu Application........................................................................................................................ 251

Metoda Lock........................................................................................................................................... 251
Metoda Unlock ....................................................................................................................................... 253

P

LIK GLOBAL

.

ASA

............................................................................................................................................ 253

Zdarzenia pliku global.asa ......................................................................................................................... 255

Zdarzenie Application_OnStart.............................................................................................................. 255
Zdarzenie Application_OnEnd............................................................................................................... 259
Zdarzenie Session_OnStart .................................................................................................................... 259
Zdarzenie Session_OnEnd ..................................................................................................................... 261
Deklaracje obiektów w pliku global.asa................................................................................................. 263

A

PLIKACJE

ASP

W UŻYCIU

.............................................................................................................................. 263

ROZDZIAŁ 9. OBIEKTY CDO DLA WINDOWS NT SERVER .............................................................. 266

U

ZUPEŁNIENIE STRONY

ASP

O FUNKCJĘ WYSYŁANIA WIADOMOŚCI E

-

MAIL

................................................... 266

O

BIEKT

N

EW

M

AIL

.......................................................................................................................................... 267

Właściwości obiektu NewMail.................................................................................................................... 268

Właściwość To ....................................................................................................................................... 268
Właściwość From ................................................................................................................................... 269
Właściwość Subject................................................................................................................................ 270
Właściwość Body ................................................................................................................................... 270
Właściwość CC ...................................................................................................................................... 273
Właściwość BCC.................................................................................................................................... 273
Właściwość Importance.......................................................................................................................... 274
Właściwości BodyFormat i MailFormat ................................................................................................ 275
Właściwości ContentBase i ContentLocation ........................................................................................ 278
Właściwość Value .................................................................................................................................. 279
Właściwość Version ............................................................................................................................... 280

Metody obiektu NewMail............................................................................................................................ 281

Metoda Send........................................................................................................................................... 281
Metoda AttachFile.................................................................................................................................. 282
Metoda AttachURL ................................................................................................................................ 284
Metoda SetLocaleID............................................................................................................................... 285

O

BIEKT

N

EW

M

AIL W DZIAŁANIU

.................................................................................................................... 285

background image

ASP – Kompendium programisty

5

ROZDZIAŁ 10. SKŁADNIKI ASP ................................................................................................................ 287

O

BIEKTY ZWIĘKSZAJĄCE MOŻLIWOŚCI STRON

ASP......................................................................................... 287

S

KŁADNIK

B

ROWSER

C

APABILITIES

................................................................................................................ 287

Modyfikacja pliku browser.ini.................................................................................................................... 295

S

KŁADNIK

A

D

R

OTATOR

................................................................................................................................. 296

S

KŁADNIK

P

AGE

C

OUNTER

.............................................................................................................................. 303

S

KŁADNIK

C

OUNTERS

..................................................................................................................................... 311

S

KŁADNIK

C

ONTENT

L

INKING

......................................................................................................................... 316

S

KŁADNIK

C

ONTENT

R

OTATOR

....................................................................................................................... 324

S

KŁADNIK

M

Y

I

NFO

......................................................................................................................................... 328

background image

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

background image

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.

background image

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.

background image

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

%>

background image

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

background image

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"

background image

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)

background image

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.

background image

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

background image

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

<%

background image

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.

background image

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.

background image

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

background image

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

background image

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.

background image

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.

background image

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

background image

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).

background image

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

background image

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

background image

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

background image

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)

background image

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.

background image

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.

background image

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.

background image

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.

background image

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

background image

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.

background image

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

background image

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)

background image

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ń

background image

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.

background image

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.

background image

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.

background image

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.

background image

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

background image

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

background image

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.

background image

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.

background image

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.

background image

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.

background image

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.

background image

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.

background image

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.

background image

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.

background image

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

background image

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ż

background image

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.

background image

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

background image

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.

background image

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ą

background image

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

background image

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.

background image

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.

background image

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>

background image

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.

background image

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.

background image

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

background image

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.

background image

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.

background image

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.

background image

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

background image

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.

background image

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

background image

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ą

background image

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.

background image

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).

background image

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

background image

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.

background image

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.

background image

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).

background image

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.

background image

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.

background image

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.

background image

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

background image

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.

background image

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.

background image

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.

background image

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

background image

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

background image

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.

background image

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

background image

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.

background image

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).

background image

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.

background image

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.

background image

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

background image

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 %>"

background image

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.

background image

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.

background image

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.

background image

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.

background image

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>

background image

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.

background image

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.

background image

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.

background image

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

background image

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

background image

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

background image

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

background image

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ę:

background image

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

background image

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

background image

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

background image

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.

background image

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

background image

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")

background image

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

%>

background image

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:

background image

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

%>

background image

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,

background image

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

background image

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.

background image

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:

background image

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ż:

background image

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

background image

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

%>

background image

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.

background image

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.

background image

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

.

background image

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.

background image

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.

background image

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.

background image

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)

background image

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

background image

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

background image

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

background image

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

background image

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ą!"

background image

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.

background image

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.

background image

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.

background image

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.

background image

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"

.

background image

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

background image

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 _

background image

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

background image

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:

background image

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.

background image

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.

background image

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

background image

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.

background image

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

background image

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

background image

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

background image

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>

background image

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

background image

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

background image

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

background image

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.

background image

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

background image

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.

background image

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

background image

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: " _

background image

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

background image

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>

background image

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)

background image

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.

background image

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.

background image

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

background image

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

background image

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"))

background image

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"

background image

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.

background image

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

background image

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

background image

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

background image

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:

background image

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.

background image

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.

background image

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"

background image

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:

background image

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"

background image

ASP – Kompendium programisty

179

a odwiedzający jest odsyłany do strony powitania.

response.redirect "./welcomeback.asp"

background image

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.

background image

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.

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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.

background image

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

background image

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)

background image

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

background image

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).

background image

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.

background image

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

background image

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

background image

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)

background image

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"

background image

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.

background image

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

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.

background image

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.

background image

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.

background image

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

background image

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

E-mail

mailto:jsmith@whatever.com


Zwróć uwagę na pozycję

E-mail

, 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

background image

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

background image

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

background image

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

background image

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

background image

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.

background image

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"

background image

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:

background image

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:

background image

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 %>">

background image

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.

background image

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.

background image

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.

background image

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.

background image

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")

background image

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")

background image

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.

background image

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&lt;B<P>B. P&gt;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.

background image

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

background image

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

background image

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

background image

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.

background image

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

background image

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 _

background image

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"

background image

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"

background image

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

background image

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"

background image

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"

background image

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

background image

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.

background image

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

background image

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

background image

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"

%>

background image

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.

background image

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.

background image

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

%>

background image

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

%>

background image

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

background image

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

background image

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

background image

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.

background image

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.

background image

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ę:

background image

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ą

background image

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

background image

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")

background image

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.

background image

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

:

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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:

background image

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

%>

background image

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>

background image

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

background image

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

background image

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

background image

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 _

background image

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")

background image

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

background image

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ń

background image

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.

background image

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

background image

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"

background image

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."

background image

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"

background image

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

background image

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.

background image

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:

background image

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.

background image

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>" _

background image

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>" _

background image

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.

background image

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.

background image

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!"

background image

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

%>

background image

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

background image

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

background image

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.

background image

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"

background image

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ć

background image

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.

background image

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")

background image

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

background image

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

background image

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

background image

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

background image

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

background image

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:

background image

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:

background image

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

background image

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

background image

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

background image

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.

background image

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") & "')"

background image

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.

background image

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

:

background image

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ęć."

background image

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

background image

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.

background image

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

background image

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

background image

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

background image

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

%>

background image

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:

background image

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"

background image

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:

background image

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ę:

background image

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"

background image

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

background image

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")

background image

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:

background image

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)

background image

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ę:

background image

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

background image

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.

background image

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:

background image

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

%>

background image

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>

background image

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).

background image

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

background image

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>

background image

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")

background image

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"

background image

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

background image

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


Wyszukiwarka

Podobne podstrony:
ASP Kompendium programisty (6)
ASP Kompendium programisty (2)
ASP Kompendium programisty (5)
ASP Kompendium programisty aspkom
ASP Kompendium programisty aspkom
ASP Kompendium programisty
ASP Kompendium programisty aspkom
ASP Kompendium programisty aspkom
ASP Kompendium programisty aspkom
Delphi 2005 Kompendium programisty
C Builder Kompendium programisty cbu6kp
Macromedia Flash MX Kompendium programisty flmxkp
helion flash 5 kompendium programisty ZVEA5N62Z5AZAXW4EBJIHJVAARCWDTRWXXYBDKY
Java Kompendium programisty
Flash 5 Kompendium programisty fla5kp
ASP 003, Programowanie
C++Builder Kompendium programisty

więcej podobnych podstron