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.
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 T 525f58f ag 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.
Rysunek 4.1. Strona ASP ze znacznikiem podstawowym
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>
Wygląd strony przedstawia rysunek 4.2.
Rysunek 4.2. Strona zawierająca pojedynczą linię kodu ASP
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.
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:
Wyjściowa strona pokazana jest na rysunku 4.3.
Rysunek 4.3. Strona ASP używająca znacznika <Script>
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.
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
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()
// -->
</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
%>
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()
// -->
</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()
// -->
</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 zmienna TheRate w znacznikach skryptu została zastąpiona wartością , 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
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 %>
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.
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 jest prostym plikiem tekstowym zawierającym twój kod. Tak jak w przypadku każdej strony ASP, kod ma następującą strukturę:
<%
'blok kodu jest tutaj
%>
Kod objęty jest znacznikami <% i %>
Na przykład plik Include, zapisany jako FieldValidation.inc, zawiera procedurę, która sprawdza, czy wpisana data faktycznie jest datą i czy należy do określonego zakresu. Zawiera również procedurę sprawdzająca, czy dane pole jest polem liczbowym i czy liczba w nim jest zgodna z narzuconym zakresem. Wartości te są weryfikowane odpowiednio jako prawidłowa data urodzin oraz kod pocztowy.
<%
Function DateRange(DateToTest, StartDate, EndDate)
if not isdate(DateToTest) then
DateRange = 0
elseif cdate(DateToTest) < cdate(StartDate) or _
cdate(DateToTest) > cdate(EndDate) then
DateRange = 0
else
DateRange = -1
end if
End Function
Function NumberRange(FieldToTest, MinNumber, MaxNumber)
If Not IsNumeric(FieldToTest) Then
NumberRange = 0
ElseIf CSng(FieldToTest) < MinNumber Or _
CSng(FieldToTest) > MaxNumber Then
NumberRange = 0
Else
NumberRange = -1
End If
End Function
Function Birthdate(FieldToTest)
If Not IsDate(FieldToTest) Then
Birthdate = 0
ElseIf CDate(FieldToTest) > Date Then
Birthdate = 0
Else
Birthdate = -1
End If
End Function
Function ZipCode(FieldToTest)
If Len(FieldToTest) = 5 Then
If IsNumeric(FieldToTest) Then
ZipCode = -1
Else
ZipCode = 0
End If
ElseIf Len(FieldToTest) = 10 Then
If IsNumeric(Left(FieldToTest, 5)) And _
IsNumeric(Right(FieldToTest, 4)) Then
ZipCode = -1
Else
ZipCode = 0
End If
Else
ZipCode = 0
End If
End Function
%>
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
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.
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
'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
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.
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 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
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ą.
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")
Zauważ, że kiedy używamy wariantu do zapisania obiektu, korzystamy z instrukcji Set. Zostanie ona omówiona nieco dalej w tym rozdziale.
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
%>
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.
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
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 , 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:
<%
'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
%>
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
%>
Wynikiem powyższego kodu będzie wysłanie do przeglądarki cyfry . 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)
%>
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, 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>"
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ół . 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.
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:
<%
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ż:
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
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
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
%>
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.
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.
Rysunek 4.12. Wyjście ServerVariables
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
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.
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.
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.
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.
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)
%>
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 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)))
%>
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.
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
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
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.
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
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ą!"
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.
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.
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.
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.
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.
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.
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"
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
= "
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
= "
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
StringToChop
= "
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
= "
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
= "
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 _
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
= "
SearchString = "s"
Response.Write InstrRev(String2Search, SearchString)
%>
Wynikiem wykonania kodu będzie wysłanie do przeglądarki liczby 7, jest to bowiem pozycja pierwszego wystąpienia litery "s" w słowie Mississippi, patrząc od końca ciągu.
Jednak naprawdę użyteczne stają się te funkcje dopiero wtedy, gdy się je połączy. Zwróćmy uwagę na przykład procedury zatwierdzającej wprowadzony przez użytkownika adres poczty elektronicznej. Poniższy kod pokazuje, jak to można zrobić:
<%
Option Explicit
Dim TheAt
Dim TheDot
Dim FieldToTest
FieldToTest = "[email protected]"
If Len(FieldToTest) < 6 then
Response.Write "Adres e-mail jest nieprawidłowy!"
Else
TheAt = InStr(2, FieldToTest, "@")
If TheAt = 0 Then
Response.Write "Adres e-mail jest nieprawidłowy!"
Else
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:
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("
'początek przeszukiwania od pozycji 5
Response.Write
Replace("
'początek przeszukiwania od pozycji 1 i dwie zamiany
Response.Write
Replace("
'początek przeszukiwania od pozycji 4 i dwie zamiany
Response.Write
Replace("
'zwykła zamiana, ale znak nie został znaleziony
Response.Write
Replace("
'to samo, ale teraz porównywany jest tekst
Response.Write
Replace("
%>
Wyniki kodu są pokazane na rysunku 4.23.
Rysunek 4.23. Wyniki funkcji Replace
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.
Rysunek 4.24. Wyniki generowania liczb losowych
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
%>
Zauważ, że w tym przypadku wywołując WriteMessage oczekuje się jakiejś wartości, która mogłaby zostać wysłana do przeglądarki przy użyciu metody Write obiektu Response. Funkcja ma podobną strukturę do procedury sub. Rozpoczyna się kluczowym słowem Function, po którym określona zostaje nazwa funkcji. Następnie gdzieś w kodzie ustalasz zwracaną wartość funkcji poprzez umieszczenie w jakimś równaniu jej nazwy. Funkcja kończy się instrukcją End Function
Twoje procedury mogą również zawierać parametry. Przyjrzyj się poniższemu blokowi kodu, który zamienia blok zatwierdzający poprawność wprowadzonego adresu e-mail na funkcję.
<%
Option Explicit
Dim LocalTest
LocalTest = "[email protected]"
Response.Write ValidateEmailAddress(LocalTest)
%>
<%
Function ValidateEmailAddress(FieldToTest)
Dim TheAt
Dim TheDot
If Len(FieldToTest) < 6 then
ValidateEmailAddress = "Adres e-mail jest nieprawidłowy!"
Else
TheAt = InStr(2, FieldToTest, "@")
If TheAt = 0 Then
ValidateEmailAddress = "Adres e-mail jest nieprawidłowy!"
Else
TheDot = InStr(cint(TheAt) + 2, FieldToTest, ".")
If TheDot = 0 Then
ValidateEmailAddress = "Adres e-mail jest _ nieprawidłowy!"
ElseIf cint(TheDot) + 1 > Len(FieldToTest) Then
ValidateEmailAddress = "Adres e-mail jest _ nieprawidłowy!"
Else
ValidateEmailAddress = "Adres e-mail jest _ prawidłowy!"
End If
End If
End If
End Function
%>
Zauważ, że teraz funkcji przekazywany jest parametr w głównym bloku kodu:
Response.Write ValidateEmailAddress(LocalTest)
Ponadto zwróć uwagę na to, że funkcja wysyła wiadomość poprzez przypisanie jej nazwie zwracanej wartości.
|
