Introduzione ad ASP

Home Page | Comments | Articles | Faq | Documents | Search | Archive | Tales from the Machine Room | Contribute
A cura di Davide Bianchi Una (breve) introduzione alla creazione di pagine Web "attive" utilizzando ASP, il popolare linguaggio di scripting introdotto da Microsoft.

Parte prima

Introduzione La necessita' di rendere "vive" le pagine HTML, quindi capaci di "rispondere" alle richieste degli utenti e di fornire non solo informazioni "statiche", ma calcolate al momento, ha portato alla creazione di diverse tecnologie per la "programmazione" del Web.

Active Server Pages (ASP) e' la tecnologia messa a punto da Microsoft per consentire agli sviluppatori la possibilita' di creare pagine "attive" utilizzando come piattaforma di sviluppo Internet Information Server (IIS) o Personal Web Server, i Web Server distribuiti da Microsoft su Windows NT Server e su Windows NT Workstation/Windows 95/98.

Fondamentalmente, ASP e' un metodo che consente allo sviluppatore di inserire all'interno di una pagina HTML del codice VBScript o JScript. Tale codice viene elaborato da un apposito interprete quando l'utente richiama la pagina, il risultato dell'elaborazione e' in genere una pagina HTML contenente del testo che e' stato creato "al volo" dal codice stesso. La pagina risultante viene spedita al browser dell'utente che ha iniziato la richiesta.

I vantaggi di tale tecnologia sono:

  1. L'utente riceve sempre e solo una pagina HTML, quindi il suo browser e' ininfluente
  2. Gli script sono facili da fare e veloci da mantenere, basta modificare lo script ed aggiornare la pagina per verificare subito i risultati.
  3. Non sono richiesti particolari ambienti di programmazione, il volgare Blocco Notes di Windows e' piu' che sufficiente.

Gli svantaggi sono un po' meno evidenti invece:

  1. Il codice ASP e' facilmente visibile (quindi copiabile) all'interno delle pagine
  2. Richiede un Web Server per poter funzionare.
  3. ASP e' limitato all'ambiente Microsoft

Quest'ultima limitazione non e' del tutto vera: data la popolarita' della tecnologia, varie societa' (la principale Chili!Soft) hanno sviluppato "moduli aggiuntivi" che consentono di utilizzare ASP anche su Web Server e sistemi non Microsoft. Per maggiori informazioni http://www.chilisoft.com.
Prerequisiti Per poter provare l'ASP occorre necessariamente installare un Web Server sulla propria macchina, come minimo basta il Personal Web Server di Microsoft, che trovate on-line direttamente sul sito della Microsoft (cercate per PWS), oppure viene distribuito insieme a FrontPage. Voci non confermate dicono che dovrebbe anche essere sul CD di Win 95/98. Il PWS distribuito insieme a FrontPage di suo NON supporta l'ASP, occorre installare il modulo aggiuntivo ASP.EXE che si trova nella cartella dei moduli nel "60 Minutes Intranet Kit".

Vedere anche le faq.

Una volta installato il Web Server ed attivato il supporto ASP, possiamo procedere alla creazione delle pagine.
Prima pagina ASP Una pagina ASP non e' altro che una pagina HTML che pero' prende l'estensione .ASP. La pagina puo' contenere del "codice", questo "codice" deve essere inserito tra i "tag" <%; e %>.

In alternativa e' possibile mettere il codice tra i tag <SCRIPT> e </SCRIPT>, il risultato e' lo stesso, solo che i tag <SCRIPT> consentono anche di definire il linguaggui che si vuole adoperare per scrivere il codice.

ASP consente infatti di utilizzare due differenti linguaggi: JScript o VBScript.

JScript e' un "porting" di JavaScript fatto dalla Microsoft, mentre VBScript e' una versione di Visual Basic dove e' rimasta la sintassi basic-like, ma e' stata rimossa interamente l'interfaccia visuale. Nel seguito dell'articolo si utilizzera' VBScript.

Una pagina ASP minima potrebbe essere una cosa del tipo:


<HTML>
<BODY>
<% ="Una pagina ASP" %>
</BODY>
</HTML>
I Tag <% e %< indicano l'inizio e la fine del codice, il codice in se' stesso in questo caso e' composto molto semplicemente dal comando "=" che ha l'effetto di "buttare" nella pagina HTML prodotta l'espressione seguente. Questa pagina non fa' altro che scrivere "Una pagina ASP" dentro al documento HTML.

