Introduzione alla programmazione ASP

Transcript

Appunti a cura del Prof. G.Tombolini
La programmazione Web – Programmazione ASP
La programmazione Web
4-Introduzione al Server Side Scripting ASP
L'ASP è un ottimo strumento per la creazione di pagine web dinamiche, è una tecnologia introdotta da Microsoft e ci dà
la possibilità di scrivere codice con le funzionalità di un linguaggio di programmazione che genera l'HTML per le
nostre pagine web in modo appunto dinamico.
Il codice viene interpretato dal server quindi non siamo di fronte al solito problema di compatibilità con i diversi client
che possono visualizzare le nostre pagine in quanto viene restituito al client solo normale codice HTML.
Il primo annuncio di Microsoft riguardante le ASP venne fatto il 16 Luglio del 1996 e la prima versione beta venne
rilasciata nel novembre del 1996; la versione 1.0 ufficiale si ebbe il 12 dicembre dello stesso anno e da allora l'utilizzo
di tale tecnologia è aumentato esponenzialmente.
Si possono usare vari linguaggi di programmazione per la creazione di pagine ASP; il più diffuso è sicuramente il
VBScript (con sintassi simile al Visual Basic), seguito dal JScript (simile al JavaScript) ma anche altri linguaggi come il
PerlScript (simile a Perl) o Python possono essere utilizzati a patto di avere un server in grado di elaborare il codice e
restituire l'HTML necessario. Si parla quindi di linguaggi di scripting e una pagina Web contenente tale codice viene
chiamata script.
NOTA
Si tenga ben presente che lo scripting lato server viene elaborato interamente dal server che restituisce al browser
codice HTML. Lo scripting lato client invece viene interpretato dal browser del client ed è per questo motivo che si
preferisce l'utilizzo del linguaggio JavaScript in quanto Netscape supporta unicamente questo tipo di linguaggio per lo
scripting lato client.
4.1) Modello client-server
Quando un client fa una richiesta ad un server per ottenere una pagina con estensione .htm o .html, vengono eseguiti
questi passaggi:
1) Il client richiede una pagina Web al server
2) Il server invia la pagina Web al client sotto forma di
linguaggio HTML
3) Il browser del client interpreta l'HTML ricevuto e
visualizza la pagina
Quando invece si tratta di una pagina con estensione .asp
allora i passaggi sono:
1) Il client richiede una pagina Web al server
2) Il server elabora il codice interno alla pagina e
sostituisce l'ASP con normale HTML
3) Il server invia la pagina Web al client sotto forma di linguaggio HTML
4) Il browser del client interpreta l'HTML ricevuto e visualizza la pagina
4.2) Struttura di uno script ASP
1.
2.
3.
4.
5.
6.
<%@ language="VBSCRIPT" %>
<html>
<body>
Sono le ore <% Response.Write Time() %>
</body>
</html>
Si noti che il codice ASP è racchiuso fra i caratteri <% e %>. La direttiva @ language (riga 1) serve per specificare il
tipo di linguaggio che verrà utilizzato all'interno della pagina. Se non viene specificato nessun linguaggio allora il server
darà per scontato che si utilizzerà il linguaggio impostato sul server stesso che di default per i Web Server Microsoft è il
1
VBScript. Alla riga 4 troviamo un'altra istruzione ASP che tramite l'oggetto Response e il metodo Write fa sì che
all'interno della pagina venga visualizzato l'orario corrente tramite la funzione Time().
Un altro modo per inserire uno script ASP che giri lato server è il seguente ma potrebbe non funzionare come ci si
aspetta; vediamo il codice.
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
<html>
<body>
<h3>Data odierna</h3>
Oggi è
<script language="vbscript" runat="server">
Response.Write Date()
</script>
e questo è un esempio di ASP script.
</body>
</html>
Il problema è che la data (tramite la funzione Date() di riga 6) viene visualizzata alla fine della pagina in quanto il
server esegue a tutti gli effetti lo scripting nel modo corretto ma accoda l'HTML risultante alla fine dello stream HTML.
In altre parole non tiene conto della posizione in cui lo script è stato inserito relativamente agli altri elementi interni alla
pagina. Se si visualizza il codice HTML risultante infatti, ci si accorge che la data viene scritta dopo l'ultimo tag HTML
della pagina ovvero dopo </html>.
4.2) Variabili
Uno dei concetti più importanti in tutti i linguaggi di programmazione è la possibilità di immagazzinare informazioni.
Supponiamo che ad un utente venga richiesto di fornire il proprio nome: dove memorizziamo questa informazione in
modo che possa essere riutilizzata in seguito? Come immagazziniamo altri tipi di dati come numeri o date? Ed infine,
come fa il computer a sapere a quale utente appartengono determinate informazioni che l'utente stesso ci ha dato? Tutto
questo può essere fatto utilizzando le variabili.
Una variabile è una sezione di memoria che viene allocata dal programmatore tramite un nome. Potete pensare alle
variabili come a tante scatole. Sono semplicemente contenitori per le informazioni che volete memorizzare. Ecco un
esempio di tre variabili:
1.
2.
3.
4.
5.
6.
7.
8.
<%
Dim NomeDiPersona
Dim Eta
Dim DataDiNascita
NomeDiPersona = "Giovanni"
Eta = 33
DataDiNascita = #09/02/1968#
%>
Come si può immaginare è sufficiente utilizzare l'istruzione Dim seguita dal nome della variabile per la dichiarazione e
successivamente assegnare alla variabile un valore. C'è anche un modo più veloce per dichiarare più di una variabile
con una sola istruzione Dim sostituendo nel codice precedente, alle righe 2, 3 e 4, la riga seguente:
Dim NomeDiPersona, Eta, DataDiNascita
Nella maggior parte dei linguaggi di programmazione, è cosa comune specificare un tipo di dati per una variabile, in
modo che il sistema sappia con che tipo di variabile ha a che fare. In VBScript invece tutte le variabili sono
memorizzate in un unico tipo detto variant. Il variant è un tipo di variabile speciale che può contenere qualsiasi tipo di
dato senza che esso sia specificato a priori. Nel momento in cui la variabile viene letta, VBScript le assegnerà da solo
un particolare tipo, a seconda dei dati e del contesto. Ci sono un paio di controindicazioni; una perdita di performance e
qualche volta il fatto che VBScript non assegni alla variabile il tipo che ci aspettiamo. VBScript assegna un subtipo al
variant che ricorda il tipo di dati che sono stati memorizzati.
4.3) Subtipi Numerici
Integer
Numeri interi con un range che va da -32.768 a +32.767
Byte
2
I byte sono interi con un range che va da 0 a 255.
Long
Simile all'Integer ma con un range che va da -2.147.483.648 a +2.147.483.647.
Single
Numeri in virgola mobile a precisione singola con range da -3,402823E38 a -1,401298E-45 (per i valori negativi) e da
1,40298E-45 a 3,402823E38 (per i valori positivi)
Double
Numeri in virgola mobile a precisione doppia con range da -1,79769313486232E308 a -4,94065645841247E-324 (per i
valori negativi) e da 4,94065645841247E-324 a 1,79769313486232E308 (per i valori positivi)
Currency
Numeri con al massimo 4 cifre per i valori decimali con range da -922.377.203.685.477,5808 a +
922.377.203.685.477,5807.
Subtipo Stringa
I variant con subtipo stringa possono contenere qualunque informazione testuale, tipo parole e/o numeri.
Subtipo Data
Subtipo che viene usato per contenere dati di tipo data e orario.
Subtipo Booleano
Subtipo che può contenere uno di due valori, solitamente TRUE o FALSE (vero o falso). In VBScript, se si convertono
questi valori in Integer, allora assumono i valori -1 e 0 rispettivamente.
Subtipi Speciali
Empty
I variant empty sono variabili alle quali non è ancora stato assegnato un valore (conosciute come variabili non
inizializzate).
Null
Null è un subtipo inusuale che viene utilizzato in concomitanza con i database, quando si parla di campi che non
contengono dati.
Object
Il subtipo object si riferisce agli oggetti.
Error
Il subtipo error è usato molto raramente. Se ne sconsiglia l'uso perché non esistono funzioni di conversione che
permettono di creare o convertire variant di subtipo error.
4.4) Nomi di variabili
Se abbiamo molte variabili in un programma, abbiamo bisogno di sapere che tipo di dati contengono, quindi conviene
dare nomi alle variabili che ci possano aiutare a capirne il contenuto. Ecco una tabella riassuntiva delle convenzioni
usate:
Tipo di dati
Prefisso
Esempio
Boolean
bln o bol
blnMember o bolMember
Byte
byt
bytByte
Date/Time
dat
datToday
Double
dbl
dblDouble
Error
err
errError
Integer
int
intSalary
Long
lng
lngLong
Object
obj
objConn
Single
sng
sngSingle
3
String
str
strTextBox
Per evitare di compiere errori di battitura senza ricevere errori, è buona norma utilizzare l'istruzione Option Explicit che
obbliga a dichiarare esplicitamente tutte le variabili.
1.
2.
3.
4.
5.
6.
7.
8.
<%
Option Explicit
Dim intBase, intAltezza, intAreaTriangolo
intBase = 10
intAltezza = 15
intAreaTriangolo = (intBase * intAlteza) / 2
Response.Write intAreaTriangolo
%>
In questo caso si genera un errore di variabile non definita 'intAlteza' alla riga 6 mentre senza l'Option Explicit l'area del
triangolo sarebbe stata di 0 e non si sarebbe generato nessun errore.
Per sapere il subtipo di una variabile, si può utilizzare la funzione TypeName in questo modo
<%
Dim miaVariabile
miaVariabile = 5
Response.Write TypeName(miaVariabile)
%>
4.5) Array
Un array di variabili è una sequenza di variabili, aventi il medesimo nome, contraddistinte da un indice. Gli array sono
usati spesso per raggruppare tipi di dati simili ma anche in molte altre occasioni. Segue un esempio:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
<%
Dim arrGiorni(6), intIndex
arrGiorni(0) = "Domenica"
arrGiorni(1) = "Lunedì"
arrGiorni(2) = "Martedì"
arrGiorni(3) = "Mercoledì"
arrGiorni(4) = "Giovedì"
arrGiorni(5) = "Venerdì"
arrGiorni(6) = "Sabato"
intIndex = 3
Response.Write arrGiorni(intIndex)
%>
Tramite la funzione Array si può dichiarare più velocemente un array di variabili.
1.
2.
3.
4.
<%
Dim arrGiorni
arrGiorni = Array("Domenica", "Lunedì", "Martedì", "Mercoledì", "Giovedì", "Venerdì", "Sabato")
%>
4.6) Costanti
Le costanti sono come le variabili ad eccezione del fatto che, una volta che è stato assegnato un valore, non possono
cambiare. Per convenzione i nomi delle costanti sono scritti in maiuscolo, per la loro dichiarazione si utilizza
l'istruzione Const.
<%
Const ZEROASSOLUTO = -273
%>
4.7) Operatori
Gli operatori consentono di lavorare con i dati, modificandoli o sostituendoli. Vi sono 4 categorie principali di
operatori.
4
4.7.1) Operatori di assegnazione
Usato spesso per assegnare un valore ad una variabile. Tale operatore è il segno di uguale (=) e fa sì che il valore che si
trova alla sua destra venga memorizzato nella variabile alla sua sinistra.
1.
2.
3.
4.
5.
6.
<%
Dim intNumber, intOldNumber
intNumber = 5
intOldNumber = intNumber
intNumber = 4
%>
4.7.2) Operatori matematici
Fanno parte di questa categoria di operatori l'addizione, la sottrazione, la moltiplicazione, la divisione, il modulo,
l'elevamento a potenza, la negazione e la concatenazione.
1. <%
2. Dim intBase, intAltezza, intAreaRettangolo, intSemiAreaRettangolo
3. intBase = 5
4. intAltezza = 10
5. intSemiperimetro = intBase + intAltezza
6. intPerimetro = intBase + intBase + intAltezza + intAltezza
7. intSemiperimetro = intPerimetro - intBase - intAltezza
8. intAreaRettangolo = intBase * intAltezza
9. intSemiAreaRettangolo = (intBase * intAltezza) / 2
10. %>
Esiste un altro tipo di divisione per la quale si utilizza il carattere di backslash \ che restituisce un numero intero che
indica quante volte è contenuto un numero in un altro.
5 \ 3 dà 1
4 \ 2 dà 2
0 \ 8 dà 0
Il modulo (Mod) invece restituisce il resto di una divisione.
5 Mod 3 dà 2
4 Mod 2 dà 0
0 Mod 8 dà 8
L'elevamento a potenza è indicato dal carattere ^.
3^2 = 9
3^3 = 27
3^4 = 81
2^3^2 = 8^2 = 64
La negazione utilizza lo stesso simbolo della sottrazione - e serve per convertire un numero positivo in negativo e
viceversa. Equivale insomma a moltiplicare per -1 il valore in questione.
L'operatore di concatenazione (&) ci permette di unire più stringhe fra loro.
<%
Dim strNome, strCognome
strNome = "Giovanni"
strCognome = "Acerbi"
Response.Write "Il mio nome è " & strNome & " e il mio cognome è " & strCognome
%>
4.7.3) Operatori di confronto
Gli operatori di confronto effettuano confronti tra due argomenti e forniscono come risultato TRUE o FALSE.
Operatore
TRUE quando...
FALSE quando...
A=B
A è uguale a B
A è diverso da B
5
A>B
A è maggiore di B
A è minore o uguale a B
A= B
A è maggiore o uguale a B
A è minore di B
A <= B
A è minore o uguale a B
A è maggiore di B
A <> B
A è diverso da B
A è uguale a B
4.7.4) Operatori di logici
Questo gruppo di operatori permette di compiere operazioni fra valori booleani (TRUE o FALSE) restituendo un
risultato anch'esso booleano.
Operatore
TRUE quando...
FALSE quando...
A And B
A e B sono True
Almeno uno tra A e B è False
A Or B
Almeno uno tra A e B è True
A e B sono False
Not A
A è False
A è True
A Xor B
A o B è True ma non entrambi
A e B sono entrambi True o False
A Eqv B
A e B sono entrambi True o False
A o B è True ma non entrambi
A Imp B
A è False o B è True
A è True o B è False
4.8) Strutture di controllo
Una struttura di controllo è una serie di istruzioni che permette di controllare il flusso dei dati all'interno del codice. Ve
ne sono tre tipi principali che sono definiti di logica condizionale, logica ciclica e logica ramificata.
4.8.1) Struttura IF
La logica condizionale verifica una condizione o una serie di condizioni e, in base ai risultati, sceglie il codice da
eseguire. La più utilizzata è senz'altro l'istruzione If... Then. Ha il seguente aspetto:
If condizione/i Then
codice da eseguire
End If
1. <%
2. If Hour(Now()) >= 0 And Hour(Now()) < 8 Then
3. Response.Write "E' ancora notte fonda!!!"
4. End If
5. %>
Una variante è data dall'istruzione If... Then... Else che permette di eseguire altro codice se la prima condizione è falsa.
Ecco come si presenta:
codice da eseguire
Else
codice alternativo da eseguire
End If
5. <%
6. If Hour(Now()) >= 0 And Hour(Now()) < 8 Then
7. Response.Write "E' ancora notte fonda."
6
8.
9.
10.
11.
Else
Response.Write "E' giorno o sera."
End If
%>
Notare che è possibile nidificare svariate istruzioni If... Then... Else una dentro l'altra ottenendo una struttura di questo
tipo:
If altra/e condizione/i Then
codice da eseguire
Else
altro codice da eseguire
End If
Else
End If
Un'altra variante che permette di semplificare due o più istruzioni If... Then comuni annidate si ottiene con l'uso della
istruzione Elseif in questo modo:
codice da eseguire
Elseif condizione/i Then
End If
Può essere presente più di una istruzione Elseif; basti ricordare che solitamente si conclude con una istruzione Else e
che dopo l'istruzione Else non può essere presente un'ulteriore istruzione Elseif.
1.
2.
3.
4.
5.
6.
7.
8.
9.
<%
If Hour(Now()) >= 0 And Hour(Now()) < 8 Then
Response.Write "E' ancora notte fonda."
Elseif Hour(Now()) >= 8 And Hour(Now()) < 19 Then
Response.Write "E' giorno"
Else
Response.Write "E' sera."
End If
%>
La seconda struttura che fa parte della logica condizionale è la Select Case che si utilizza di solito quando le opzioni da
controllare sono molte e sarebbe scomodo utilizzare l'istruzione If... Then... tradizionale. Si presenta così:
4.8.2) Struttura SELECT … CASE
Select Case variabile
Case opzioneA
codiceA
Case opzioneB
codiceB
Case Else
codiceC
End Select
La parte finale, cioè il Case Else non è obbligatoria ma di solito si lascia per eventuali valori che non sono stati
erroneamente previsti. Segue un esempio:
1.
2.
<%
Dim intTemperatura, strTesto
7
3. intTemperatura = 25
4. Select Case intTemperatura
5. Case 0,1,2,3,4,5,6,7,8,9
6. strTesto = "fredda"
7. Case 10,11,12,13,14,15,16,17,18,19
8. strTesto = "temperata"
9. Case 20,21,22,23,24,25,26,27,28,29
10. strTesto = "calda"
11. Case Else
12. strTesto = "freddissima o caldissima"
13. End Select
14. %>
Oggi è una giornata <% = strTesto %>.
4.8.3) Struttura FOR
La logica ciclica esegue ripetutamente un blocco di codice fino al momento in cui vengono soddisfatte alcune
condizioni oppure mentre si verifica se alcune condizioni sono vere. Vi sono due strutture principali che sono la Do
While e la For... Next. La prima solitamente viene usata quando non si sa il numero preciso di cicli da compiere mentre
la seconda si usa di solito quando si sa esattamente quante volte un ciclo deve essere effettuato.
Il ciclo For... Next si presenta così:
For contatore = valoreIniziale To valoreFinale Step incremento
codice da eseguire
Next
Se l'incremento è in positivo di un numero alla volta, la parte finale, in questo caso Step 1, si può omettere come
nell'esempio che segue:
1. <%
2. For intCont = 1 To 10
3. Response.Write "Numero " & intCont & " "
4. Next
5. %>
Per ottenere i numeri dispari tra 1 e 10 è sufficiente modificare la riga 2 come segue:
1. <%
2. For intCont = 1 To 10 Step 2
3. Response.Write "Numero " & intCont & " "
4. Next
5. %>
Un derivato della struttura For... Next è la For Each... Next che è molto comoda quando si ha a che fare con degli array
o con delle collection (che vedremo più avanti). Ecco un esempio con un array:
1. <%
2. Dim Item, strCitta(2)
3. strCitta(0) = "Roma"
4. strCitta(1) = "Londra"
5. strCitta(2) = "Parigi"
6. For Each Item In strCitta
7. Response.Write Item & " "
8. Next
9. %>
4.8.4) Struttura DO .. WHILE
La struttura Do While... Loop si presenta così:
Do While condizione
codice da eseguire
Loop
1. <%
8
2.
3.
4.
5.
6.
7.
8.
Dim intCont
intCont = 1
Do While intCont <= 10
Response.Write "Numero " & intCont & " "
intCont = intCont + 1
Loop
%>
Quando si lavora con i cicli bisogna fare estrema attenzione a non creare i cosiddetti cicli infiniti che sono cicli che non
hanno mai soddisfatte le condizioni per essere terminati e provocano quindi rallentamenti del sistema su cui girano.
Nell'esempio precedente se non ci fosse la riga 6 si creerebbe un ciclo infinito in quanto intCont rimarrebbe per sempre
inferiore a 10 in quanto verrebbe a mancare l'istruzione per il suo incremento di 1 ad ogni giro del ciclo.
Nel caso della struttura Do While... Loop, non siamo obbligati a controllare la condizione nella prima riga ma possiamo
farlo anche nell'ultima riga di istruzione del ciclo:
Do
codice da eseguire
Loop While condizione
La differenza fondamentale fra le due sintassi è che nel secondo caso il nostro ciclo viene comunque effettuato una
volta; la condizione cioè è controllata solo dopo che il codice centrale è stato eseguito almeno una volta.
Un'altra variante del ciclo Do While... Loop è la Do Until... Loop che anch'essa ha la possibilità del controllo nell'ultima
riga del ciclo con la struttura Do... Loop Until. La differenza qui sta nel significato stesso della parola; in inglese While
significa Mentre, invece Until significa Fino A Quando. Una istruzione deve essere eseguita MENTRE una condizione
è vera oppure, nel caso Do Until... Loop, deve essere eseguita FINO A QUANDO una condizione non diventa vera.
Segue un esempio:
1.
2.
3.
4.
5.
6.
7.
8.
<%
Dim intCont
intCont = 1
Do While intCont <= 10
Loop
%>
che diventa come segue nel caso si utillizzi il Do Until... Loop
1.
2.
3.
4.
5.
6.
7.
8.
<%
Dim intCont
intCont = 1
Do Until intCont > 10
Loop
%>
Un'ultima alternativa alla struttura Do While... Loop che è esattamente identica per funzionamento è la While... Wend.
Non vi è nessuna differenza se non nelle parole che determinano l'istruzione.
1.
2.
3.
4.
5.
6.
7.
8.
<%
Dim intCont
intCont = 1
While intCont <= 10
Wend
%>
9
4.9) Subroutine e funzioni per il riutilizzo del codice
L'utilizzo di subroutine e funzioni è molto utile soprattutto quando si ha la necessità di ripetere più volte un certo pezzo
di codice o di effettuare più volte lo stesso tipo di calcolo. Solitamente vengono scritte in file esterni e poi incluse nelle
pagine nelle quali se ne fa uso (vedremo più avanti come fare) ma in alcuni casi si possono trovare all'interno della
pagina stessa in cui se ne fa uso. Le subroutine eseguono azioni come per esempio scrivere del testo in una pagina
mentre le funzioni eseguono calcoli e operazioni e restituiscono un valore.
4.9.1) Subroutine
Le subroutine, conosciute anche col nome di procedure, si presentano nella loro forma più semplice come segue:
Sub nomeDellaSubroutine
codice da eseguire
End Sub
Per richiamare la procedura si utilizza l'istruzione Call seguita dal nome della subroutine; è sufficiente comunque
scrivere solo il nome della subroutine evitando l'uso di Call. Vediamo un esempio:
1. <%
2. Sub SalesContactInfo
3. Response.Write "chiamate Mister X al numero 0522956842"
4. End Sub
5. %>
6. Per prenotare un tavolo per una cena al sabato sera,
7. <%
8. Call SalesContactInfo
9. %>
10. 
La chiamata ad una subroutine o ad una funzione all'interno della stessa pagina può essere fatta tutte le volte che se ne
ha bisogno. Si possono creare anche procedure alle quali vengono passati degli argomenti:
Sub nomeDellaSubroutine(argomento1, argomento2, ...)
codice da eseguire nel quale si possono utilizzare gli argomenti
End Sub
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
<%
Sub NomeCognome(nome, cognome)
Response.Write "Il nome è: " & nome & " "
Response.Write "Il cognome è: " & cognome & " "
End Sub
%>
Elenco dei partecipanti
<%
NomeCognome("Giovanni","Acerbi")
NomeCognome("Pinco","Pallino")
%>