Ovviamente questo non e' tutto cio' che si puo' fare. Pero' per fare di piu' occorre cominciare a studiare un po' di teoria.
Istruzioni, Commenti, Maiscole e Minuscole

Uno script ASP e' composto da istruzioni, ogni istruzione occupa una linea ed e' terminata da un ritorno a capo.


istruzione
istruzione
istruzione
...
Lo script viene letto dall'alto in basso ed eseguito nello stesso modo, quindi le istruzioni poste all'inizio dello script sono eseguite per prime. Esistono particolari istruzioni (cicli o controlli di flusso) che permettono di eseguire parti di codice ripetitivamente o a seconda determinate condizioni, quindi il "flusso" di esecuzione puo' non essere completamente lineare.

I commenti sono parte di testo che l'interprete ASP ignora quando incontra. Un commento viene iniziato con l'apostrofo ('). Tutto quello che segue l'apostrofo fino al termine della linea viene considerato commento ed ignorato.

Quindi se vogliamo "eliminare" temporaneamente un'istruzione basta metterci un'apostrofo davanti per "disattivare" la linea.

VBScript non considera maiuscole e minuscole, quindi le istruzioni possiamo scriverle sia in maiuscolo che in minuscolo che in una combinazione dei due. Anche le variabili definite dall'utente seguono la stessa regola, quindi AA, aa ed Aa per VBScript sono esattamente la stessa cosa.

Io preferisco usare una combinazione di maiuscole e minuscole per migliorare la leggibilita' del codice, ma queste sono fisime mie.

Il codice ignora gli spazi in eccesso e le righe vuote. Per questo motivo e' buona norma utilizzare questi elementi per avere del codice il piu' leggibile possibile. Un codice leggibile significa un codice facilmente mantenibile.

Quindi abbondare con i commenti ed usare righe bianche e spazi extra per spaziare le istruzioni in modo da renderle piu' leggibili ed il "flusso" logico piu' facilmente identificabile.
Variabili e valori

Per elaborare dei dati questi "dati" bisogna pure ficcarli da qualche parte, quindi abbiamo bisogno di Variabili, cioe' contenitori dove mettere le informazioni che ci consentano di reperirle quando ci servono.

In ASP le variabili possono essere lette e scritte senza problemi, inoltre non hanno "tipo", la stessa variabile puo' essere usata per contenere numeri, lettere, frasi intere, valori vero/falso e cosi' via.

Una variabile ASP non deve essere "dichiarata" prima di usarla, ma e' buona norma farlo. La "dichiarazione" non ha alcun effetto veramente. La dichiarazione di una variabile si effettua con il comando 


DIM nomevariabile
dove nomevariabile e' il nome che vogliamo assegnare alla variabile, il nome deve cominciare con un carattere e puo' contenre caratteri, numeri ed il simbolo _ (sottolineato), non puo' contenere segni di interpunzione, ed i caratteri ? $ % o cose cosi'.

Per esempio: 


Dim laMiaBellaVariabile
e' una variabile chiamata laMiaBellaVariabile". La lunghezza massima del nome e' di 255 caratteri, quindi conviene assegnare alle variabili dei nomi che siano "indicativi" di "a cosa serve" quella cosa. Evitiamo di avere A, B, C etc. etc. che poi non ci si ricorda mai a cosa servono.

Una volta che l'abbiamo dichiarata la variabile possiamo usarla, per assegnare un valore alla variabile usiamo 


variabile = valore/espressione
dove valore/espressione e' un qualunque valore fisso o una espressione.

I valori numerici sono indicati semplicemente con un numero. Per esempio 5 indica il numero 5 e basta. I valori di tipo testo invece, devono essere rachiusi tra doppi apici ("), questo per consentire all'interprete ASP di riconoscere i valori da eventuali istruzioni scritte male e fare un po' di controlli in piu'.

Per esempio: 


Dim variabile1
Dim variabile2

variabile1 = "A"
variabile2 = 10 + 3 + 7
Queste 4 righe definiscono due variabili ed assegnano alla prima il valore "A" (testo), mentre la seconda viene "caricata" con il valore 20 (numerico) risultante dall'operazione 10+3+7.

Possiamo tranquillamente visualizzare il valore di queste variabili nei nostri script usando l'istruzione <%= nel modo seguente: 


<HTML>
<BODY>

<%
  Dim variabile1
  Dim variabile2
  
  variabile1 = "A"
  variabile2 = 10 + 3 + 7
%>

<%=variabile1 %>
<%=variabile2 %>

</BODY>
</HTML>
Le variabili vengono automaticamente convertite quando e' necessario, nel caso precedente abbiamo una variabile che e' una Stringa, cioe' contiene uno o piu' caratteri, mentre la seconda e' un numero. Pero' se facciamo una cosa del tipo: 

variabile1 = variabile1 & variabile2
L'operatore & (aggiunta) "trasformera'" automaticamente variabile2 in stringa prima di unirla a variabile1, che in questo modo conterra' "A20". Notare che variabile2 non e' stata toccata da tutto questo ed e' ancora un numero.

Le variabili "esistono" all'interno della singola pagina ASP, se da una pagina ASP "passiamo" ad un'altra pagina, anche all'interno della stessa applicazione, le variabili dichiarate e valorizzate nella prima pagina vengono distrutte ed i valori vanno persi.

Per passare valori tra due diverse pagine vi sono pero' diversi modi che vedremo piu' avanti.
Operatori

Sono usati per effettuare calcoli o "trasformazioni" tra variabili, questi operatori sono: 

+     somma
-     differenza
*     moltiplicazione
/     divisione
MOD   resto (modulo)
& concatenazione (aggiunta)
La priorita' di questi operatori e' quella solita matematica, cioe' la moltiplicazione e la divisione sono fatte prima di somme e sottrazioni, possiamo usare le parentesi ( ) per rachiudere le eventuali operazioni che vogliamo siano eseguite prima.

Ma ancora ci manca di immetterli in qualche modo questi dati. E questo e' compito di una parte importantissima per qualunque sistema di programmazione: l'Input e l'Output. Ovvero, come fare ENTRARE ed USCIRE i dati.
Input ed Output

Dato che stiamo parlando di programmazione Web, l'input deve essere effettuato tramite una pagina HTML, e l'output idem.

Nella fattispecie l'input avverra' tramite una FORM HTML, mentre l'output verra' prodotto su una pagina HTML. Perche' la nostra form "trasmetta" i dati ad ASP e' necessario che il parametro ACTION del tag FORM "punti" alla nostra pagina ASP.

Definendo una form come segue: 


<FORM ACTION="pagina.asp" METHOD=POST>
<INPUT TYPE=TEXT NAME="prima"><BR>
<INPUT TYPE=TEXT NAME="seconda"><BR>
<INPUT TYPE=SUBMIT VALUE="Ok">
</FORM>
Produrremo una maschera con due campi di testo denominati rispettivamente "prima" e "seconda", ed un pulsante Ok, che una volta premuto avra' l'effetto di "spedire" i valori alla pagina denominata PAGINA.ASP.

Come li recuperiamo i valori dalla pagina ? I singoli valori spediti possono essere facilmente reperiti usando: 


variabile = Request("nomecampo")
dove nomecampo e' il nome del campo di input specificato nella form. Al momento lasciamo perdere cosa e' "Request" e perche' si usa. Limitiamoci ad usarlo.

Quindi, la form seguente invia dua campi denominati "prima" e "seconda", che possiamo recuperare usando: 


variabile1 = Request("prima")
variabile2 = Request("seconda")
Una pagina ASP, potendo contenere elementi HTML potrebbe essere la destinataria di una form contenuta in se' stessa. Non c'e' niente di strano in tutto questo.

Per esempio se mettiamo il codice seguente in una pagina chiamata Pagina.Asp: 


<HTML>
<BODY>

Immettere il proprio nome:
<FORM ACTION="pagina.asp" METHOD=POST>
<INPUT TYPE=TEXT NAME=Nome VALUE=<% =Request("Nome") %>><BR>
<INPUT TYPE=SUBMIT VALUE="Ok">
</FORM>
<P>

<% ="Ciao " & Request("Nome") %>

</BODY>
</HTML>
Abbiamo una pagina che richiama se' stessa e ci mostra i valori che sono stati immessi nella stessa pagina.

In questo modo abbiamo visto come acquisire dei dati da una Form in una variabile ASP e come visualizzare gli stessi dati usando <% =variabile %>. C'e' un altro modo pero' di "scrivere" i dati nella pagina: usare l'istruzione Response.Write espressione , dove espressione e' una variabile o una qualunque altra cosa che possa essere visualizzata.

Come prima, lasciamo perdere che cosa sia "Response", limitiamoci ad usarlo al momento.

La stessa pagina di prima puo' essere rivista come: 


<HTML>
<BODY>

Immettere il proprio nome:
<FORM ACTION="pagina.asp" METHOD=POST>
<INPUT TYPE=TEXT NAME=Nome VALUE=<% =Request("Nome") %>><BR>
<INPUT TYPE=SUBMIT VALUE="Ok">
</FORM>
<P>

<% 
  Response.Write "Ciao " & Request("Nome")
%>

</BODY>
</HTML>
Con queste semplici informazioni possiamo creare un primo programmino utile: un convertitore lire/euro:


<HTML>
<BODY>

Immettere il valore in Lire:

<FORM ACTION="conv.asp" METHOD=POST>
Immettere il valore in Lire:
<INPUT TYPE=TEXT NAME=Lire VALUE=<% =Request("Lire") %>>  
<INPUT TYPE=SUBMIT VALUE="Converti">
</FORM>
<P>

<% 
  
  Dim conversione
  Dim Lire 
  
  ' fattore di conversione: 1 E = 2000 L
  conversione = 2000
  
  ' leggo il valore delle lire
  Lire = Request("Lire")
  
  ' converto in euro
  Lire = Lire * ( 1/conversione)
  
  ' mostro il risultato
  Response.Write "L'equivalente in Euro e' " & Lire
  
%>

</BODY>
</HTML>
Se mettiamo questo codice in un file denominato conv.asp, abbiamo un semplice programma di conversione. Il parametro di conversione "conversione", e' fissato a 1 euro=2000 lire, ma e' facilmente modificabile.
Controlli

Un controllo ci permette di verificare il valore di una o piu' variabili e di prendere delle decisioni in funzione dei risultati delle verifiche.

Il controllo si effettua con le istruzioni 


If  Then
  .... (a)
End If
oppure 

If  Then
  .... (a)
Else
  .... (b)
End If
Le istruzioni nel blocco (a) sono eseguite se il controllo e' positivo, in caso contrario sono eseguite le istruzioni nel blocco (b).

I controlli che possono essere eseguiti sono molteplici, ma tutti devono essere chiaramente definiti, cioe' occorre che il controllo sia VERO oppure FALSO in modo certo.

E' possibile verificare "in negativo" una certa condizione usando Not davanti alla condizione o <> al posto di =.

Per esempio dire

If Nome <> "" e' equivalente a dire If Not ( Nome = "" ).

In entrambi i casi la condizione e' verificata se Nome NON E' nullo.

Per esempio ecco un "rifacimento" della pagina di prima che verifica che l'utente abbia immesso un nome.


<HTML>
<BODY>

<FORM ACTION="pagina.asp" METHOD=POST>
Immettere il proprio nome:
<INPUT TYPE=TEXT NAME=Nome VALUE=<% =Request("Nome") %>><BR>
<INPUT TYPE=SUBMIT VALUE="Ok">
</FORM>
<P>

<%

  Dim Nome
  
  Nome = Request("Nome")
  
  ' visualizzo il nome solo se non vuoto ("").
  If Nome <> "" Then
    Response.Write "Ciao " & Nome
  End If
  
%>

</BODY>
</HTML>
Cicli

Un ciclo consente la ripetizione di un certo blocco di codice per un certo numero di volte oppure fintanto che' una certa condizione rimane verificata.

I Cicli sono ottimi per eseguire operazioni ripetitive in maniera rapida.

Vi sono fondamentalmente 3 tipi di cicli: FOR/NEXT, WHILE/LOOP e DO/WHILE.

Il ciclo For/Next si basa su una variabile usata come conteggio, la varibile viene incrementata o decrementata ad ogni ciclo fino a che non raggiunge un valore/limite predefinito, a questo punto il ciclo termina. Questo tipo di ciclo e' ottimo se si sa a priori quante volte farlo eseguire. Il ciclo si definisce come: 


For variabile = valore_iniziale To valore_finale [Step incremento]
  ....
Next
La parte [Step] puo' non essere indicata, in questo caso la variabile viene incrementata ogni volta di 1. Nel caso si voglia un incremento negativo (da 10 a 0 per esempio), occorre specificare uno Step -1.

E' possibile anche specificare Step maggiori di 1, in questo caso la variabile verra' incrementata del valore di incremento. Quando il programma raggiunge "Next", viene verificato il valore di variabile, se questo e' maggiore di valore_finale, il ciclo termina e viene eseguita l'istruzione successiva a Next, in caso contrario l'esecuzione riprende dalla linea successiva a For.

Esempio: 


<HTML>
<BODY>

<%

  Dim variabile1

  For variabile1 = 1 To 10
  
    Response.Write "Questa qui' e' la linea #" & variabile1 & "<br>"
    
  Next
  
%>

</BODY>
</HTML>
Il risultato di questo codice e' la creazione di 10 righe numerate da 1 a 10.

E' possibile "rompere" il ciclo in un momento qualsiasi all'interno del blocco richiamando l'istruzione Exit For, questo ha l'effetto di "saltare" alla riga successiva al Next in qualunque caso.

I cicli possono anche essere chiusi uno dentro l'altro come scatole cinesi, l'unica avvertenza e' di usare sempre variabili diverse per i singoli cicli.

Per esempio questo codice: 


<HTML>
<BODY>

<%

  Dim variabile1
  Dim variabile2
  Dim variabile3

  For variabile1 = 0 To 9

    variabile3 = ""
    For variabile2 = 0 To 9
    
      variabile3 = variabile3 & variabile1 & variabile2 & "   "
    
    Next
  
    Response.Write variabile3 & "<BR>"
    
  Next

%>

</BODY>
</HTML>
Stampa una "griglia" da 00 a 99.

Il Ciclo Do While/Loop viene invece controllato da un test all'inizio del ciclo. Il ciclo viene ripetuto finche' il test viene soddisfatto. Quando il test non viene piu' soddisfatto l'esecuzione riprende dalla prima riga dopo "Loop".

Il ciclo si definisce come: 


Do While 
  ....
Loop
Si suppone che, nel mezzo del "corpo" del ciclo, qualche cosa vengo effettuato percui ad un certo punto la "condizione" diventera' falsa ed il ciclo terminera', in caso contrario si ottiene un ciclo infinito ed ad un certo punto il Server Web "tronchera'" l'elaborazione con un bel TimeOut.

E' possibile uscire forzatamente dal ciclo Do While richiamando una Exit Do

Una forma "alternativa" di ciclo Do e' Do Until, in questo caso il ciclo e' ripetuto finche' la condizione e' falsa, e viene concluso quando la condizione diventa vera,


Do Until 
  ...
Loop
E' anche possibile spostare la condizione in fondo al ciclo: 

Do
  ...
Loop While/Until
La differenza sostanziale di avere la condizione in fondo invece che al principio, e' che nel primo caso se la condizione non e' verificata fin dall'inizio il ciclo non viene eseguito nemmeno una volta, mentre nel secondo caso almeno una volta nel "corpo" ci si passa di sicuro.

I cicli Do/Loop sono ottimi quando non si sa con precisione quante volte si dovra' ripetere una operazione, ma la ripetizione dipende da qualche fattore esterno.

Per esempio, ecco il codice di prima rifatto con Do/While invece che con For/Next: 


<HTML>
<BODY>

<%

  Dim variabile1
  Dim variabile2
  Dim variabile3

  variabile1 = 0
  
  Do While variabile1 <= 9

    variabile3 = ""
    variabile2 = 0
    Do While variabile2 <= 9
    
      variabile3 = variabile3 & variabile1 & variabile2 & "   "
      variabile2 = variabile2 + 1
    
    Loop
  
    Response.Write variabile3 & "<BR>"    
    variabile1 = variabile1 + 1
    
  Loop

%>

</BODY>
</HTML>
I cicli ed i controlli If/Then permettono di controllare l'esecuzione dello script e di eseguire le operazioni di elaborazione dei dati.

Un esempio un po' piu' complesso: estrazione dei numeri primi.

Una procedura di estrazione dei numeri primi non e' molto complessa: dato un numero 'n', questo e' primo se:

  1. 'n' e' dispari
  2. 'n' non e' divisibile per nessun numero tra 2 ed n-1

Un 'estrattore' quindi dovrebbe prendere solo numeri dispari (partendo da 1), e quindi verificare se il numero in analisi e' divisibile per un qualunque numero tra 2 ed n-1.

Possiamo scrivre il codice usando due cicli For: il primo ciclo "estrae" i numeri da verificare, il secondo ciclo prova a dividere il numero.


<HTML>
<HEAD>
<TITLE>Estrattore di numeri primi</TITLE>

<BODY>

<FORM ACTION="GRID.ASP" METHOD=POST>
Limite di estrazione:<INPUT TYPE=TEXT NAME=LIMITE VALUE="100">
<INPUT TYPE=SUBMIT VALUE="Ok">
</FORM>

<FONT FACE=COURIER SIZE=2>
<%

  Dim limite    ' limite di estrazione dei numeri
  Dim numero    ' numero in fase di test
  Dim divisore  ' numero che divide
  Dim risul     ' risultato
  Dim stringa   ' stringa di testo da visualizzare
  
  ' inizializzo la stringa
  stringa = ""
  
  ' inizia il programma vero e proprio.
  ' per prima cosa verifico se ho un limite di estrazione
  
  ' leggo il limite e lo converto in un numero intero (1)
  limite = CInt( Request("Limite") )
  
  If Request("Limite") <> "" And limite > 0 Then

    Response.Write "<B>Elenco dei numeri primi tra 1 e "
    Response.Write limite & "</B><P>"
      
    ' Ok, inizio il ciclo di estrazione, uso uno Step 2 per
    ' saltare tutti i numeri pari.
    
    For numero = 1 To limite Step 2
  
      ' precarico il "risultato"
      risul = " " & numero
      
      ' adesso "numero" contiene il numero in fase di test,
      ' passo alla fase di controllo,
      ' solo se il numero e' maggiore di 2
      If numero > 2 Then
      
        ' prendo tutti i numero tra 2 ed n-1.
        For divisore = 2 To ( numero-1 )
        
          ' provo a fare la divisione
          If numero MOD divisore = 0 Then

            ' il numero non e' primo
            risul = ""
            
            ' non c'e' senso a continuare
            Exit For
            
          End If
          
        Next
        
      End If
      
      ' aggiungo il risultato alla sequenza
      stringa = stringa & risul
      
      ' se la stringa e' maggiore di 30 caratteri, stampo
      If Len( stringa ) > 30 Then
        Response.Write stringa & "<BR>"
        stringa = ""
      End If
  
    ' prossimo numero    
    Next

    ' stampo l'ultima sequenza
    Response.Write stringa & "<BR>"
    
  End If
  
%>
</FONT>

</BODY>
</HTML>
Potete provare l'estrattore con un limite qualunque di numeri primi da estrarre, l'unica avvertenza e' che oltre il 5000 diventa piuttosto lento.

Il codice limite = CInt( Request("Limite") ) consente di leggere il limite imposto, convertendolo in un numero intero. Questo perche' le variabili VBScript non hanno tipo, quindi per default VBScript leggerebbe il testo immesso come testo, ma a noi serve un valore numerico. CInt (Convert Int), consente di avere un valore numerico che possiamo poi verificare.

Il codice For numero = 1 To limite Step 2 ci assicura di prendere i valori da 1 fino al limite, saltando i numeri pari. Step 2 significa che al numero viene aggiunto ogni volta 2, quindi tutti i numeri estratti sono dispari.

Il codice For divisore = 2 To ( numero-1 ) consente di estrarre tutti i numeri tra 2 e numero-1, in modo da verificare la divisibilita; del numero stesso. L'uso di una variabile come limite di un ciclo For non ha nulla di strano.

Il codice If numero MOD divisore = 0 Then verifica se numero e' divisibile per divisore. Se lo e', MOD (resto) sara' 0, ed il test verra' soddisfatto, in caso contrario il ciclo riprendera'.

Quando il ciclo piu' interno si conclude i casi sono due: "risul" contiene il numero estratto (che e' primo), oppure non contiene piu' nulla perche' e' stato cancellato dal controllo. In entrambi i casi viene "aggiunto" alla sequenza. Aggiungere un testo nullo ad un altro testo non ha alcun effetto.

A questo punto verifichiamo la lunghezza del testo attuale e se e' maggiore di 30 caratteri (Len ritorna la lunghezza del testo), il testo viene scritto sulla pagina dei risultati, quindi il testo stesso viene azzerato per poter contenere la linea successiva.

Fino ad ora abbiamo visto come eseguire il codice, come fare calcoli, come fare entrare ed uscire i dati come fare dei test etc. E' il momento di vedere come fare qualche cosa di piu' interessante. E' il momento di parlare degli Oggetti.
Gli Oggetti

Cosa e' un "oggetto" ? lasciando perdere tutta la tiritera della programmazione Object Oriented, un "oggetto" e' un qualche "arnese" che ci viene fornito da una libreria (DLL) esterna all'ASP stesso. Quindi le "capacita'" dell'oggetto in questione sono specifiche dell'oggetto e non dipendono da ASP. Anche eventuali errori o problemi che l'oggetto puo' dare sono esterni ad ASP.

A che servono gli oggetti? Ad "estendere" le capacita' del linguaggio ed a fornire l'accesso a funzionalita' molto utili che sarebbe riduttivo o eccessivamente complicato mettere "dentro" al linguaggio stesso.

Come si crea un Oggetto? Ogni oggetto viene creato usando CreateObject("nometipo"), dove "nometipo" e' il nome del Tipo dell'oggetto. I tipi di oggetto che sono disponibili sono molti, ma dipende tutto se la libreria (DLL) che fornisce tale tipo e' stata installata o meno sul sistema. In generale i tipi disponibili sono 3 o 4. Eventuali tipi aggiuntivi potrebbero non essere disponibili.

Se la libreria non e' installata correttamente o ci sono dei problemi, la CreateObject ci ritornera' un errore, sara' nostro compito a questo punto installare correttamente la DLL oppure risolvere i problemi che si verificano.

Come si usa un oggetto ? Ogni oggetto ha delle Caratteristiche (o Proprieta') e delle Funzionalita' (o Metodi), che sono tipici dell'oggetto stesso. Per esempio supponiamo di avere un oggetto che rappresenta una cartella (Folder) sul disco. Questo oggetto potrebbe avere delle proprieta' che sono: il nome della cartella, la dimensione occupata (in KByte), il numero di file contenuti, l'elenco dei file contenuti e cosi' via. I Metodi associati potrebbero essere "Cancella" per distruggere la cartella e tutto il suo contenuto, "Sposta" per muovere la cartella con il suo contenuto e cosi' via.

Che ce ne facciamo degli oggetti ? Utilizzando gli appositi oggetti con ASP e' possibile:

  1. richiedere informazioni relative al Client dell'utente
  2. salvare e reperire informazioni tra diverse pagine ASP
  3. condividere informazioni tra tutti gli utenti del sito ASP
  4. collegarsi a database e leggere/scrivere dati
  5. accedere a file e cartelle sul disco del server
  6. inviare e-mail direttamente da ASP
  7. effettuare Upload di file dal browser dell'utente al server
e cose cosi'.

Per richiamare un Metodo o interrogare una Proprieta' di un oggetto si utilizza: 


oggetto.metodo/proprieta
Per esempio, supponendo di avere un oggetto Pippo con proprieta' Pluto: 

Pippo.Pluto = "1"
Assegna alla proprieta' Pluto il valore "1". Allo stesso modo: 

variabile = Pippo.Pluto
leggo il valore della proprieta' Pluto nella variabile denominata "variabile".
Gli oggetti standard

Alcuni oggetti sono standard e vengono sicuramente forniti con ASP, altri oggetti devono essere installati a parte, ma in generale sono disponibili. Cominciamo a vedere gli oggetti che sono sicuramente forniti. Questi oggetti non devono essere creati con la CreateObject, ma vengono automaticamente creati dal server e sono disponibili in ogni pagina ASP.

Application e Session

L'oggetto Session rappresenta il collegamento tra il client (browser) ed il server. Esiste un oggetto Session per ogni browser collegato al sito. L'oggetto Session viene creato automaticamente quando il browser si collega, e viene distrutto automaticamente circa 20 minuti dopo che il browser si e' scollegato o dopo 20 minuti di inattivita' del browser stesso.

L'oggetto Application viene creato non appena un browser si collega al sito e viene distrutto dopo 20 minuti che l'ultimo browser si e' scollegato dal sito. Esiste un solo oggetto Application per tutto il sito e tutti i browser condividono lo stesso oggetto.

Sessione ed Application sono usati per memorizzare informazioni da passare tra una pagina ASP e l'altra o per memorizzare informazioni "globali" per tutto il sito. La differenza fondamentale e' che Session e' privato dell'utente, quindi le informazioni inserite nella Session rimangono di proprieta' del singolo utente e non vanno ad influire sugli altri utenti del sito, mentre Application e' condiviso tra tutti gli utenti.

Per memorizzare delle informazioni nella Session o nella Application si utilizza: 


Session("nomeinfo") = valore/variabile
Application("nomeinfo") = valore/variabile
Per esempio: 

Session("NomeUtente") = "non disponibile"
Crea una variabile di Sessione denominata "NomeUtente" e gli assegna il valore "non disponibile".

Per reperire il valore di una variabile si usa: 


variabile = Session("nomeinfo")
variabile = Application("nomeinfo")
Per esempio: 

utente = Session("NomeUtente")
Reperisce la variabile "NomeUtente" e la assegna alla variabile denominata "utente". Se una variabile di Session/Application non e' mai stata definita e viene richiesta, viene ritornata una stringa nulla ("") e non viene segnalato nessun errore.

Request e Response

Abbiamo gia' usato prima Request e Response, pur senza preoccuparci di cosa rappresentavano, adesso e' il momento di occuparcene.

Request rappresenta le informazioni che sono "arrivate" alla pagina ASP dal browser quando la pagina ASP stessa e' stata richiamata.

Response rappresenta la pagina HTML in fase di costruzione che verra' rispedita al Client al termine dell'elaborazione e ci permette di scrivere sopra la stessa.

Request e Response forniscono diverse proprieta' e metodi: Request("nomecampo") ritorna il valore del campo di input denominato "nomecampo", abbiamo gia' usato questo metodo precedentemente, senza sapere cosa significava.

Response.Write "testo" permette di scrivere nella pagina di risposta il testo indicato. Abbiamo gia' usato questo metodo in modo molto semplice prima.

Per esempio, il codice seguente recupera tutte le variabili identificative del client e le visualizza nella pagina:


<HTML>
<BODY>
<%
	For Each var IN Request.ServerVariables
		Response.Write var & "=" 
		Response.Write Request.ServerVariables( var )
		Response.Write "<br>"
	Next
%>
</BODY>
</HTML>
Server

L'oggetto Server rappresenta il Server Web e ci consente di svolgere diverse attivita', tra cui la creazione di nuovi oggetti.


Set Var = Server.CreateObject("tipooggetto")
Crea un nuovo oggetto di tipo "tipooggetto" e lo assegna alla variabile Var. Una volta creato possiamo usare la variabile come se fosse un oggetto del tipo indicato.

Per ulteriori informazioni sugli oggetti interni di ASP vedere Gli oggetti di ASP.

Comments

Max length of comments: 1000 chars.

1 commento
Andrea dice il 26/11/2008 15:57:
Grazie D., questo mi è tornato proprio utile!

Add a comment (max 1000 chars)

Comment from:
Comment:

L'Autore Davide Bianchi, works as Unix/Linux administrator for a "network security" company of Haarlem.
Contacts: mail: davide AT onlyforfun.net , ICQ: 268751033, Jabber: davideyeahsure AT gmail.com Skype: davideyahsure
Contribuire Volete contribuire? Leggete come!
Copyright This site is made by me with blood, sweat and gunpowder, if you want to republish or redistribute any part of it, please drop me (or the author of the article if is not me) a mail.
This site was composed with VIM, now is composed with VIM and the (in)famous CMS FdT.

This site isn't optimized for vision with any specific browser, nor it requires special fonts or resolution.
You're free to see it as you wish.
Web Interoperability Pleadge is this a valid html document?

Ultimo aggiornamento: 01 Novembre 2000