4.9.2) Funzioni
Le funzioni vengono utilizzate per effettuare dei calcoli. La loro struttura di base non differisce molto da quella delle
subroutine; al posto di Sub e End Sub metteremo Function e End Function. L'unica cosa che è diversa è che il nome
della funzione diventa la variabile alla quale si deve abbinare il valore del risultato ottenuto. Ecco come si presenta:
Function NomeFunzione(argomento1, argomento2, ...)
10
codice da eseguire nel quale si possono utilizzare gli argomenti
NomeFunzione = valore
End Function
Per richiamare la funzione si utilizza la seguente sintassi:
MiaVariabile = NomeFunzione(argomento1, argomento2, ...)
Vediamo un esempio che calcola l'elevamento a potenza di un numero intero passato come primo argomento elevato al
numero intero passato come secondo argomento:
1. <%
2. Function ElevamentoAPotenza(intNumero, intEsponente)
3. Dim intRisultato
4. intRisultato = intNumero ^ intEsponente
5. ElevamentoAPotenza = intRisultato
6. End Function
7. %>
8. 4 elevato alla quinta dà
9. <%
10. Dim intPotenza
11. intPotenza = ElevamentoAPotenza(4,5)
12. Response.Write intPotenza
13. %>
14. 
Non è necessario assegnare ad una variabile il risultato di una funzione, il codice precedente si può anche scrivere come
segue:
1. <%
2. Function ElevamentoAPotenza(intNumero, intEsponente)
3. Dim intRisultato
4. intRisultato = intNumero ^ intEsponente
5. ElevamentoAPotenza = intRisultato
6. End Function
7. %>
8. 4 elevato alla quinta dà
9. <%
10. Response.Write ElevamentoAPotenza(4,5)
11. %>
12. 
4.10) Funzioni interne di VBSCRIPT
Nel linguaggio VBScript, sono disponibili parecchie funzioni interne, cioè pronte e disponibili per effettuare un
notevole numero di operazioni piuttosto comuni. La prima cosa che prendiamo in considerazione è il typecasting delle
variabili. Può capitare di avere bisogno di modificare il subtipo di una variabile; per esempio se si ha una stringa il cui
valore è "350" e la si vuole fare diventare un numero intero per compiere operazioni matematiche, oppure una stringa
con valore "09/02/1968" la si vuole fare diventare a tutti gli effetti una variabile di subtipo data. Come vedremo non ci
sono solo funzioni per il typecasting. Il seguente codice ci fa capire meglio di cosa si sta parlando:
1. <%
2.
Dim varMyVar1, varMyVar2
3.
varMyVar1 = "200"
4.
varMyVar2 = "300"
5.
Response.Write varMyVar1 + varMyVar2 & " "
6.
' Conversione delle stringhe in numeri interi
7.
varMyVar1 = CInt(varMyVar1)
8.
varMyVar2 = CInt(varMyVar2)
9.
Response.Write varMyVar1 + varMyVar2
10. %>
La prima volta che si effettua la somma delle variabili si ottiene una stringa il cui valore è "200300", dopo la
conversione in numeri interi il risultato è un intero che vale 500.
11
4.10.1) Funzioni di casting di tipo
Vediamo una tabella riassuntiva di alcune funzioni di typecasting:
Funzione Sintassi
Descrizione
Esempio
CBool
CBool(espressione) Ritorna un valore booleano corrispondente al intCounter = 5
valore di una espressione. Se l'espressione blnValue = CBool(intCounter)
vale zero il risultato è falso altrimenti è vero.
blnValue è Vero
CByte
CByte(espressione) Ritorna una espressione convertita ad un
variant di subtipo byte. Si ha errore se il
valore esce dal range accettabile per un
Byte (da 0 a 255)
dblValue = 5.456
bytValue = CByte(dblValue)
bytValue vale 5
CCur
CCur(espressione)
Ritorna una espressione convertita ad un
dblValue = 821.555790
variant di subtipo currency. Il risultato
curValue = CCur(dblValue)
dipende dalle impostazioni internazionali del
server. I numeri vengono formattati con
curValue vale 821,5558
l'appropriato separatore decimale e la quarta
cifra dopo la virgola viene arrotondata per
eccesso se la quinta cifra è superiore o
uguale a 5.
CDbl
CDbl(espressione)
dblValue = CDbl(3.49)
variant di subtipo double. Il risultato dipende
dalle impostazioni internazionali del server. Il dblValue diventa 3,49
separatore delle cifre decimali è formattato a
seconda di queste impostazioni.
CInt
CInt(espressione)
varValue = 5579.56
variant di subtipo integer. Il risultato dipende intValue = CInt(varValue)
dalle impostazioni internazionali del server. Il
valore decimale viene prima arrotondato e
intValue vale 5580
poi scartato. Nel caso di numeri tipo 0.5, 1.5,
2.5 ecc... il numero viene arrotondato al
numero pari più vicino.
CLng
CLng(espressione)
varValue = 5579.56
variant di subtipo long. Il risultato dipende
lngValue = CLng(varValue)
dalle impostazioni internazionali del server. Il
valore decimale viene prima arrotondato e
lngValue vale 5580
poi scartato.
CSng
CSng(espressione) Ritorna una espressione convertita ad un
variant di subtipo single. Il risultato dipende
dalle impostazioni internazionali del server.
varValue = 5.456
sngValue = CSng(varValue)
sngValue vale 5,456
CStr
CStr(espressione)
variant di subtipo string. Il risultato dipende
dalle impostazioni internazionali del server.
Si ha errore se espressione vale Null. Valori
di tipo numeric e err diventano numeri, valori
booleani diventano Vero o Falso, le date
vengono convertite al formato di tipo short
(corto).
strBool = CStr(True)
strDate = CStr(#1/1/01#)
strNum = CStr(5,45)
strBool vale "Vero"
strDate vale "01/01/2001"
strNum vale "5,45"
Gli esempi precedenti sono stati testati su un server con impostazioni italiane di default.
4.10.2) Funzioni matematiche
12
Vediamo una tabella riassuntiva di alcune funzioni matematiche:
Funzione
Significato
Esempio
Abs(numero)
Valore assoluto
Abs(-58)
Ris: 58
Atn(numero)
Arcotangente
4 * Atn(1)
Ris: 3,14159265358979
Cos(numero)
numero in radianti
Coseno
Cos(30 * 3.14 / 180)
Ris: 0,866158094405463
Exp(numero)
e ^ numero (e = 2,718282)
Exp(2)
Ris: 7,38905609893065
Fix(numero)
Parte intera
Fix(-7.6)
Ris: 7
Hex(numero)
Esadecimale in base 10
Hex(200)
Ris: C8
Int(numero)
Parte intera
Int(-7.6)
Ris: 8
Log(numero)
Logaritmo naturale
Log(5)
Ris: 1,6094379124341
Oct(numero)
Ottale in base 10
Oct(8)
Ris: 10
Rnd
Numero casuale
Randomize
Int(Rnd * 10)
Ris: nr. casuale >= 0
e < 10
Round(numero)
Arrotonda a intero più prossimo
Round(4.5)
Ris: 4
Round(4.51)
Ris: 5
Round(numero,decimali) Arrotonda al valore di decimali
Round(4.515,2)
Ris: 4,51
Round(4.516,2)
Ris: 4,52
Sgn(numero)
Segno
numero < 0 = -1
numero = 0 = 0
numero > 0 = 1
Sin(numero)
Seno
Sin(30 * 3.14 / 180)
Ris: 0,499770102643102
Sqr(numero)
numero>0
Radice quadrata
Sqr(9)
Ris: 3
Tan(numero)
Tangente
Tan(10)
Ris: 0,648360827459087
Esistono tante altre funzioni interne di VBScript relative a date, stringhe, formattazioni particolari ecc...
Vediamo l'uso di alcune di esse molto comuni, mentre per una lista completa conviene fare riferimento ad un manuale
VBScript o a documentazione ufficiale Microsoft.
4.10.3) Funzioni data e ora
13
Funzioni di data e orario:
Date restituisce la data del giorno attuale
DatePart("h",Now) restituisce l'ora (es: 7 o 13 o 18 ....) dell'orario attuale
Segue un elenco dei valori che si possono inserire al posto di "h":
d - giorno
m - mese
n - minuto
q - trimestre
s - secondo
w - giorno della settimana
ww - settimana dell'anno
y - giorno dell'anno
yyyy - anno
Day(Date) restituisce il giorno della data attuale
Time restituisce l'orario attuale
Hour(Time) restituisce l'ora dell'orario attuale
Minute(Time) restituisce i minuti dell'orario attuale
Second(Time) restituisce i secondi dell'orario attuale
IsDate(espressione) restituisce un variant di subtipo booleano
Esempio:
IsDate(Date) = Vero
IsDate("") = Falso
IsDate(#01/01/2002#) = Vero
MonthName(month, [abbreviato]) restituisce il nome del mese indicato da month
Esempio:
MonthName(Month(Date)) restituisce il nome del mese corrente
MonthName(Month(Date),True) restituisce il nome abbreviato del mese corrente
Now restituisce la data e l'ora attuale
4.10.4) Funzioni di stringa
Qualunque cosa faccia la nostra applicazione, spesso ci si trova a dover manipolare delle stringhe. Vi sono molte
funzioni di stringa ed ora ne vediamo qualcuna nel dettaglio:
InStr([start,] string1, string2 [, compare])
ritorna un numero intero che indica la posizione della prima occorrenza di una parte di stringa all'interno di una stringa.
start (opzionale) è una qualunque espressione valida non negativa che indica la posizione di partenza della ricerca
all'interno di string1. I valori non interi sono arrotondati. Questo argomento è richiesto se è specificato l'argomento
compare.
string1 è la stringa nella quale vogliamo cercare.
string2 è la sub stringa che vogliamo trovare.
compare (opzionale) indica il metodo di comparazione da utilizzare, può essere 0 (zero ovvero vbBinaryCompare) per
una ricerca case sensitive o 1 (uno ovvero vbTextCompare) per una ricerca non-case sensitive. Il valore di default è
zero.
Note
Se start contiene Null si genera un errore di runtime. Se start è più grande della lunghezza di string2, viene restituito 0
(zero).
Esempio:
1. <%
2. Dim strText, lngStartPos, lngFoundPos, strSearchFor
3. strText = "Testo di prova per un test sulle stringhe"
4. Response.Write strText & " "
5. lngStartPos = 1
6. strSearchFor = "t"
7. lngFoundPos = InStr(lngStartPos,strText,strSearchFor)
8. Do While lngFoundPos > 0
9. Response.Write "Lettera t trovata in posizione " & lngFoundPos & " "
14
10. lngStartPos = lngFoundPos + 1
11. lngFoundPos = InStr(lngStartPos,strText,strSearchFor)
12. Loop
13. %>
Il risultato finale è il seguente:
Testo di prova per un test sulle stringhe
Lettera t trovata in posizione 4
Da notare che la prima T della frase non viene trovata perché non è stato specificato l'argomento di comparazione e
quindi viene utilizzato quello di default, cioè zero, che effettua una ricerca case sensitive e quindi "T" è diverso da "t".
LCase(string) e UCase(string)
Queste due funzioni si utilizzano per convertire in lettere minuscole o maiuscole una stringa specificata.
Esempio:
1. <%
2. strText = "Lo chiamavano Trinità"
3. Response.Write LCase(strText) & " "
4. Response.Write UCase(strText)
5. %>
Il risultato finale è il seguente:
lo chiamavano trinità
LO CHIAMAVANO TRINITÀ
Len(string)
La funzione Len restituisce il numero di caratteri di cui è composta una stringa compresi gli spazi; Len("Bella
giornata") restituirà il valore 14.
Left(string, length) e Right(string, length)
Queste due funzioni restituiscono la parte sinistra o destra della stringa della lunghezza specificata dal valore length.
Esempio:
1. <%
2. strText = "Bella giornata"
3. Response.Write Left(strText,5) & " "
4. Response.Write Right(strText,5)
5. %>
Il risultato finale è:
Bella
rnata
Mid(string, start[, length])
La funzione Mid restituisce una parte di string partendo dal carattere start e lunga il valore di length (opzionale).
Esempio:
1. <%
3. Response.Write Mid(strText,4) & " "
4. Response.Write Mid(strText,4,6)
5. %>
Il risultato finale è:
la giornata
la gio
LTrim(string), RTrim(string) e Trim(string)
15
Queste funzioni servono nell'ordine a eliminare gli spazi bianchi a sinistra di una stringa, a destra di una stringa e da
tutte e due le parti di una stringa.
Replace(expression, find, replacewith[, start[, count[, compare]]])
Questa funzione sostituisce una parte di una stringa con un'altra stringa un numero definito di volte.
expression è la stringa intera nella quale cercare la parte da sostituire.
find è la parte di stringa che si vuole sostituire.
replacewith è la stringa che si vuole utilizzare per la sostituzione.
start (opzionale) è il carattere espresso in numeri dal quale cominciare a cercare, il valore di default è 1 cioè inizio
stringa.
count (opzionale) è il numero delle sostituzioni da effettuare, il valore di default è -1 che significa che verranno
effettuate tutte le ricorrenze trovate.
zero.
Esempio:
1. <%
3. Response.Write Replace(strText,"Bella","Brutta")
4. %>
Il risultato è il seguente:
Brutta giornata
Split(expression[, delimiter[, count[, compare]]])
Questa funzione è molto comoda perché genera automaticamente un array di stringhe.
expression è la stringa da suddividere.
delimiter (opzionale) è il o i caratteri da prendere in considerazione per la suddivisione, se non specificato viene usato il
carattere di spazio.
count (opzionale) è il numero di substringhe da ritornare.
zero.
Esempio:
1. <%
2. strText = "1;2;3;4;5;6;7;8;9;0"
3. arrMyArray = Split(strText,";",5)
4. For Each Item In arrMyArray
5. Response.Write Item & " "
6. Next
7. %>
Il risultato è il seguente:
1
2
3
4
5;6;7;8;9;0
4.10.5) Funzioni di formattazione
Per finire questa sezione vediamo ora alcune funzioni di formattazione che sono funzioni che servono appunto per
modificare l'aspetto di numeri, date, valute ecc...
FormatDateTime(date[, namedformat])
date è una qualunque data valida.
namedformat (opzionale) è un valore numerico che indica il formato di data/orario da utilizzare. Può avere i seguenti
valori:
16
vbGeneralDate 0 formato data (se presente) e ora (se presente) che utilizza la data corta e l'orario esteso presi dalle
impostazioni locali del server
vbLongDate 1 formato data estesa presa dalle impostazioni locali del server
vbShortDate 2 formato data corta presa dalle impostazioni locali del server
vbLongTime 3 formato orario esteso preso dalle impostazioni locali del server
vbShortTime 4 formato orario corto preso dalle impostazioni locali del server
Esempio:
1. <%
2. Response.Write FormatDateTime(Now,vbGeneralDate) & " "
3. Response.Write FormatDateTime(Now,vbLongDate) & " "
4. Response.Write FormatDateTime(Now,vbShortDate) & " "
5. Response.Write FormatDateTime(Now,vbLongTime) & " "
6. Response.Write FormatDateTime(Now,vbShortTime) & " "
7. %>
Il risultato su un server con le impostazioni italiane di default è il seguente:
02/01/2002 15.45.33
mercoledì 2 gennaio 2002
02/01/2002
15.45.33
15.45
FormatNumber(expression[, numdigitsafterdecimal[, includeleadingdigit[, useparensfornegativenumbers[,
groupdigits]]]])
Questa funzione serve a formattare un numero.
expression è la variabile che vogliamo formattare
numdigitsafterdecimal (opzionale) è un valore numerico che indica quanti numeri decimali dopo la virgola vogliamo
utilizzare, se non specificato è utilizzato il valore di default del Pannello di Controllo.
includeleadingdigit (opzionale) indica se si vuole utilizzare un zero all'inizio di valori frazionari.
useparensfornegativenumbers (opzionale) indica se i numeri negativi sono da scrivere fra parentesi.
groupdigits (opzionale) indica se si vuole utilizzare il separatore delle migliaia specificato nelle impostazioni
internazionali del Pannello di Controllo.
Gli ultimi tre argomenti possono assumere i seguenti valori:
vbUseDefault 2 impostazioni di default prese dal Pannello di Controllo
vbTrue -1
vbFalse 0
Come detto in precedenza, conviene fare riferimento ad un manuale VBScript o a documentazione ufficiale Microsoft
per una lista completa delle funzioni interne di VBScript.
4.11) Oggetti, proprietà, metodi ed eventi
Spesso si sente parlare di programmazione ad oggetti o rivolta agli oggetti ma cosa si intende con questa definizione? In
poche parole la si può riassumere come una rappresentazione software di oggetti del mondo reale per i quali, come
vedremo, si parla di proprietà, metodi ed eventi.
Quando si sarà capito che cosa si intende per oggetto, saremo in grado di capire anche come gli oggetti nella
programmazione possano essere utili agli sviluppatori di software.
4.11.1) Che cosa è un oggetto
Nel mondo reale sappiamo già che cosa sono gli oggetti. Sono cose che si possono vedere, toccare, usare come un
elettrodomestico, una macchina, un arnese da lavoro. Prendiamo ad esempio un telefono; ogni telefono ha un
microfono, un altoparlante e un tastierino numerico. Queste sono proprietà fisiche del telefono. Si può dire che un
telefono ci permette di fare delle cose, ad esempio chiamare qualcuno, parlargli. Un telefono ci avvisa quando qualcun
17
altro ci chiama e questo farà sì che noi solleviamo il ricevitore. In maniera più astratta, si può dire che un telefono
abbia:
Alcune proprietà che lo descrivono
Un insieme di cose o metodi che ci permettono di compiere azioni
L'abilità di compiere azioni se si genera un evento
Vediamo una tabella riassuntiva di queste tre voci.
Descrizione del
Il telefono è grigio
telefono
Il telefono è fatto di plastica
Il telefono pesa 450 grammi
Il telefono ha 12 tasti
Il numero del telefono è 0522 333248
Il telefono è connesso alla linea
A cosa serve
Possiamo telefonare
Possiamo rispondere ad una chiamata
Possiamo interrompere una chiamata
Possiamo inserire in nostro numero di carta di credito
Possiamo disconnetterlo dalla linea
Cosa può fare per farci Qualcuno ci sta chiamando
agire
La persona chiamata è occupata
Un'altra persona ci sta chiamando mentre siamo in altra conversazione
In termini più legati all'informatica, come già detto in precedenza, si parla di proprietà, metodi ed eventi. C'è un altro
termine da tenere in considerazione: istanza. Quando parliamo di un unico oggetto, possiamo usare il termine di istanza
per dire che si sta parlando di un oggetto in particolare. Tornando all'esempio del telefono, si può parlare di una istanza
che prende in considerazione il telefono di Pippo e una che prende in considerazione il telefono di Pluto. Stiamo
parlando dello stesso tipo di oggetto che però nei due casi potrebbe avere proprietà diverse; per esempio quello di Pippo
potrebbe essere blu a differenza di quello di Pluto che magari è grigio. Quando si parla di un oggetto in particolare di
una determinata classe, si dice che l'oggetto è stato istanziato. Quello che succede è che si genera una copia di tutte le
proprietà e degli eventi dalla descrizione dell'oggetto ma i metodi (solitamente molte righe di codice) rimangono nel
luogo d'origine e le sezioni del codice vengono utilizzate da tutte le diverse istanze dell'oggetto.
4.11.2) Proprietà
Quando parliamo delle caratteristiche di un oggetto, ci stiamo riferendo alle sue proprietà. Ogni proprietà è descritta da
un nome al quale viene assegnato un valore. Nell'esempio del telefono si può fare una lista di queste accoppiate:
Nome della Proprietà
Valore della Proprietà
Colore
Grigio
Materiale
Plastica
Peso
450 grammi
NumeroDiTasti
12
NumeroDelTelefono
0522 333248
Connesso
Sì
Vi possono essere varie istanze dello stesso oggetto con proprietà diverse, vediamo un esempio:
Nome della Proprietà
Telefono di Pippo
Telefono di Pluto
Colore
Grigio
Blu
Materiale
Plastica
Termoplastica
Peso
450 grammi
400 grammi
NumeroDiTasti
12
12
NumeroDelTelefono
0522 333248
02 3516548
Connesso
Sì
Sì
4.11.3) Metodi
Un'altra caratteristica degli oggetti è che possono compiere delle operazioni per noi. Per esempio un metodo
EffettuaChiamata ci connetterà al nostro operatore telefonico che instraderà la chiamata e farà suonare il telefono del
destinatario. Non tutti gli oggetti hanno queste funzionalità; una sedia per esempio ci permette di metterci a sedere,
quindi possiamo dire che la sua funzione sia quella di sopportare il nostro peso. Gli oggetti che compiono azioni che
sono più 'funzionali' posseggono dei metodi. Ogni operazione che un oggetto può compiere è definita appunto metodo.
Vediamo una tabella riassuntiva:
Nome del Metodo
Descrizione
18
PlaceCall
Effettua una chiamata
Answer
Risponde ad una chiamata
HangUp
Chiude la chiamata corrente
SendCardNumber
Inserisce o spedisce il nostro numero di carta
Disconnect
Disconnette il telefono dalla linea
Solitamente alcuni metodi necessitano di parametri aggiuntivi oltre alla chiamata del metodo. Per esempio il fatto che si
sollevi la cornetta per rispondere ad una chiamata non ha bisogno di nessun'altra informazione ma nel caso di una
chiamata da effettuare, occorre senz'altro fornire il numero di telefono da chiamare. Ecco quindi che, come i parametri
che vengono passati a subroutine e funzioni, anche quando si effettua una chiamata ad un metodo si possono passare dei
parametri. Se ritorniamo ai metodi del nostro oggetto telefono, possiamo identificare quali metodi necessitano di
parametri:
Nome del Metodo
Parametri
PlaceCall
Numero di telefono da chiamare
Answer
Nessun parametro
HangUp
Nessun parametro
SendCardNumber
Numero della carta, numero PIN
Disconnect
Nessun parametro
Alcuni metodi possono anche ritornare dei valori che sono appunto detti valori di ritorno.
Nome del Metodo
Valori di ritorno
PlaceCall
True (se la chiamata ha avuto successo)
False (se la chiamata non ha avuto successo)
Answer
Nessun valore di ritorno
HangUp
True (se il telefono è stato chiuso bene)
False (se il telefono è stato chiuso male)
SendCardNumber
True (se la carta è stata accettata)
False (se la carta non è stata accettata)
Disconnect
Nessun valore di ritorno
4.11.4) Eventi
Le proprietà e i metodi sono modi in cui l'utilizzatore dell'oggetto può comunicare con l'oggetto stesso, ma cosa succede
se l'oggetto deve comunicare con il programma che lo ha creato? Per esempio quando c'è una chiamata in entrata, il
telefono ci deve avvisare. Si genera quindi un evento, cioè in questo caso molto probabilmente la suoneria emette un
suono che fa sì che noi alziamo la cornetta. Anche gli eventi possono passare dei valori, per esempio nel caso in cui si
abbia la possibilità di visualizzare il numero del chiamante ecco che l'evento, oltre che ad avvisarci della chiamata in
arrivo, ci comunica anche il numero di chi ci sta chiamando.
4.11.5) Incapsulazione
Quando si utilizzano oggetti creati da terze parti, non ci si deve preoccupare di come questi oggetti funzionino bensì del
come li si debba utilizzare. Nel caso del telefono, non dobbiamo preoccuparci di come la nostra voce faccia a
raggiungere il nostro interlocutore, l'unica cosa che dobbiamo fare è alzare la cornetta e comporre il numero. Nel caso
degli oggetti in ASP, non dobbiamo preoccuparci di come siano stati programmati, basta sapere come utilizzarli. Questo
concetto di utilizzo di un oggetto, senza sapere come l'oggetto funzioni nei minimi particolari, viene detto
incapsulazione.
4.11.6) Programmazione con gli oggetti
Immaginiamo ora di avere il nostro telefono collegato al nostro PC e vediamo come potremmo interagire con esso via
software. Non vedremo come l'oggetto funziona nei particolari o come è stato programmato ma vedremo come di solito
si utilizzano in ASP le proprietà e i metodi di un oggetto. Nel caso del telefono, potremmo immaginarla così:
1. <%
2. Option Explicit
3. Dim objTelephone
4. Set objTelephone = Server.CreateObject("MyTelephone.Telephone")
5. objTelephone.Color = "Blue"
6. objTelephone.Material = "Thermoplastic"
7. objTelephone.Weight = 450
8. objTelephone.NumberOfKeys = 12
9. Response.Write "Fatto"
19
10. Set objTelephone = Nothing
11. %>
In questo primo pezzo di codice si vede come si possono andare a modificare le proprietà di un istanza di un oggetto.
Alla riga 3 si definisce la variabile che conterrà l'istanza dell'oggetto. Tramite l'istruzione Set si inizializza l'oggetto
sfruttando il metodo Server.CreateObject dopodiché, tramite la sintassi oggetto.proprietà diamo i valori delle
proprietà dell'oggetto.
Vediamo ora come richiamare le proprietà dell'oggetto stesso.
1. <%
2. Option Explicit
3. Dim objTelephone
5. objTelephone.Color = "Blue"
6. objTelephone.Material = "Thermoplastic"
7. objTelephone.Weight = 450
8. objTelephone.NumberOfKeys = 12
9. Dim strColor, strMaterial, intNumKeys, intWeight, blnConnected
10. strColor = objTelephone.Color
11. strMaterial = objTelephone.Material
12. intNumKeys = objTelephone.NumberOfKeys
13. intWeight = objTelephone.Weight
14. blnConnected = objTelephone.IsConnected
15. Response.Write "objTelephone.Color = " & strColor & " "
16. Response.Write "objTelephone.Material = " & strMaterial & " "
17. Response.Write "objTelephone.NumberOfKeys = " & intNumeKeys & " "
18. Response.Write "objTelephone.Weight = " & intWeight & " "
19. Response.Write "objTelephone.IsConnected = " & blnConnected & " "
21. %>
La sintassi per richiamare un metodo è molto simile alla sintassi per ricavare una proprietà; solo due cose bisogna tenere
presente:
o se il metodo richiede dei parametri, bisogna passarli correttamente
o se il metodo ha un valore di ritorno, dobbiamo leggerlo in qualche modo
1. <%
2. Option Explicit
3. Dim objTelephone
4. Dim blnIsConnected
6. Response.Write "Rispondo al telefono... "
7. objTelephone.Answer()
8. blnIsConnected = objTelephone.IsConnected
9. Response.Write "La proprietà IsConnected è " & blnIsConnected
10. Response.Write "Chiudo il telefono... "
11. objTelephone.HangUp()
12. Response.Write "La proprietà IsConnected è " & objTelephone.IsConnected
14. %>
Vediamo ora un esempio col passaggio di parametri.
1. <%
2. Option Explicit
3. Dim objTelephone
4. Dim strPhoneNumber
5. Dim blnIsConnected
7. strPhoneNumber = "0522 333248"
8. Response.Write "Calling " & strPhoneNumber & " "
9. objTelephone.PlaceCall(strPhoneNumber)
10. blnIsConnected = objTelephone.IsConnected
11. Response.Write "La proprietà IsConnected è " & blnIsConnected & " "
13. %>
Fino ad ora abbiamo parlato di un oggetto che incontriamo nella vita di tutti i giorni, il telefono. Nella programmazione
delle pagine ASP, quello che maggiormente interessa è il fatto che si possa tenere nota di informazioni passate
20
dall'utente, visualizzare informazioni dinamicamente ecc... Ecco che allora Microsoft ha creato oggetti che ci
permettono di effettuare molte di queste operazioni.
4.12) Oggetti incorporati
Gli oggetti principali che costituiscono la struttura delle ASP 3.0 sono 7, anche chiamati built-in objects, ovvero oggetti
incorporati. Vediamo una lista in ordine alfabetico:
Response object
Si usa per mandare testo, dati e gestire cookies verso il browers
Request object
Gestisce i dati dei form, i cookies e le variabili sul server
Application object
Permette di manipolare i dati all'interno di uno script che saranno resi visibili a tutti quelli che stanno
navigando sul sito o utilizzando lo script in quel momento
Session object
Permette di spedire dati ed interagire con un particolare utente che naviga nel sito, senza che tali dati siano
visibili a tutti
ASPError object
Permette di intercettare errori avvenuti durante l’esecuzione
ObjectContext object
Server object
Permette di accedere ai metodi e alle proprietà del server. Il metodo più utilizzato è Server.CreateObject, che
permette la definizione di oggetti ActiveX
ADO Object
Gestisce le collezioni della tecnologia ADO. Nel seguito lo useremo per le operazioni con i database
BrowserCap Object
Permette di riconoscere il browser e le impostazioni (ad esempio la risoluzione,il numero di colori etc) che il
visitatore sta utilizzando, adattando il sito al software dell'utente
FileSystem Object
Permette di manipolare files e directories
Ve ne sono altri che vedremo man mano, per ora partiamo dai due più utilizzati ovvero gli oggetti Response e Request.
4.12.1) Response Object
L'oggetto Response è già stato utilizzato per scrivere a video, tramite il metodo Write, determinate stringhe o valori di
variabili. Tuttavia questo è un oggetto che possiede molte proprietà e metodi nonché collection che permettono al server
di comunicare svariate cose ad un client nel momento in cui avviene una richiesta di una pagina web. Vediamone un
riassunto:
Collections:
Cookies
Properties:
Buffer
CacheControl
Charset
ContentType
Expires
ExpiresAbsolute
21
IsClientConnected
Pics
Status
Methods:
AddHeader
AppendToLog
BinaryWrite
Clear
End
Flush
Redirect
Write
Il più utilizzato dei metodi dell'oggetto Response è sicuramente il Write. Si può presentare in due forme, una estesa ed
una abbreviata.
1. 
2. <% Response.Write "Questa è la forma estesa. " %>
3. <% = "Questa è la forma abbreviata" %>
4. 
Un altro metodo molto utilizzato è il Redirect che serve a reindirizzare l'utente su una pagina diversa al verificarsi di
determinate condizioni.
1. <%
2. If Hour(Now) >= 0 And Hour(Now) < 8 Then
3. Response.Redirect "notte.asp"
4. Else
5. %>
6. <html>
7. <body>
8. ...
9. html o codice asp da eseguire
10. ...
11. </body>
12. </html>
13. <%
14. End If
15. %>
Nel caso in cui il reindirizzamento dovesse avvenire dopo che sono state scritte già delle intestazioni HTML all'interno
della pagina, è necessario mettere a True il valore del buffer della pagina, in modo che il server non invii le intestazioni
al client fino a quando l'elaborazione della pagina non sia finita.
1. <% Response.Buffer = True %>
2. <html>
3. <body>
4. Ho già cominciato a scrivere dell'HTML
5. <%
6. If Hour(Now) >= 0 And Hour(Now) < 8 Then
7. Response.Redirect "notte.asp"
8. Else
9. %>
10. ...
11. html o codice asp da eseguire
12. ...
13. <%
14. End If
15. %>
16. </body>
17. </html>
Abbiamo quindi appena visto come utilizzare la proprietà Buffer dell'oggetto Response. Un'altra proprietà
comunemente utilizzata è la Expires o ancora meglio la ExpiresAbsolute; il loro utilizzo fa in modo che il
22
programmatore possa decidere la vita di durata di una pagina nella cache del browser dell'utente che la visita. La prima
ha la seguente sintassi:
Response.Expires = number
dove number è il numero di minuti di validità della pagina nella cache del browser del client.
La seconda invece si presenta così:
Response.ExpiresAbsolute [= [#date[time]#]
dove date è la data in cui la pagina scadrà
time è l'orario in cui la pagina scadrà
se time non viene specificato la pagina scadrà alla mezzanotte del giorno indicato in date
se date non viene specificato la pagina scadrà all'orario indicato il giorno in cui la pagina viene richiesta
Esempio:
1. <%
2. Response.ExpiresAbsolute = #March 31, 2002 12:00:00#
3. %>
Nell'esempio la pagina scadrà il 31 Marzo 2002 a mezzogiorno.
La proprietà CacheControl determina se il proxy riesce a mantenere in cache il contenuto delle pagine ASP.
La proprietà CharSet specifica il set di caratteri utilizzato.
La proprietà ContentType specifica il protocollo HTTP utilizzato.
Nelle lezioni seguenti vedremo come utilizzare la collection Cookies per mantenere dei dati persistenti nel web.
4.12.2) Request Object
L'oggetto Request, al contrario di Response, è utilizzato per recuperare informazioni di vario genere, vengano esse dal
client che richiede una pagina o siano esse relative al server stesso. Come per l'oggetto Response vediamo il riassunto
veloce dei metodi, delle proprietà e delle collection:
Collections:
ClientCertificate
Cookies
Form
QueryString
ServerVariables
Properties:
TotalBytes
Methods:
BinaryRead
La sintassi generica dell'oggetto Request è la seguente:
Request.[collection|property|method](variable)
I parametri variabili sono stringhe che specificano l'elemento da recuperare da una collection o da usare come input per
un metodo o una proprietà. Tutte le variabili possono essere recuperate tramite la sintassi Request(variable) senza fare
riferimento alla collection. In questo caso il server cerca all'interno delle collection in questo ordine:
1. QueryString
2. Form
3. Cookies
4. ClientCertificate
5. ServerVariables
Vediamo ora alcuni esempi di codice vero e proprio. Supponiamo che all'interno di una pagina vi sia la seguente
istruzione:
1.
2.
3.
...
<a href="page.asp?valore1=15&valore2=20">Apri page.asp</a>
...
23
La parte di codice scritta in grassetto significa che oltre a definire il nome della pagina che si vuole aprire, in questo
caso page.asp, si effettua anche un passaggio di una variabile che si chiama valore1 che contiene 15 e di una variabile di
nome valore2 che contiene 20. Vediamo allora qual'è l'istruzione da scrivere in page.asp per recuperare queste
informazioni e magari scriverle a video (NOTA : dati inviati con il metodo GET):
1. <%
2. Dim strValore1, strValore2
3. strValore1 = Request.QueryString("valore1")
4. strValore2 = Request.QueryString("valore2")
5. Response.Write "valore1 vale: " & strValore1 & " "
6. Response.Write "valore2 vale: " & strValore2
7. %>
Un altro modo per ottenere le stesse informazioni è quello di sfruttare il fatto che si tratti di collection, nel seguente
modo:
1. <%
2. Dim Item
3. For Each Item In Request.QueryString
4. Response.Write Item " vale: " & Request.QueryString(Item) & " "
5. Next
6. %>
La stessa collection si utilizza quando si vogliono recuperare dati passati tramite un form con il metodo GET.
Nel caso in cui invece il form sia inviato col metodo POST, allora si utilizza la collection Form dell'oggetto Request.
Supponiamo di avere il seguente form all'interno di una pagina web:
1. ...
2. <form method="POST" action="page.asp">
3. Nome: <input type="text" name="nome"> 
4. Cognome: <input type="text" name="cognome"> 
5. <input type="submit" value="Invia dati">
6. </form>
7. ...
Questo è il codice che si potrebbe usare per recuperare le accoppiate variabile/valore:
1. <%
2. Dim Item
3. For Each Item In Request.Form
4. Response.Write Item & " vale: " & Request.Form(Item) & " "
5. Next
6. %>
oppure
1. ...
2. 
3. Nome: <% = Request.Form("nome") %> 
4. Cognome: <% = Request.Form("cognome") %>
5. 
6. ...
Per leggere tutte le variabili di ambiente tramite la collection ServerVariables si può utilizzare sempre un ciclo For
Each... Next e vedere di cosa si tratta.
1. <%
2. Dim Item
3. For Each Item In Request.ServerVariables
4. Response.Write Item & ": " & Request.ServerVariables(Item) & " "
5. Next
6. %>
Vediamo uno screenshot di quello che si dovrebbe vedere:
24
Nel caso in cui si abbia la necessità di una sola variabile di ambiente o di alcune variabili, si può fare riferimento alle
singole:
1. <%
2. Dim strUserAgent, strRemoteAddr
3. strUserAgent = Request.ServerVariables("HTTP_USER_AGENT")
4. strRemoteAddr = Request.ServerVariables("REMOTE_ADDR")
5. Response.Write "Browser in uso sul client: " & strUserAgent & " "
6. Response.Write "IP number del client: " & strRemoteAddr & ""
7. %>
In questo caso abbiamo letto che tipo di browser è in uso sulla macchina del client e l'IP number della sua connessione e
li abbiamo riscritti a video in grassetto.
25
4.12.3) I Cookies
Prima di parlare di cookies facciamo una piccola premessa riguardo alla interazione che esiste fra client e server.
Quando un client fa una richiesta ad un server per una pagina web, il server risponde con l'informazione corretta. Cosa
succede a questo punto? Il server si "sgancia" dal client in attesa di altre richieste, la connessione quindi non rimane
attiva, il server si dimentica subito di chi lo ha visitato. Uno dei più grossi problemi della rete è appunto il suo essere
stateless cioè senza stato. In altre comuni applicazioni tipo Word questo problema non si pone, in quanto ogni
modifica, correzione o aggiunta ad un file non necessita di informazioni ulteriori, il programma sa sempre su che file
stiamo lavorando fino a quando non lo chiudiamo. Internet è un po' come spedire una lettera, se ci dimentichiamo di
scrivere qualcosa, dobbiamo scriverne un'altra e rispedirla. Una prima soluzione a questo problema sono appunto i
cookies, anche se vedremo che ASP mette a disposizione altri strumenti per tenere traccia dei client.
4.12.3.1) Creare i Cookies con l’oggetto Response
Scrivere un cookie sul PC di un client è molto semplice. La sintassi è la seguente:
<% Response.Cookies("cookie") = value %>
Se value è una stringa allora va messa fra virgolette. La scrittura precedente aggiunge la seguente intestazione HTTP:
Set-Cookie:YOURCOOKIENAME=somevalue
4.12.3.2) Utilizzo delle chiavi
Se aggiungiamo un valore chiave, allora possiamo accedere ai cookie come collection. Questo significa che un cookie
può avere lo stesso nome ma più chiavi per diversi valori memorizzati. La sintassi è la seguente:
<% Response.Cookies("cookie")("key") = value %>
quindi si procede solitamente a specificare i diversi valori:
1. <%
2. Response.Cookies("sameCookieName")("key1") = value1
3. Response.Cookies("sameCookieName")("key2") = value2
4. %>
4.12.3.3) La proprietà HasKeys
ASP utilizza la proprietà HasKeys per determinare se un cookie ha o no valori multipli. Per sapere se un cookie ha
valori multipli interroghiamo la proprietà HasKeys:
1. <%
2. For Each Cookie In Request.Cookies
3. If Request.Cookies(Cookie).HasKeys Then
4.
For Each CookieKey In Request.Cookies(Cookie)
5.
Response.Write(Cookie) & "." & (CookieKey) & " = "
6.
Response.Write(Request.Cookies(Cookie)(CookieKey)) & " "
7.
Next
8. Else
9.
Response.Write(Cookie) & " = " & (Request.Cookies(Cookie)) & " "
10. End If
11. Next
12. %>
4.12.3.4) Mantenere il Cookies in vita
Se non si specifica una data di scadenza, un cookie persiste fino a quando il client non chiude il proprio browser o la
sessione utente non è scaduta. Per far sì che il cookie rimanga in memoria nell'hard disk del client, dobbiamo
specificare una data di scadenza, in questo modo:
<% Response.Cookies("cookie").Expires = "May 31, 2002"
Un modo migliore per fare in modo che non vi siano problemi con le date e i loro diversi formati, si preferisce utilizzare
la sintassi seguente:
<% Response.Cookies("cookie").Expires = Date + nrOfDays %>
dove nrOfDays è un numero che indica i giorni di vita del cookie a partire dalla data attuale.
26
4.12.3.5) Cancellare un Cookies
Per fare in modo che un cookie sia cancellato, si utilizza lo stesso codice precedente con l'unica differenza che alla data
attuale si tolgono dei giorni; per essere sicuri che non vi siano problemi con le date se ne tolgono molti:
<% Response.Cookies("cookie").Expires = Date - 1000 %>
4.12.3.6) Chi può leggere i nostri Cookies?
Fino a prova contraria l'unico modo per leggere un cookie via web è che una pagina che risiede nello stesso dominio ne
faccia richiesta. Si può tuttavia forzare il Cookie ad avere ben specificato il nome del dominio dal quale viene scritto e
anche da quale percorso:
<% Response.Cookies("cookie").Domain = "www.joanna.it" %>
<% Response.Cookies("cookie").Path = "/pages/samples/" %>
Se si specifica un dominio diverso da quello in cui si trova la pagina richiesta, il cookie non viene scritto, per ovvi
motivi di sicurezza.
27
4.12.4) Application Object
Per capire cosa sia l'oggetto Application e cosa può fare, dobbiamo ricordare che un'applicazione è definita da tutti i file
contenuti in una directory virtuale che è stata esplicitamente configurata per essere la radice (root) dell'applicazione e di
tutte le sue subdirectory. Con questo oggetto possiamo:
o essere avvisati quando un'applicazione inizia, così che possiamo effettuare delle operazioni in fase di startup
o essere avvisati quando un'applicazione si sta fermando, così che possiamo effettuare delle operazioni per
chiudere l'applicazione stessa in modo corretto
immagazzinare informazioni che possono essere utilizzate da tutti i client che accedono all'applicazione
C'è una singola istanza dell'oggetto Application per ogni applicazione che gira sul server ma potrebbero esserci più
client che stanno accedendo alla stessa applicazione. Questo oggetto immagazzina variabili e/o oggetti che possono
essere utilizzati da ogni pagina ASP che è parte dell'applicazione. Il diagramma che segue ci mostra la relazione tra
applicazioni, oggetti Application e oggetti Session.
Tratto da Beginning Active Server Pages - Wrox Press- Capitolo 8 - Pagina 302
Per inizializzare delle variabili in un oggetto Application, immagazziniamo le informazioni necessarie in uno speciale
file ASP che si chiama global.asa. Vediamo un primo esempio di file global.asa:
1. <SCRIPT LANGUAGE="VBScript" RUNAT="Server">
2. Sub Application_OnStart
3. Application("myAppVariable") = " "
4. Application("anotherAppVariable") = 0
5. End Sub
6. </SCRIPT>
In questo pezzo di codice abbiamo utilizzato un evento (di 4 disponibili) e cioè Application_OnStart. Questo evento si
eseguirà solo una volta nel momento in cui un primo utente si connetterà ad una pagina che fa parte dell'applicazione.
L'evento Application_OnStart viene eseguito prima che una prima sessione sia creata, cioè prima dell'evento
Session_OnStart. Quello che accade, in pratica, è che vengono inizializzate due variabili, una come stringa vuota e
l'altra con valore 0, che possono poi essere utilizzate all'interno di una normale pagina ASP nel modo che segue:
1. <%
2. Application.Lock
3. Application("myAppVariable") = Now
4. Application("anotherAppVariable) = Application("anotherAppVariable) + 1
5. Application.Unlock
6. Response.Write Application("myAppVariable") & " "
7. Response.Write Application("anotherAppVariable")
8. %>
Per leggere tutte le variabili con validità a livello di applicazione che abbiamo inizializzato, possiamo sfruttare la
Contents Collection dell'oggetto Application nel modo che segue:
1. <%
2. Dim Key
3. For Each Key In Application.Contents
4. Response.Write (Key & " vale " & Application(Key))
5. Next
6. %>
28
4.12.4.1) Metodi dell’oggetto Application
L'oggetto Application ha due metodi (più altri due tramite la Contents Collection): Lock e Unlock. Il metodo Lock
serve per bloccare l'applicazione in modo che le variabili memorizzate nell'oggetto Application non possano essere
modificate se non da un client alla volta, come nell'esempio precedente. Questo serve per fare in modo che i dati non
vengano corrotti per una eventuale simultaneità di operazioni sui dati stessi. Il metodo Unlock sblocca le variabili
dell'oggetto Application preventivamente bloccate col metodo Lock. Una novità dell'ASP 3.0 sono i due metodi
Remove e RemoveAll accessibili tramite la Contents Collection che servono per rimuovere un elemento dalla
collection o tutti gli elementi in un colpo solo. Vediamo un esempio:
1. Application("PrimaVariabile") = "Gatti"
2. Application("SecondaVariabile") = "Cani"
3. Application.Contents.Remove("PrimaVariabile")
4.12.4.2) Il file Global.asa
Abbiamo già detto che esiste un file ASP speciale che si chiama global.asa nel quale possiamo immagazzinare oggetti e
variabili che hanno validità a livello di applicazione. In questo file possiamo memorizzare dati che avranno validità
anche a livello di sessione. Il totale degli eventi che si possono generare in ogni file global.asa con del codice VBScript
è 4; vediamo un esempio di un file global.asa con all'interno il codice di base.
3. '...codice VBScript
4. End Sub
5. Sub Application_OnEnd
7. End Sub
8. Sub Session_OnStart
10. End Sub
11. Sub Session_OnEnd
13. End Sub
14. </SCRIPT>
Vediamo quindi che cosa sono le sessioni e le variabili di sessione e come possiamo utilizzarle.
4.12.5) Session Object
In aggiunta al supporto per le applicazioni in un sito web, ASP permette di tenere traccia di ogni singolo utente in ogni
pagina di una applicazione tramite le sessioni. Una sessione utente inizia ogni qualvolta un utente accede ad una pagina
.asp all'interno di una applicazione. La sessione rimane attiva fino a quando l'utente rimane all'interno dell'applicazione
stessa. Ci sono due modi per terminare una sessione. Il primo è determinato dal fatto che l'utente non si trovi più
all'interno dell'applicazione e in questo caso la sessione terminerà automaticamente dopo un certo periodo di tempo (di
default 20 minuti); nel secondo caso si utilizza l'istruzione Session.Abandon in una pagina .asp che forza la chiusura
della sessione. L'oggetto Session quindi ci permette di:
o sapere quando inizia una sessione utente in modo che si possano eseguire determinate operazioni per ogni
singolo client connesso
o sapere quando un utente ha terminato la sua sessione
o immagazzinare informazioni che possono essere utilizzate dal client durante la sua sessione
Anche per l'oggetto Session è possibile ricavare i nomi e i valori di tutte le variabili di sessione utilizzando la Contents
Collection:
1. <%
2. Dim Key
3. For Each Key In Session.Contents
4. Response.Write (Key & " vale " & Session(Key))
5. Next
6. %>
Per ricavare il valore di una singola variabile di sessione si può utilizzare la sintassi
<% = Session.Contents("nomeVariabile") %>
oppure, essendo Contents la Collection di default
<% = Session("nomeVariabile") %>
29
4.12.5.1) Le proprietà dell’oggetto Session
L'oggetto Session ha le seguenti proprietà:
SessionID
Timeout
CodePage
LCID
La SessionID è una proprietà di sola lettura che ritorna il numero di sessione dell'utente. Questo numero è unico per
ogni sessione il che significa che ogni utente ha un numero identificativo diverso dagli altri. Potrebbe capitare nel
tempo, nel caso in cui un server sia riavviato, che un numero di sessione si ripresenti; è quindi sconsigliato utilizzare
questo numero generato automaticamente per salvare eventualmente in un database un dato che si pensa possa per
sempre appartenere ad un singolo utente. Per scrivere a video il numero di sessione utente si utilizza la seguente
sintassi:
<% = Session.SessionID %>
La proprietà Timeout ci permette di impostare la durata di tempo assegnata all'oggetto Session per ogni applicazione. Il
valore è espresso in minuti e il timeout di default è solitamente di 20 minuti. Per modificare il timeout della sessione e
metterlo a 30 minuti si utilizza la seguente sintassi:
<% Session.Timeout = 30 %>
CodePage e LCID sono proprietà che servono per impostare o ricavare la codifica delle impostazioni internazionali
(lingua, formato data...) da utilizzare per la visualizzazione dei dati.
4.12.5.2) Metodi dell’oggetto Session
L'oggetto Session ha un metodo (più 2 tramite la Contents Collection); è il metodo Abandon che distrugge tutti gli
oggetti memorizzati in un oggetto Session e libera le risorse del server che questi occupavano. Se non si utilizza questo
metodo, il server distrugge tutti gli oggetti di sessione al termine della sessione stessa.
Come l'oggetto Application, tramite la Contents Collection si possono utilizzare altri due metodi, Remove e
RemoveAll per eliminare un elemento alla volta o tutti gli elementi in un colpo solo.
1. Session("PrimaVariabile") = "Carote"
2. Session("SecondaVariabile") = "Cipolle"
3. Session.Contents.RemoveAll
4.12.5.3) Le sessioni e il Global.asa
Nella sezione relativa all'oggetto Application, abbiamo visto che ci sono due eventi che si possono utilizzare a livello di
applicazione. Ve ne sono anche due che si possono usare a livello di sessione e sono Session_OnStart e
Session_OnEnd. Vediamo un classico utilizzo di un file global.asa che ci aiuta a sapere quanti utenti
contemporaneamente sono connessi al nostro sito Internet:
3. Application("ActiveUsers") = 0
4. End Sub
5. Sub Application_OnEnd
6. End Sub
7. Sub Session_OnStart
8. Application.Lock
9. Application("ActiveUsers") = Application("ActiveUsers") + 1
11. End Sub
12. Sub Session_OnEnd
13. Application.Lock
14. Application("ActiveUsers") = Application("ActiveUsers") - 1
16. End Sub
17. </SCRIPT>
All'interno di una pagina .asp sarà sufficiente la seguente sintassi per visualizzare a video il numero di utenti connessi:
<% = Application("ActiveUsers") %>
30
IMPORTANTE: le sessioni e quindi le variabili di sessione hanno comunque bisogno che il client abbia abilitato
l'utilizzo dei cookies sulla propria macchina per poter essere utilizzate correttamente.
4.12.6) Error Object
E' veramente difficile, se non impossibile, scrivere righe di codice che non contengano nemmeno un errore. Vi sono
molti errori possibili e alcuni potrebbero anche non dipendere da noi; il più classico è l'errore di sintassi (sintax error),
poi vi sono errori di logica di programmazione, errori che sono generati dal malfunzionamento del server sul quale gira
l'applicazione e poi vi sono errori che non vengono segnalati ma che restituiscono un output sbagliato e tanti altri. Fin
da subito quindi conviene cercare di prevenire che si generino errori che siano poi difficili da rintracciare. Il primo
accorgimento da prendere è sicuramente quello di utilizzare sempre Option Explicit all'inizio delle pagine .asp per fare
in modo che tutte le variabili debbano essere per forza dichiarate. Vediamo un esempio:
1. <%
2. intLato = 5
3. intAltezza = 10
4. Response.Write intLato * intAlteza
5. %>
In questo caso, non si genera nessun errore ma l'operazione base * altezza ci darà come risultato 0 anziché 50 e tutto per
colpa del fatto che abbiamo dimenticato una zeta nello scrivere intAltezza nella riga dell'operazione. Vediamo come ci
può aiutare in questo caso l'Option Explicit:
1. <%
2. Option Explicit
3. Dim intLato, intAltezza
4. intLato = 5
5. intAltezza = 10
6. %>
7. <html>
8. <head>
9. <title>Base x altezza</title>
10. </head>
11. <body>
12. <%
13. Response.Write intLato * intAlteza
14. %>
15. </body>
16. </html>
In questo caso l'errore viene segnalato con un messaggio del tipo seguente:
Errore di run-time di Microsoft VBScript (0x800A01F4)
Variabile non definita: 'intAlteza'
/asp/err.asp, line 13
Un'altra cosa che ci aiuta è senz'altro l'utilizzo del codice indentato. Vediamo le differenze:
1. <%
3. Select Case intCont
4. Case 1,3,5,7,9
5. Response.Write intCont & " è un numero dispari" & " "
6. Case Else
7. Response.Write intCont & " è un numero pari" & " "
8. End Select
9. Next
10. %>
Il codice qui sopra non è indentato ed è sicuramente più comodo nel caso di errore lo stesso codice scritto come segue:
1. <%
a. Select Case intCont
b. Case 1,3,5,7,9
i. Response.Write intCont & " è un numero dispari" & " "
c. Case Else
i. Response.Write intCont & " è un numero pari" & " "
d. End Select
31
3. Next
4. %>
Un altro accorgimento può essere l'utilizzo di commenti per poter trovare velocemente determinati pezzi di codice
all'interno di una pagina, vediamo come:
1. <%
2. ' *****************************************************************
3. ' INIZIO CICLO CONTROLLO NUMERO PARI O DISPARI
4. ' *****************************************************************
6. Select Case intCont
7. Case 1,3,5,7,9 ' IL NUMERO E' DISPARI
8. Response.Write intCont & " è un numero dispari" & " "
9. Case Else ' IL NUMERO E' PARI
10. Response.Write intCont & " è un numero pari" & " "
11. End Select
12. Next
13. ' **************
14. ' FINE CICLO
15. ' **************
16. %>
E' consigliabile inoltre l'utilizzo di subroutine e funzioni per il riutilizzo del codice e la dichiarazione delle variabili
utilizzando le convenzioni viste in precedenza per i nomi da assegnare alle variabili stesse (blnVar per una variabile di
subtipo booleano, intVar per una variabile di subtipo integer ecc...)
Ma cosa ci offre ASP per il controllo degli errori? In ASP 2.0 si utilizzava l'oggetto Err, funzionante anche nella
versione 3.0, tramite il quale, assieme all'istruzione On Error Resume Next, si poteva forzare la pagina a non
terminare l'esecuzione del codice, ignorando gli errori incontrati e non facendo visualizzare all'utente la classica pagina
di errore non troppo piacevole a vedersi. Vediamo un esempio:
1. <%
2. Dim arrMyArr(3)
3. On Error Resume Next
4. arrMyArr(5) = 6
5. If Err.Number > 0 Then
a. Response.Write "E' avvenuto un errore!!!" & " "
b. Response.Write "Descrizione: " & Err.Description & " "
c. Response.Write "Numero: " & Err.Number & " "
d. Response.Write "Origine: " & Err.Source
6. End If
7. %>
In questo caso si è tentato di assegnare un valore ad un indice dell'array fuori dall'intervallo consentito e il messaggio di
errore da noi generato si presenta così:
E' avvenuto un errore!!!
Descrizione: Indice non incluso nell'intervallo
Numero: 9
Origine: Errore di run-time di Microsoft VBScript
La novità in ASP 3.0 è appunto l'oggetto ASPError, l'unico oggetto interno nuovo rispetto alla 2.0. La novità di questo
oggetto è che ci aiuta a gestire gli errori in maniera personalizzata senza dover scrivere del codice all'interno di ogni
pagina .asp. Si interviene infatti direttamente sul server tramite l'IIS (Internet Information Services). Quando si verifica
un errore nelle pagine .asp, viene generato l'errore HTTP 500;100. Si deve quindi intervenire sulle proprietà del sito
tramite l'IIS e impostare una nuova pagina di destinazione in caso di errore al posto di quelle di default; sarà in questa
pagina che si potrà utilizzare l'oggetto ASPError.
32
Quello che segue è un codice di esempio di una pagina di errore personalizzata che si presenterà all'utente nel caso
in cui un errore del tipo 500;100 si generasse sul server:
1. <%
2. Option Explicit
3. Dim objAspError, strTable
4. Set objAspError = Server.GetLastError()
5. strTable = "<table align=""center"" border=""1"">" & vbCrLf
6. strTable = strTable & "<tr>" & vbCrLf
7. strTable = strTable & "<td nowrap>Codice ASP</td><td>" & objAspError.AspCode & " </td>" &
vbCrLf
8. strTable = strTable & "</tr>" & vbCrLf
10. strTable = strTable & "<td nowrap>Numbero di Errore</td><td>" & objAspError.Number & " </td>" &
vbCrLf
13. strTable = strTable & "<td nowrap>Origine</td><td>" & objAspError.Source & " </td>" & vbCrLf
16. strTable = strTable & "<td nowrap>Categoria</td><td>" & objAspError.Category & " </td>" & vbCrLf
19. strTable = strTable & "<td nowrap>Errore verificatosi in</td><td>" & objAspError.File & " </td>" &
vbCrLf
22. strTable = strTable & "<td nowrap>Numero di linea</td><td>" & objAspError.Line & " </td>" &
vbCrLf
25. strTable = strTable & "<td nowrap>Numero di colonna</td><td>" & objAspError.Column & " </td>" &
vbCrLf
33
28. strTable = strTable & "<td nowrap>Descrizione</td><td>" & objAspError.Description & " </td>" &
vbCrLf
31. strTable = strTable & "<td nowrap>Descrizione estesa</td><td>" & objAspError.ASPDescription &
" </td>" & vbCrLf
33. strTable = strTable & "</table>" & vbCrLf
34. %>
35. <html>
36. <head>
37. <title>Pagina di errore</title>
38. </head>
39. <body>
40. Si è verificato un errore!
41. <% = strTable %>
42. <a href="default.asp">Torna alla Home Page</a>
43. </body>
44. </html>
Alla riga 4 si crea una istanza dell'oggetto ASPError tramite il metodo GetLastError dell'oggetto Server dopodiché si
genera una tabella riassuntiva che contiene tutte le proprietà che l'oggetto ASPError può ritornare.
4.12.6.1) Proprietà dell’oggetto Error
Riassumiamo le proprietà dell'oggetto di seguito:
ASPCode
Number
Source
Category
File
Line
Column
Description
ASPDescription
Ci sono tre categorie di errori che l'oggetto ASPError può riconoscere, errori interni ASP, errori dello script, errori negli
oggetti ed è in base all'errore che si genera che la descrizione dell'errore può essere più o meno precisa.
34
4.13) ASP e i Database – ADO Object
In passato la connessione a un database era una procedura piuttosto complessa in quanto era necessario conoscere una
API (Application Programming Interface) a basso livello per ogni database che si voleva utilizzare. Con la creazione di
ODBC (Open Database Connectivity) si è cercato di fornire agli sviluppatori una API universale per l'accesso ai dati;
la maggior parte dei database si è adeguata allo standard ma ODBC necessitava ancora di chiamate a basso livello per la
gestione dei dati. Inizialmente la soluzione proposta da Microsoft fu DAO (Data Access Objects) seguita da RDO
(Remote Data Objects) e infine da ADO (ActiveX Data Objects). Per ovviare al fatto che anche DAO e RDO
richiedevano che i dati fossero in formato SQL (Structured Query Language), Microsoft ha introdotto OLEDB, un
oggetto di accesso ai dati basato su COM che consente l'accesso a tutti i tipi di dati. Si può dire che OLEDB
sostituisce ODBC in quanto include un driver ODBC che assicura la compatibilità con tutte le origini dati ODBC. ADO
permette ad una pagina ASP una facile connessione ai database e tramite i suoi cinque principali oggetti incorporati
(Connection, Recordset, Command, Record e Stream) consente la manipolazione dei dati.
4.13.1) L’oggetto Connection
Prima di poter utilizzare un database, è necessario effettuare una connessione. L'oggetto Connection contiene le
informazioni relative all'archivio dati da utilizzare. L'istruzione per aprire una connessione è molto semplice:
Dim objCon
Set objCon = Server.CreateObject("ADODB.Connection")
A questo punto serve una stringa di connessione che identifichi che tipo di archivio dati si intende utilizzare. Nel caso di
un database Access la stringa si presenterebbe come segue:
objCon.ConnectionString = "Provider = Microsoft.Jet.OLEDB.4.0; Data Source = C:\percorso\nomefile.mdb"
In questo caso abbiamo utilizzato un cosiddetto Provider OLEDB specifico per il collegamento con Access. In
alternativa la stringa potrebbe fare riferimento ad un driver ODBC e allora la stringa sarebbe:
objCon.ConnectionString = "Driver = {Microsoft Access Driver (*.mdb)}; DBQ = C:\percorso\nomefile.mdb"
Le stringhe variano a seconda dell'archivio dati cui ci si vuole connettere. Una volta fatto questo, si apre definitivamente
la connessione con:
objCon.Open
In alternativa si può anche utilizzare una forma abbreviata:
Dim objCon
objCon.Open "Driver={Microsoft Access Driver (*.mdb)};DBQ=C:\percorso\nomefile.mdb"
Ipotizziamo di avere molte pagine che necessitino di connettersi allo stesso archivio dati. Come si potrebbe fare per
evitare di scrivere le stesse istruzioni in ogni pagina? In questo caso ci viene incontro l'SSI (server-side include) per
l'inclusione di file lato server. Significa che si possono creare uno o più file esterni che possono essere inclusi in tutte le
pagine che ne hanno bisogno e che possono contenere delle istruzioni che saranno elaborate dal server come se fossero
all'interno della pagina stessa. Vediamo un esempio di file da includere:
1. Dim path, objCon
2. path = "percorso\nomefile.mdb"
3. Set objCon = Server.CreateObject("ADODB.Connection")
4. objCon.Open "DRIVER={Microsoft Access Driver (*.mdb)};DBQ=" & server.MapPath(path)
Solitamente sui libri di testo si consiglia di chiamare i file da includere con una estensione .inc, io consiglio invece di
continuare a chiamare questi file con una estensione .asp. Nel caso in cui un utente scoprisse l'indirizzo diretto ad un
vostro file .inc, potrebbe aprirlo come un normale file di testo; lasciandolo come .asp questo non accadrebbe. Bene,
ipotizziamo di salvare il nostro file come inc_opendb.asp e vediamo qual è l'istruzione per l'inclusione:

Fino ad ora abbiamo parlato di connessioni cosiddette DSN-less, dove per DSN si intende Data Source Name. Le
connessioni DSN solitamente si possono utilizzare quando si ha libero accesso alle impostazioni del pannello di
35
controllo del server che ospita il nostro sito Internet. Infatti, per impostare una di queste connessioni su Windows 2000,
bisognerebbe andare in Pannello di Controllo --> Strumenti di amministrazione --> Origine dati (ODBC) --> DSN di
Sistema e impostare un nome per la connessione, il tipo di driver da utilizzare e il percorso più il nome dell'archivio
dati al quale si fa riferimento. Una volta fatto questo, l'istruzione da mettere all'interno delle pagine sarebbe la
seguente:
Dim objCon
objCon.Open "nomeDSN"
dove nomeDSN è il nome impostato nel Pannello di Controllo.
Una volta che la connessione all'archivio dati non è più necessaria, si deve chiudere la connessione e ripulire la
memoria del server come segue:
objCon.Close
Set objCon = Nothing
Esiste una collection nell'oggetto Connection chiamata Properties che contiene un'istanza dell'oggetto Property per
ogni proprietà supportata dalla connessione. Per vedere quindi le proprietà della connessione utilizzata, si potrebbe
procedere come segue:
1. <%
2. Dim path, objCon, objProperty
5. objCon.Open "Driver={Microsoft Access Driver (*.mdb)};DBQ=" & server.MapPath(path)
6. For Each objProperty In objCon.Properties
7. Response.Write objProperty.Name & ": " & objProperty.Value & " "
8. Next
9. objCon.Close
10. Set objCon = Nothing
11. %>
Oltre ad osservare tutte le proprietà, non si può fare molto con l'oggetto Connection. Per poter usare i dati contenuti in
un database, occorre utilizzare un altro oggetto di ADO, l'oggetto Recordset.
4.13.2) Recordset Object
Come per l'oggetto Connection, anche l'oggetto Recordset deve essere istanziato prima di poter essere utilizzato e le
istruzioni sono molto simili:
Dim objRs
Set objRs = Server.CreateObject("ADODB.Recordset")
La variabile objRs contiene l'oggetto ma non è sufficiente l'istanza per inserire dati nell'oggetto, bisogna utilizzare il
metodo Open, la cui forma generale è la seguente:
objRs.Open source, connection, cursortype, locktype, commandtype
source è o un oggetto Command che vedremo più avanti o una stringa che contiene le informazioni relative alla
connessione
connection è o un oggetto Connection o una stringa contenente le informazioni relative alla connessione
cursortype indica in che modo ci si potrà spostare all'interno del recordset
locktype determina in che modo sarà possibile, se lo sarà, scrivere nel database
commandtype indica come dovrà essere interpretato il parametro source
Per quanto riguarda il valore che potranno avere i parametri cursortype, locktype e commandtype, bisogna fare
riferimento a delle costanti, le costanti ADO che sono tutte raccolte in un file particolare che di norma si trova nella
cartella C:\Programmi\File Comuni\System\ado e il cui nome è adovbs.inc.
Seguono tre tabelle che riassumono i valori delle costanti ADO che interessano i parametri del metodo Open
dell'oggetto Recordset.
36
4.13.2.1) CursorType
Nome
adOpenDynamic
adOpenForwardOnly
adOpenKeyset
adOpenStatic
adOpenUnspecified
Valore
2
0
1
3
-1
Descrizione
Apre un cursore dinamico
Default. Apre un cursore "solo in avanti"
Apre un cursore di tipo keyset
Apre un cursore di tipo statico
Indica un valore non specificato per il tipo di cursore
4.13.2.2) LockType
Nome
adLockBatchOptimistic
Valore
4
adLockOptimistic
3
adLockPessimistic
2
adLockReadOnly
1
adLockUnspecified
-1
Descrizione
I record non vengono bloccati finché
non avviene un aggiornamento
batch. Questa opzione dovrà essere
utilizzata con cursori lato client e
Recordset non connessi
I record sono bloccati solo quando
si chiama il metodo update
I record sono bloccati
immediatamente quando inizia la
modifica per garantire che non vi
siano discrepanze fra quando i
nuovi valori sono stati inseriti e
quando si verifica il comando
Update
Default. I record sono di sola lettura
e non possono essere modificati.
Inoltre, non si possono aggiungere
nuovi record
La copia dei dati viene creata con lo
stesso tipo di bloccaggio
dell'originale
4.13.2.3) CommandType
Nome
adCmdFile
Valore
256
adCmdStoredProc
4
adCmdTable
2
adCmdTableDirect
512
adCmdText
1
adCmdUnknown
8
adCmdUnspecified
-1
Descrizione
Il provider interpreta il comando
(source) come un file
precedentemente salvato
(source) come una store procedure
Il provider genera una query SQL che
ritorna tutti i record della tabella
indicata dal comando (source)
Il provider ritorna tutti i record della
tabella indicata dal comando (source)
(source) come una definizione
testuale di una istruzione, ad esempio
una istruzione SQL
Il tipo di istruzione nel comando
(source) non è conosciuto
Il tipo di comando non è specificato
Vi sono vari modi per utilizzare un Recordset, ad esempio utilizzando delle connessioni implicite che però potrebbero
risultare difficili da interpretare nel caso di modifiche da apportare al codice a distanza di tempo o nel caso di lavori di
37
equipe. Solitamente si preferisce aprire esplicitamente la connessione e utilizzare l'oggetto Recordset impostando tutti i
parametri richiesti, anche quelli di default.
Per poter utilizzare queste costanti, si può agire importando il file adovbs.inc nel proprio sito e facendo l'inclusione di
tale file nelle pagine che avranno bisogno delle costanti stesse oppure dichiarando, in un file da includere o all'interno
delle pagine interessate, solo le costanti di cui si pensa di avere bisogno. Si sconsiglia vivamente l'utilizzo diretto dei
numeri nella istruzione che apre il recordset, se non altro per una maggior chiarezza del codice.
4.13.3) Leggere i dati di un database
Vediamo quindi qualche esempio di utilizzo dell'oggetto Recordset. Ipotizziamo di avere un database Access
contenente una tabella Utenti con i campi Nome e Cognome, di volerne leggere il contenuto e di riportarlo a video.
Quella che segue è una delle possibili sintassi:
1. 
2. <%
3. Dim path, objCon, objRs, strSql
7. Set objRs = Server.CreateObject("ADODB.Recordset")
8. strSql = "SELECT * FROM Utenti"
9. objRs.Open strSql, objCon, adOpenForwardOnly, adLockReadOnly, adCmdText
10. Do While Not objRs.EOF
a. Response.Write objRs("Nome") & " " & objRs("Cognome") & " "
b. objRs.Movenext
11. Loop
12. objRs.Close
13. Set objRs = Nothing
14. objCon.Close
16. %>
Dopo aver incluso il file contenente le costanti ADO, si dichiarano le variabili necessarie. Si apre la connessione, in
questo caso sfruttando il metodo MapPath dell'oggetto Server per ricavare il percorso assoluto del database, si apre il
recordset e si crea un ciclo che arriverà fino alla fine del recordset (EOF = End Of File - riga 10) prendendo in esame un
record alla volta grazie al metodo Movenext. Alla fine del ciclo, quando ormai il recordset è stato utilizzato e la
connessione non è più necessaria, è bene chiudere entrambi gli oggetti e ripulire la memoria del server (linee 13, 14, 15
e 16).
Una alternativa potrebbe essere quella di impostare le proprietà del recordset una per una e poi di aprire l'oggetto con
l'istruzione open, ovvero:
2. <%
3. Dim path, objCon, objRs, strSql
7. Set objRs = Server.CreateObject("ADODB.Recordset")
8. strSql = "SELECT * FROM Utenti"
9. objRs.Source = strSql
10. objRs.ActiveConnection = objCon
11. objRs.CursorType = adOpenForwardOnly
12. objRs.LockType = adLockReadOnly
13. objRs.Open ,,,,adCmdText
14. Do While Not objRs.EOF
15. Response.Write objRs("Nome") & " " & objRs("Cognome") & " "
16. objRs.Movenext
17. Loop
18. objRs.Close
19. Set objRs = Nothing
20. objCon.Close
38
22. %>
In questo caso i primi quattro parametri necessari al metodo open sono dichiarati esplicitamente, l'ultimo, cioè il tipo di
comando, viene invece passato come parametro, non prima però di aver aggiunto le virgole necessarie al metodo open
per capire che si tratta dell'ultimo parametro (objRso.Open ,,,,adCmdText).
Fino ad ora abbiamo visto come leggere dei dati da un database; ma quali altre operazioni sono possibili su un archivio
dati? Sono tre e precisamente inserimento di nuovi record, modifica di record esistenti e cancellazione di record
esistenti. Nonostante queste operazioni siano fattibili anche tramite l'oggetto recordset, si preferisce l'utilizzo di un
nuovo oggetto, esplicitamente creato per questo tipo di operazioni, ovvero l'oggetto Command, che vediamo nella
prossima sezione.
4.13.4) Command Object
L'oggetto Command si usa spesso quando è necessario apportare modifiche all'interno di un database, dove per
modifiche si intende inserimento di dati, modifica di dati e cancellazione di dati. L'istruzione per creare l'istanza
dell'oggetto non è diversa da quelle già viste per le Connection e i Recordset, ovvero:
Dim objCmd
Set objCmd = Server.CreateObject("ADODB.Command")
Ciò di cui necessita questo oggetto è una impostazione delle proprietà che definiscono di quale connessione, di che tipo
di istruzione e di che tipo di comando si farà uso. Poi, tramite il metodo Execute, si completa l'istruzione. Vediamo un
esempio:
2. <%
3. Dim path, objCon, objCmd, strSql, intNrOfRecords
7. Set objCmd = Server.CreateObject("ADODB.Command")
8. strSql = "INSERT INTO Utenti (Nome, Cognome) VALUES ('Dante','Alighieri')"
9. objCmd.ActiveConnection = objCon
10. objCmd.CommandText = strSql
11. objCmd.CommandType = adCmdText
12. objCmd.Execute intNrOfRecords
13. Set objCmd = Nothing
14. objCon.Close
16. Response.Write "Numero di record inseriti: " & intNrOfRecords
17. %>
In questo caso è stato aggiunto un record al nostro database che contiene una tabella Utenti con i campi Nome e
Cognome. L'operazione è stata effettuata direttamente con un comando INSERT INTO del linguaggio SQL. Una cosa
da notare è che il metodo Execute, seguito dal nome di una variabile da noi creata, è in grado di dirci quanti record sono
stati interessati dalla nostra operazione. Per compiere operazioni di modifica o cancellazione, si fa sempre riferimento a
comandi SQL, ovvero UPDATE e DELETE. Vediamo un paio di esempi:
2. <%
8. strSql = "UPDATE Utenti SET Nome = 'Giovanni', Cognome = 'Pascoli' WHERE Cognome =
'Alighieri'"
14. objCon.Close
39
16. Response.Write "Numero di record modificati: " & intNrOfRecords
17. %>
19. <%
25. strSql = "DELETE FROM Utenti WHERE Cognome = 'Pascoli'"
31. objCon.Close
33. Response.Write "Numero di record cancellati: " & intNrOfRecords
34. %>
Nel primo caso abbiamo modificato il o i record nel cui campo cognome era presente Alighieri e abbiamo sostituito con
Giovanni Pascoli, nel secondo caso invece abbiamo cancellato il o i record nel cui campo cognome era presente Pascoli.
Per concludere si può dire che anche l'oggetto Command è in grado di restituire dei recordset, oltre che apportare
modifiche, così come l'oggetto Recordset può permettere di apportare modifiche ad un database, dipende da come un
programmatore si abitua a lavorare. Per un elenco completo di esempi e caratteristiche di tutto il linguaggio, sarebbe
comunque meglio fare riferimento a documentazione ufficiale Microsoft o ad un buon manuale.
40
4.14) FileSystemObject Object
La tecnologia ASP permette di usare questo oggetto per la gestione di file e cartelle. Occorre premettere che i metodi e
delle proprietà di file e cartelle si applicano solo se si hanno i necessari permessi sul server.
4.14.1) Metodo FolderExists
Questa proprietà dell'oggetto FileSystem permette di verificare se il file o la cartella esiste. Ecco un esempio del metodo
FolderExists, (col funzionamento analogo all'oggetto fileExists per i file).
1. <%
2. Dim objFSO
3. set objFSO=Server.CreateObject("Scripting.FileSystemObject")
4. if objFSO.FolderExists(Server.MapPath("miaCartella")) then
5. Response.Write "La cartella esiste"
6. else
7. Response.Write "La cartella non esiste"
8. end if
9. set objFSO=Nothing
10. %>
si ricorda che il metodo Server.MapPath() serve per convertire un percorso logico nel relativo percorso fisico. Questa
operazione è necessaria perché il metodo .FolderExist() opera sul percorso fisico.
4.14.2) Metodo GetFile
questo metodo permette di accedere alle proprietà dell'oggetto file e va usato solo se l'oggetto file esiste.
nomeoggetto.GetFile( <nomefile>)
Attributes
DateCreated
DateLastAccess
DateLastModified
Drive
Name
ParentFolder
Path
ShortName
ShortPath
Size
Type
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
PROPRIETA' GETFILE
Accede in Read/Write agli attributi del file
Restituisce data e ora di creazione del file
Data e ora dell’ultimo accesso
Data e ora dell’ultima modifica
La lettera dell’Unità logica in cui si trova il file
Ritorna o imposta il nome del file
Restituisce un’istanza dell’oggetto Folder in cui si trova il file
Percorso del file compreso il nome
Nome Dos in formato 8.3
Nome Dos in formato 8.3 del percorso
Dimensione in byte del file
Tipo del File
<%@ LANGUAGE=”VBSCRIPT” %>
<% Optino Explicit %>
<HTML>
<BODY>
<%
Dim objFso, objFile
set objFSO=Server.CreateObject("Scripting.FileSystemObject")
if not objFSO.FileExists(Server.MapPath("prova.txt")) then
Response.Write "Il file non esiste"
else
Response.Write "Il file esiste"
set objFile=objFSO.GetFile(Server.MapPath("prova.txt"))
Response.Write "prova.txt è stato creato il "
Response.Write objFile.DateCreated
Response.Write “ ”
……………..
set objFile=Nothing
end if
41
19.
20.
21.
22.
set objFSO=Nothing
%>
</BODY>
</HTML>
4.14.3) Metodo GetFolder
Permette di accedere alle proprietà della cartella; oltre agli attribute di GetFile possiede gli attribute:
• IsRootFile vero se è una cartella radice
• Files collection contenente i riferimenti ai file contenuti nella cartella specificata
•
SubFolder collection contenente i riferimenti alle cartelle contenute nella cartella specificata
4.14.4) Metodo OpenTextFile
Per aprire un file possiamo usare il metodo OpenTextFile dell'oggetto FileSystemObject che restituisce un'istanza
all'oggetto TextStream (flusso di caratteri di testo). La sintassi è:
nomeoggetto.OpenTextFile( <nomefile>, <modo>, <crea>, <formato>)
Nomefile è il nome del file da aprire, è consigliabile usare il metodo server.MapPath
modo può assumere i valori ForReading=1, ForWriting=2 ForAppend=8
crea serve a specificare cosa fare se il file non viene trovato (true lo crea, false restituisce un messaggio d'errore)
formato specifica il set di caratteri da utilizzare 0 = ascii ( predefinito ) -1 = unicode
1.
2.
3.
4.
5.
6.
<%
Dim objFSO, objOpenFile, strPath
strPath=Server.MapPath("prova.txt”)
set objFSO=Server.CreateObject("Scripting.FileSystemObject")
set objOpenFile=objFSO.OpenTextFile(strPath, 1)
%>
4.14.5) Leggere un file
Dopo avere aperto il file possiamo leggerne il contenuto. ASP vede il file con una struttura sequenziale.
L'oggetto TextStream (il cui riferimento è ritornato dall’apertura del file con OpenTextFile) mette a disposizione tre
metodi per leggere i lati
•
read(numcaratteri)
•
readline
•
readAll
read(restituisce una stringa di lunga numcaratteri, ad ogni lettura il puntatore all'interno del file viene incrementato di
numcaratteri, pronto per la successiva lettura.
La proprietà AtEndOfStream comunica quando siamo arrivati a fine file. Nel caso in cui il numero di caratteri letti e
inferiore al valore impostato, viene restituito solo il numero corretto di caratteri.
1. <%
2. while not objOpenFile.AtEndOfStream
a. response.write objOpenFile.read(5) & “ 
3. wend
4. objOpenFile.close
5. set objOpenFile=Nothing
6. set objFSO=Nothing
7. %>
Il metodo readline permette di leggere un file una riga alla volta
il metodo readAll permette leggere il file tutto in una volta
4.14.6) Scrivere un file
E’ possibile scrivere dati in un nuovo file o in uno già esistente. Nel caso di un file già esistente i dati possono essere
accodati. Le scrivere dati in un file si usano i metodi:
• Write scrive una riga in un file di testo
• Writeline scrive una riga non fare di testo e poi aggiunge un ritorno a capo
• WriteBlankLines(n) scrivere n ritorno a capo nelle file.
42
4.15) Server Object
La sintassi per l'oggetto Server è:
Server.property/metodo
La property principale per l'oggetto Server è:
ScriptTimeout
il tempo massimo che uno script può funzionare, prima che venga "disattivato" dal server.
I metodi dell'oggetto Server sono:
CreateObject: crea un istanza di un componente del server
HTMLEncoding: applica il codice HTML ad una generica stringa
MapPath: Sostituisce ad un percorso assoluto, una path virtuale sul server oppure il path relativo alla pagina corrente in
un path fisico
URLEncode: Applica le regole di encoding, inclusi i caratteri di escape, ad una stringa
43

Introduzione alla programmazione ASP

Transcript

Documenti analoghi

Scarica il volantino delle lezioni di Scacchi

Speciale partenze peciale partenze GENNAIO / APRILE 2016 2016

Sostegno alla scuola parte civile nella Margaritone

Cerimonia d`apertura Alta Scuola Politecnica

Psicoterapia forense: una professione con prospettive

INGLESE - accesso alla webmail

christmas - Scuola Primaria

Data Base in Internet

Pico,Amalfiweb.it