 |
Il cookie: questo sconosciuto!
A parte gli scherzi, attorno ai cookies é nato e cresciuto col passare del tempo una specie di alone mistico, che ha fatto diventare questi dolci biscottini dei biscotti da cane.
I cookies altro non sono che dei file di solo testo che vengono mandati dal server al client per conservarci diverse informazioni. In molti casi sono davvero utili, specie per applicazioni con un budget molto basso, o che necessitano di velocità. Oramai oltre il 98% dei browser in giro li supporta (tra Internet Explorer 3.x, Navigator 2.x e Opera 2.x più le versioni successive).
A questo punto dunque, é necessaria una svolta: far capire finalmente ai nostri utenti che i cookie li usiamo solo per rendere la loro navigazione migliore. Per fare questo basta una piccola nota alla fine di ogni pagina con una spiegazione dell'uso che se ne fa sul nostro sito.
Preparati i nostri visitatori, adesso prepariamo tutto quello che ci serve. Naturalmente il modo migliore per scrivere codice ASP a mano é proprio il vecchio e caro Blocco Note (alias Notepad). Apriamolo ed incominciamo la nostra avventura.
Questo é un esempio del codice necessario per creare il cookie:
Response.Cookies("miosito").Expires=#January 1, 2000#
Response.Cookies("miosito").Path="/miadir/"
Response.Cookies("miosito").Secure=FALSE
Il significato non é molto complicato. In Expires va indicata la data
in cui il cookie scadrà. In Path il percorso che ha il privilegio di
scrivere/leggere sul cookie (se omesso viene preso quello corrente), mentre
con Secure si specifica se il cookie é sicuro (crittografato, via SSL,
etc...) oppure no. Nella maggior parte dei casi si deve impostare su FALSE.
Queste tre righe sono obbligatorie per far generare il cookie in maniera
corretta.
A questo punto, per salvarci dentro dei valori si deve proseguire in questo modo:
Response.Cookies("miosito")("nome")="Daniele"
Response.Cookies("miosito")("cognnome")="Bochicchio"
insomma, seguire una sintassi del genere
Response.Cookies("nomecookie")("nomedellachiave")="valore"
Il codice deve essere inserito prima di ogni altro tag HTML (quindi prima di <html> o eventuali commenti) altrimenti il server genererà un errore, a meno che non abbiamo inpostato su True il comando Response.Buffer.
Invece per avere il valore di una chiave del nostro cookie, ad esempio per
inserirla come valore in una campo di una form, basterà fare una cose
del genere:
<input name="nome" type="text" value="<%=Request.Cookies("miosito")("nome")%>">
<input name="nome" type="text" value="<%=Request.Cookies("miosito")("cognnome")%>">
A questo punto siamo perfettamente in grado di manipolare un cookie. Ci restano due cose da imparare. Come fare a sapere se il cookie contiene già delle chiavi, e come cancellarlo.
Per sapere se abbia o meno delle chiavi, bisogna usare
Request.Cookies("miosito").HasKeys
che conterrà una risposta booleana (TRUE o FALSE) che indica se il cookie ha chiavi oppure no.
Invece per cancellarlo, basterà far eseguire un comando del genere:
Response.Cookies("miosito")=""
Attenzione quindi ad impostare direttamente il valore di un cookie senza la chiave, perché ad esempio scrivendo
Request.Cookies("miosito")="Daniele"
tutte le chiavi precedentemente memorizzate (nome e cognome) andranno perse, dato che si va a scrivere sulla chiave principale che cancella tutte le altre. Lo stesso vale se io ho impostato solo la chiave principale e vado ad impostare altre chiavi.
I cookie, come dicevamo, sono un ottimo modo per aiutarvi, l'importante é usarli con parsimonia, spiegare ai visitatori che non fanno male, e sopratutto fare tanta pratica. Sembra facile, ma ci potrebbero essere delle difficoltà dietro l'angolo... E' sempre meglio provare e riprovare. Solo allora si potrà essere sicuri di aver imparato a maneggiare i nostri biscottini!
L'oggetto Session é molto utile nella realizzazione di applicazioni ASP avanzate (e non) per la sua potenza. Infatti tramite questo oggetto é possibile memorizzare per tutta la durata della navigazione dell'utente in alcune variabile dei valori che saranno poi disponibili alle pagine successive in maniera (quasi) trasparente per l'utente finale (il visitatore).
Questo perché praticamente l'oggetto Session si serve di un cookie dove
memorizza il numero (chiamato ID) del visitatore, che é unico
per ognuno e che non verrà mai ripetuto.
Perciò su alcuni browser
particolarmente vecchi potrebbe non funzionare. Comunque su questi browser
anche le tue pagine non dovrebbero essere visualizzate correttamente, dato
l'arretratezza delle funzioni che supportano, per cui il gioco vale la
candela, eccome!
Questo modo di memorizzare le informazioni può essere molto ma molto
utile ad esempio per far scegliere all'utente una lingua e mantenerla
per tutta la sessione, senza bisogno di creare sottodirectory speciali
per le diverse lingue, ma gestendo il tutto all'interno della stessa
pagina, che una volta letto il valore dell'oggetto Session
fornirà il contenuto localizzato in base a quanto specificato.
Ovviamente questo é solo un esempio, ma si possono fare molte altre
cose utili e divertenti per migliorare la navigabilità del proprio
sito, come cambiare il contenuto di una pagina ad ogni nuovo accesso
del proprio visitatore, ruotare banner e così via...
Questo oggetto, nel suo utilizzo é molto simile all'oggetto
application, essendo entrambi oggetti
built-in, cioé richiamabili direttamente nello script.
Quindi per assegnare un varole ad una variabile Session,
basterà scrivere:
Session("miavar")="ciao!"
E questo é tutto quello che serve per scrivere su una variabile Session. Nient'altro. Molto semplice, più semplice dell'oggetto Application.
Analogamente, l'unica cosa da scrivere per leggerne il contenuto é:
miavar=Session("miavar")
Come si é avuto modo di vedere, l'oggetto Session é molto facile da usare, molto potente e molto versatile. L'unica raccomandazione necessaria da fare é di non abusare della sua potenza, anche perché un eccessivo uso di variabili Session può portare ad un decadimento delle prestazione (riferimento).
L'oggetto Application può essere molto utile in diverse implementazioni, dato che serve per condividere informazioni tra tutti gli utenti di tutte le pagine .asp di una applicazione, dove per applicazione si intende l'insieme di tutte le pagine che si trovano sotto una virtual directory.
Questo sistema può ritornare molto utile ad esempio quando bisogna tenere traccia di azioni compiute dagli utenti connessi in quel determinato momento, oppure se si hanno particolari necessità e, non per ultimo, per migliorare le prestazioni generali delle proprie pagine (riferimento).
In ogni caso, l'utilizzo dell'oggetto Application é molto simile
a quello dell'oggetto Session.
Entrambi sono oggetti built-in, cioé richiamabili direttamente nello
script.
Così per assegnare un varole ad una variabile Application,
basterà scrivere:
Application("miavar")="ciao!"
Con un semplice comando del genere, però, si rischia di generare degli errori, dato che può scrivere in una variabile Application un utente per volta. Per ovviare a questi problemi, é necessario quindi usare dei comandi che vadano a bloccare la variabile Application, ci scrivano sopra, e la rilascino per altri cambiamenti da parte di altre pagine. Tutto ciò viene effettuato molto velocemente, in maniera del tutto trasparente per l'utente che legge la pagina. Il codice da inserire in questo caso é quindi:
Application.Lock
Application("miavar")="ciao!"
Application.UnLock
Il primo comando non fa altro che bloccare la modifica (non la lettura, perché quella é disponibile a tutti in qualsiasi momento), scrivere sulla variabile, quindi sbloccare la variabile stessa e metterla al servizio di altre richieste. I due metodi usati sono Lock ed UnLock. Il loro funzionamento é molto semplice tanto da non meritarsi una spiegazione particolare.
Adesso che abbiamo imparato a scrivere su una variabile Application, non ci resta che imparare a ricavarne il valore. Niente di più semplice. L'unica cosa da scrivere é:
miavar=Application("miavar")
A questo punto avremo memorizzato nella variabile miavar il contentuto della variabile Application miavar, e da questo punto in poi, tramite questa variabile locale, sarà possibile usarne il valore a nostro piacimento, essendo pronta per essere stampata, manipolata, convertita come più riteniamo utile.
Tramite i famosi oggetti built-in é possibile manipolare diversi dati presenti nelle pagine web, e non ultimo quello relativo ai dati contenuti in una form, un semplice modulo web che può contenere tutte le informazioni che vogliamo.
Per farlo le ASP mettono a disposizione i comandi
Request.Form("nomeinput")
e
Request.QueryString("nomeinput")
che servono, rispettivamente, per ricavare il valore contenuto nel campo "nomeinput" nel caso si sia usato come metodo il post (che inserisce i valori direttamente nella pagina) o quello get (che aggiunge i valori all'indirizzo della pagina che processerà la richiesta).
Un generico
Request("nomeinput")
dovrebbe andare bene se si usano entrambi i medodi, a seconda della tipologia di uso che se ne fa in quel momento della pagina.
Usare i dati di una form é quanto di più facile sia possibile fare tramite le ASP. Omettendo il nome del campo di cui si vuole ricavare il valore, si ottiene la lista di tutti i campi e dei rispettivi valori.
Per fare questo bastano
Request.Form
e
Request.QueryString
i quali ci daranno, come già detto, la lista di tutti i campi con i rispettivi valori.
Questo uso può essere molto utile se ad esempio si vuole prima accertarsi che si sia inserito qualcosa. Ad esempio per rifiutare che l'utenti passi dei parametri col metodo get, si può usare uno script del genere:
if Len(Request.QueryString)>1 then
Redirect("errore.asp")
end if
In questo caso se si tenta di passare tramite il metodo get dei parametri alla pagina, si genererà un errore che rimanderà alla pagina errore.asp, dove dovrà essere contenuto un testo di spiegazione. E' anche possibile modificare a proprio piacimento lo script, facendogli compiere determinati comandi al verificarsi di tale situazione.
Tramite il controllo
Scripting.FileSystemObject é possibile accedere a qualsiasi
file che si trova sul server su cui viene eseguito il codice ASP.
Quindi non solo i canonici file che sono inseriti nelle directories
effettivamente mappate sotto il web server, ma qualsiasi file.
Questa caratteristica é molto utile in diverse circostanze, specie
quando non si ha altro modo di accedere a questi dati se non di
caricarli da file esterni.
E si sa, quando si vuole fare qualcosa facilmente e senza perdere troppo tempo, le ASP sono imbattibili. Per accedere in lettura ad un file, serve solamente questi due comandi.
Set FileObject=CreateObject("Scripting.FileSystemObject")
Naturalmente al posto di MyFile deve essere inserito il nome
del file, digitando il suo percorso completo (tipo c:\tempo\prova.txt)
oppure facendolo mappare direttamente al server, nel caso il file
in questione risieda in una delle directory accessibile al web
server, tramite il comando
MyFile=Server.MapPath("/aspoint/prova.txt")
che in questo caso indica al server di mappare (cioé tradurre nel
corrispondente indirizzo DOS) l'indirizzo della virtual directory
"/aspoint", dando come risultato una cosa del tipo
"c:\web\ospiti\aspoint\".
A questo punto, però, siamo
solo all'inizio. Infatti abbiamo un altro parametro da specificare,
e cioé la variabile tipo, che va ad indicare allo script con
quale metodo si intende aprire il file. Abbiamo a disposizione le
seguenti opzioni: 1 apre in lettura, 2 apre in scrittura,
8 apre ed aggiunge in scrittura dopo la fine del file.
Una volta specificate queste informazioni, i metodi usati per leggere
o scrivere sul file appena aperto sono semplicissimi.
Per leggere una riga basta il comando:
testo=InStream.ReadLine()
testo=InStream.ReadAll
testo=InStream.ReadLine() va bene nel caso io debba leggere
un numero prefissato di linee. Ma se io non so quante linee possa
contenere il mio file, come faccio?
Con questo script si risolve
anche questo problema:
Do While not InStream.AtEndOfStream
testo=InStream.ReadLine
Response.Write("<br>Il contenuto della linea é: "&testo)
loop
Naturalmente si possono fare tutte le modifiche necessarie per adattare lo script alle proprie esigenze.
Se invece si vuole saltare una linea, il comando é InStream.SkipLine()
Per scrivere su un file, abbiamo due possibili strade: aggiungere il testo da scrivere in coda a quanto già contenuto nel file aperto, oppure scrivere su un file nuovo.
Nel primo caso, si usa lo stesso codice di cui sopra per iniziare l'oggetto ed aprire il file, mentre per scriverci si usa
testo="prova testo"
InStream.WriteLine(testo)
La sintassi va bene anche per il secondo caso, in cui cambia il tipo di inizializzazione del file, che sarà:
Set FileObject=CreateObject("Scripting.FileSystemObject")
in cui MyFile ha lo stesso valore che ha nel primo caso.
L'unica differenza sta nel nome che abbiamo dato all'oggetto che ci
permette di accedere al nostro file, per cui per scriverci sopra dobbiamo usare
testo="prova testo"
OutStream.WriteLine(testo)
data appunto la diversità nel nome dell'oggetto che usiamo per accedere al file.
Dopo aver fatto i nostri comodi, esiste anche un comando per chiudere il file e liberare risorse, che nella fattispecie é
OutStream.Close
E' da notare che prima di ogni metodo (quello che sta a destra del punto) é necessario inserire il nome dell'oggetto così come é stato creato tramite l'istruzione
o l'istruzione equivalente
e che é appunto oggetto.
Ed ora, sei finalmente pronto per manipolare i tuoi files! Ma stai
attento, perché non é poi così facile come potrebbe sembrare, perché
potrebbe bastare sbagliare un percorso per avere risultati non richiesti.
Perciò quando lavori con l'accesso ai file, occhio al codice!
Sicuramente tutti gli sviluppatori ASP si sono imbattutti prima o poi in questa domanda: "ma quale impatto in termini di carico ha la mia pagina ASP sul server?".
Questa é una serie di consigli da usare per migliorare le performance delle tue pagine:
Se le tue pagine leggono su file che non cambiano spesso o quasi mai, invece di usare l'ogetto FileSystem Object, é più performante caricare i files in questione in un array a livello Application in GLOBAL.ASA. GLOBAL.ASA é un file (opzionale) dove si possono specificare eventi e quindi assegnare script e dichiarare oggetti a livello session o application. GLOBAL.ASA non visualizza testo all'utente ma conserva informazioni ed oggetti, gestendo gli eventi a livello application e session.
Quindi basta richiamare dalle tue pagine l'array con i dati. Questo implica leggere sul file una volta per server, anziché una volta per ogni pagina per ogni utente. E' necessario poi creare comunque una pagina speciale per permettere eventuali aggiornamenti, in quanto una volta caricato in una variabile a livello application, questa rimarrà identica a se stessa fino a quando non verrà aggiornata.
E' possibile implementare il tutto tramite un array oppure un oggetto Dictionary. Il file sarà letto solo una volta e ciò permetterà di accedere alle informazioni tramite l'array o l'oggetto Dictionary senza aver bisogno di fare una richiesta ogni volta che fosse necessario leggere informazioni da quel file.
Nel caso fosse necessario aggiornare il contenuto dei dati, é possibile creare una pagina riservata contenente uno script che esegue il comando Application.Lock, aggiorna le informazioni ed infine esegue il comando Application.Unlock che mette a disposizione di tutti i dati.
I commenti HTML (quelli contenuti nella pagine tra <!-- e -->) rallentano le prestazioni, specie con IIS 3. Rimuovendoli si rende il tutto più veloce.
Se usi molti <%=...%> per scrivere in diverse parti del codice, prova a concentrare il tutto in un unico Response.Write.
E' un buon sistema cercare di dividere la pagina in blocchi di HTML e script, in modo da velocizzare il caricamento. Per ogni coppia di <% %> il server esegue un comando che va a rallentare le prestazioni globali del server.
Per non togliere risorse al server, é più indicato usare come dimensione di un array quella più bassa o meglio ancora a quella ottimale, e solo se necesario, usando Redim portarla alla dimensione necessaria. Tutto ciò significa risparmiare un po' di memoria, invece di allocarla e spendere qualche mega di ram.
Se stai scrivendo in VBScript oppure stai accendo a qualche controllo ActiveX o script java, cerca di non usare le "Public variables". Questa chiave é al momento usata solo per compatibilità future, per cui é meglio usare Dim, dato che non esiste nessun vantaggio nell'usare l'altro metodo.
Cerca di evitare di usare MapPath se possibile, cercando di usare il percorso completo. Usando MapPath IIS deve andare a leggere il percorso con una speciale richiesta che tradotto vuol dire decadimento delle prestazioni.
Ogni volta che si accede alle cosidette "Server Variables", il web server le richiede tutte, per poi fornire alla pagina ASP solo quella desiderata. Quindi se io voglio ad esempio sapere solamente il valore dell'header HTTP_ACCEPT, il server andrà per prima cosa a richiedere tutta lista delle variabili, quindi ritornerà la variabile che ho chiesto. Tutto questo influsice sulle prestazioni. Naturalmente nel corso di una pagina, dopo aver ricevuto la prima variabile, per le altre non ci sarà un decadimento delle prestazioni, dato che il server le ha già memorizzate tutte.
Usando Option Explicit Visual Basic genererà un messaggio d'errore qualora si cerchi di accedere a variabili non dichiarate. Le variabili local non dichiarate sono lente più delle global. Inoltre questa opzione può essere utile per scovare variabili non dichiarate nel tuo codice.
L'ogetto Session serve per memorizzare durante la sessione di navigazione di un singolo utente, diverse informazioni. Le variabili contenute in questo oggetto vengono mantenute durante la navigazione dell'utente da una pagina all'altra.
Il web server crea automaticamente un ogetto Session ogniqualvolta viene richiesta per la prima volta una pagina all'interno di una determinata application e la distrugge quando non ci sono più richieste (di solito dopo 10 minuti, ma il valore é impostabile tramite il commando Session.Timeout=15, dove in questo caso abbiamo impostato il TimeOut della session a 15 min).
E' possibile disattivare l'oggetto Session, ma si perdono molte caratteristiche avanzate delle ASP in questo modo. E' meglio usarlo con parsimonia, evitando di memorizzarci tante variabili.
... testa le tue modifiche! Testare la velocità di risposta di una pagina é il modo migliore per capire se tutto il tuo lavoro ha dato i frutti che hai sperato, oppure si é trattato solo di una perdita di tempo.
Un'ultimo consiglio: scrivi le tue pagine ASP con stile! Cerca di essere il più chiaro possibile con te stesso, in modo da rendere divertente e veloce il lavoro di aggiornamento delle pagine stesse!
Hai tanto sentito parlare delle Active Server Pages, aka ASP, ma non hai proprio idea se il tuo server le supporta? Allora questo articolo é dedicato a te!
Il modo migliore per vedere se il tuo server le usa é provare! prova a caricare sul tuo server via FTP (o nel metodo che usi) una pagina dal nome prova.asp che abbia come contenuto
<%="Ciao!! Questa é la mia prima pagina ASP!"%>A questo punto, se effettivamente sulla vostra pagina vedrete apparire Ciao!! Questa é la mia prima pagina ASP! senza nessun altro codice, allora il vostro server supporta pienamente le ASP! Adesso puoi finalmente buttarti su materiale, help in linea, documentazione e naturalemente su questo sito, per riuscire a trarre il massimo vantaggio da questa fantastica tecnologia!
Questa é una lista dei server che supportano direttamente le ASP
| Nome del server | Sistema operativo |
| MS Internet Information Server 4 | Windows NT Srv 4 |
| MS Internet Information Server 3 | Windows NT Srv 3.51 o sup. |
| MS Personal Web Server 4 | Windows NT Wrks 4 - Windows 95/98 |
| MS Personal Web Server 1.x | Windows 95 |
E' possibile però usare le ASP anche con altri web server, tramite un estensione nota come Chili!ASP, prodotta dalla Chili!Soft, che però é a pagamento!
Queste sono le istruzioni per far funzionare Chili!ASP sotto Apache 1.3b6
1) Installa Chili!ASP come se stessi lavorando con il server MS IIS. Scegli la configurazione di default. Se non hai installato IIS riceverai un messaggio di errore che ti avverte di tale mancanza. Ignoralo e procedi con l'installazione.
2) Dopo aver completato l'installazione ed effettuato i vari reboot
necessari, esegui WebSite Pro.
Adesso sei finalmente pronto ad usare le ASP sul tuo server!
Con le ASP, non mi stancherò mai di ripeterlo, si può fare tutto quello che la vostra mente é in grado di immaginare, specie se si usano i server component.
Comunque lo scopo di questo articolo é di spiegare in maniera il più completa possibile come sia facile, ad esempio, generare delle immagini automatiche tramite una pagina asp, in modo che, per esempio, facendo riferimento direttamente a questa pagina tramite il tag HTML img sia possibile richiamare un'apposita pagina in modo che esegua delle operazioni, come memorizzare in un db quale sia l'immagine servita, quindi impostare il MIME type su image/gif e come ultima operazione andare a recuperare l'immagine. Semplice, non é vero?
A dire il vero, questo é un caso limite, molto molto limite. Infatti esistono dei server component in grado di fare questo in modo migliore. Ma l'importante é sapere che si può fare!
Un esempio più utile (e che io uso nei miei siti qualora mi serva) può essere quello di inserire i propri script client-side (tipo JavaScript o VBScript) in un file separato, con estensione .asp, e dargli come MIME type application/x-javascript". Tutto quello che dobbiamo fare per una cosa del genere é scrivere nel file in questione, il più in alto possibile:
Response.ContentType="application/x-javascript"
In questo modo il browser saprà (indipendentemente dall'estensione) che in quel file c'é uno script JS. I browser, infatti, non si basano sull'estensione di un programma per capire di cosa si tratti, ma si rifanno sia all'estensione che al MIME type, qualora la prima sia sconosciuta.
In questo modo si possono creare molti "giochetti" davvero divertenti. Praticamente si può assegnare qualsiasi MIME type ad una pagina ASP, sempre a patto di conoscerlo e che il sistema che richiederà la pagina sia in grado di suppportarlo.
Quella che segue é una lista dei MIME type più utili.
E' necessario attenersi alle specifiche del formato per avere un risultato funzionante e privo di errori. Per fare questo é consigliato approfondire gli aspetti legati ai vari formati, al fine di evitare di incappare in inutili errori.
Per tutti i formati vale la seguente sintassi:
Response.ContentType="tipo/sottotipo"
| Tipo/Sottotipo (Estensione) | Descrizione |
| text/html (.htm) | Semplice testo html. Non é necessario specificarlo, in quanto é il tipo di default. |
| text/plain (.txt) | Testo semplice, leggibile con qualsiasi computer. |
| text/css (.css) | File di testo contenente informazioni per la formattazione delle pagine HTML tramite CSS. |
| image/gif (.gif) | Immagine GIF (graphic interlaced file). |
| image/jpeg - image/pjpeg (.jpg) | Immagine JPEG. Il secondo é di tipo progressive. |
| image/tiff (.tif) | Immagine TIFF. Molto usata nel DTP. |
| image/xbm - image/x-xbitmap (.xbm) | Immagine in formato xbm. Poco usato. |
| image/x-png - image/png (.png) | Immagine in formato PNG (ping). Dovrebbe essere il nuovo formato standard per lo scambio di immagini sulla rete. |
| image/bmp (.bmp) | Immagine in formato bitmap, in assoluto il formato per le immagini più diffuso in ambiente Windows. |
| image/x-wmf (.wmf) | Immagine in formato Windows MetaFile. Attualmente poco usato. |
| audio/wav - audio/x-wav (.wav) | File audio wave. Molto usati in ambito PC. |
| audio/aiff - audio/x-aiff (.aiff) | Formato audio molto diffuso in ambiente UNIX. |
| audio/basic (.au) | Formato audio comparabile al wave, molto diffuso in rete. |
| audio/x-pn-realaudio (.ram) | Formato molto diffuso in rete per lo streaming (trasmissione in diretta) di audio. |
| audio/mid (.mid) | Formato audio contenente le informazioni per essere riprodotto in qualsiasi strumento MIDI (come la scheda audio di un computer). |
| video/quicktime (.qt) | File video QuickTime, molto diffuso in ambiente MAC e Windows. |
| video/mpeg (.mpeg) | File video MPEG. Sono caratteristici per la loro alta qualità ed il loro minimo ingomrbo. |
| video/avi - video/x-msvideo (.avi) | Formato video standard per gli utenti Windows. |
| video/vdo (.vdo) | Formato VDOLive, utilizzato per la trasmissione video in Internet. |
| message/rfc822 | File contenente le informazione necessarie per la ricezione/spedizione in un messaggio di posta elettronica. |
| application/x-javascript (.js) | File contenente il codice JavaScript. Viene richiamato dall'interno di una pagina HTML. |
| application/x-x509-ca-cert (.crt) | File con certificato digitale. Utilizzato per l'autenticazione, anche in ambito e-commerce. |
| application/x-zip-compressed (.zip) | Archivio compresso. Molto utilizzato per lo scambio di dati. |
| application/x-internet-signup (.ins) | File contenente i comandi per l'iscrizione automatica ad un provider tramite Internet Explorer. |
| application/msword (.doc) | File di Microsoft Word |
| application/pdf (.pdf) | Portable Document Format é un formato universale per lo scambio di dati (immagini, testi, etc). |
| application/x-iphone (.iii) | File di Internet Phone. Utilizzato per videotelefonate via Internet. |
| application/x-cdf - application/cdf (.cdf) | File contenente le specifiche per l'utilizzo di un canale di Internet Explorer. |
| model/vrml - x-world/x-vrml (.wrl) | Modello Virtual Reality Markup Language per la realtà virtuale. |
| Tra parentesi é specificata l'estensione predefinita. | |
Mettere il proprio script JS in una pagina ASP può essere utile per proteggere il
proprio lavoro da occhi indiscreti.
Si può fare servendosi del
MIME type.
Basta inserire nella pagina ASP che
richiama il nostro script, una linea del genere:
Session("js")="ok"
e farla seguire dal richiamo al file .asp che contiene lo script,
<script language="JavaScript" src="js.asp"></script>
A questo punto, inserendo nella nostra pagina ASP una semplice routine di verifica dell'oggetto Session, tutto dovrebbe andare a gonfie vele!
if Session("js")="ok" then
Response.ContentType="application/x-javascript"
...codice da eseguire...
else
...messaggio di errore in HTML puro
end if
Session("js")="ko"
In qualsiasi caso, sia che venga richiamato da una pagina autorizzata (che abbia in sostanza il comando Session("js")="ok" al proprio interno), sia che si cerchi di accedervi direttamente o senza permesso, lo script va ad impostare su ko il valore dell'oggetto Session, in modo che sia impossibile, se non tramite la sola pagina .asp che richiama la nostra JS-ASP accedere al suo contenuto!
Ed il nostro lavoro sarà al sicuro da occhi indiscreti. Sfido chiunque a trovare una soluzione ad una cosa del genere...
Questa pagina dimostra come creare un semplice contatore di accesso (testuale o con immagini) tramite ASP. Con l'aiuto di alcuni oggetti per creare/scrivere/leggere file sul server, é possibile farlo in pochi secondi.
L'oggetto FileSystem é usato per accedere al file in cui vanno memorizzati gli accessi. L'oggetto TextStream é usato per leggere e scrivere sul file in questione.
Per un contatore testuale questo codice é più che sufficiente:
myfile="c:\inetpub\www\mypath\counter_mysite.txt"
Set fs=CreateObject("Scripting.FileSystemObject")
Set a=fs.OpenTextFile(myfile)
visita=CInt(a.ReadLine)
if Len(Session("visita"))=0 then
Session("visita")=visita
visita=visita+1
a.close
Set a=fs.CreateTextFile(myfile, True)
a.WriteLine(visita)
end if
a.Close
Response.Write visita
La prima azione effettuata da questo script é aprire il file (il percorso deve essere adattato al proprio caso, anche con l'ausilio di un MapPath), leggere l'ultimo valore, convertirlo in interi, quindi verificare che questa sia la prima visita effettuata alla pagina e solo in questo caso aggiungere 1 al numero. In questo modo si ottine un contatore di solo testo. L'ultima parte dello script scrive sul file l'incremento e chiude il tutto, visualizzando il numero delle visite. Per far funzionare il tutto deve essere inserito nel percorso che viene dichiarato nella variabile myfile un file con lo stesso nome specificato nella variabile e che abbia come contentuo 0 (a numeri) oppure il numero di visitatori da cui si vuole partire.
Se invece serve un contatore che visualizzi dei numeri come immagini, si può usare questo script
myfile="c:\inetpub\www\mypath\counter_mysite.txt"
Set fs=CreateObject("Scripting.FileSystemObject")
Set a=fs.OpenTextFile(myfile) visita=CInt(a.ReadLine)
if Len(Session("visita"))=0 then
Session("visita")=visita
visita=visita+1
a.close
Set a=fs.CreateTextFile(myfile, True)
a.WriteLine(visita)
end if
a.Close
lung=CInt(Len(visita))
visita=CStr(visita)
Response.Write "<img src=""immagini/contdx.gif"">"
for i=1 to lung
Response.Write "<img src=""immagini/cont"&Mid(visita,
i, 1)&".gif"">"
next
Response.Write <"img src=""immagini/contsx.gif"">"
Il funzionamento di questo script é simile al precedente, con la sola differenza che questo ha bisogno che sotto la cartella immagini, si trovino dei file con nome cont0.gif....etc fino a cont9.gif che rappresentino i vari numeri. Sono anche necessari i file contdx.gif che rappresenta il bordo destro ed il file contsx.gif che rappresenta il border sinistro. Il funzionamento é del tutto simile allo script precedente, escluso la routine di visualizzazione delle immagini. L'incoveniente di uno script di questo tipo rispetto ad un cgi é che i numeri vengono richiamati come singole immagini, per cui ci può essere un caricamento non proprio sincronizzato, a differenza di quanto avviene con gli script CGI. Il punto di forza é che si può praticamente cambiare di tutto ed in più usare come immagini quelle che si preferisce, oltre al fatto di appesantire di meno il server, riuscendo ad occupare minori risorse, grazie al fatto che il tutto viene generato direttamente dal file .asp
Microsoft Active Server Pages (ASP) consente la creazione di applicazioni lato server utilizzabili da diversi tipi di browser. Essenzialmente, ASP non è altro che VBScript eseguito sul server. Quando viene richiesta una pagina, il codice script genera l'HTML. Questa è la chiave dell'ASP: un client non vede mai il codice, ma solo l'HTML risultante, riconoscibile da tutti i browser.
Un aspetto fondamentale di ASP è l'utilizzo dei componenti, che non sono altro che ActiveX come quelli che si possono creare con Visual Basic, Visual
C++, Visual J++ , Delphi, eccetera.
Il più utile tra tutti i componenti ASP è Database Access,
detto anche ActiveX Data Object, o ADO. Nella pubblicazione di database su Web si utilizza questo
componente e gli oggetti in esso contenuti per leggere e scrivere su fonti dati Open Database Connectivity (ODBC).
COSA OCCORE:
Come detto prima, ADO è lo strumento necessario per operare sulla fonte di dati ODBC (il vostro database). Di questo componente bisogna assolutamente conoscere l'oggetto Connection, indispensabile per il suo utilizzo.
L'oggetto Connection viene creato tramite il metodo CreateObject dell'oggetto Server e utilizza una variabile per ricevere il riferimento ad un'oggetto. Una volta creato, l'oggetto Connection può essere utilizzato per aprire una connessione con qualsiasi fonte di dati ODBC.
Quest'operazione avviene con l'ODBC Data Source Administrator, generalmente localizzato nel Pannello di controllo. La realizzazione della sorgente di dati avviene selezionando la pagina System DNS nel property sheet ODBC data source Administrator. In questa pagina premere il pulsante Add... per visualizzare un elenco di tutti i driver ODBC disponibili. Dopo aver selezionato il driver ODBC appropriato premere il pulsante Finish che introduce un nuovo oggetto.
Il codice seguente stabilisce una connessione con una fonte di dati ODBC Microsoft Access Driver chiamata Registrazioni.
<%
' dichiaro la variabile che conterrà l'oggetto Connection
Dim conn
'creo l'oggetto Connection
Set conn = Server.CreateObject("ADOBD.Connection")
'apro la connessione con la fonte di dati
conn.Open "Registrazioni"
%>
In alcuni casi, ad esempio per non costringere il proprio amministratore a creare una quantità elevata di sorgenti ODBC, è possibile creare, ma solo nel caso in cui il database sia Access, una connessione DSN-less.
Tutto quello per compiere un'operazione di questo tipo è usare al posto del codice precedente, quest'altro:
<%
' dichiaro la variabile che conterrà l'oggetto Connection
Dim conn
'creo l'oggetto Connection
Set conn = Server.CreateObject("ADOBD.Connection")
'apro la connessione con la fonte di dati
conn.Open "driver={Microsoft Access Driver (*.mdb)};dbq="&Server.MapPath("/data/database.mdb")
%>
Naturalmente al posto di "/data/database.mdb" va inserito l'esatto percorso di ricerca in cui è stato salvato il file mdb.
Una volta aperta la connessione con la fonte di dati, è possibile utilizzare un oggetto Recordset per recuperare le informazioni. L'oggetto Recordset consente di eseguire le istruzioni SQL restituendo un insieme di record filtrati tramite la query. Come l'oggetto Connection, Recordset viene creato utilizzando l'oggetto Server.
<%
' dichiaro la variabile che conterrà l'oggetto Recordset
Dim rs
'creo l'oggetto Recordset
Set rs = Server.CreateObject("ADOBD.Recordset")
'Eseguo la query SQL SELECT
rs.Open "SELECT *", conn
%>
Dopo aver recuperato i record è possibile leggerli con i metodi MoveFirst, MoveLast, MoveNext e MovePrevious. Il metodo Write dell'oggetto Response consente di dare in output i dati sulla pagina in HTML.
<TABLE>
<%
Do While not rs.EOF
%>
<TR>
<TD><% rs.Fields("colonna").Value %></TD>
</TR>
<%
rs.MoveNext
Loop
%>
</TABLE>
ESEMPIO DI INTERROGAZIONE DI DATABASE
PAGINAZIONE
Spesso una query restituisce molte più righe di quante possano essere visualizzate. Ad esempio un motore di ricerca Internet può avere migliaia di riferimenti rispetto alla parola chiave cercata ed è chiaro che non è consigliabile visualizzare tutti i dati in un'unica pagina.
La paginazione consente di distribuire i risultati su più pagine. ADO
supporta la paginazione tramite le proprietà PageSize, PageCount a AbsolutePage dell'oggetto
Recordset.
La proprietà PageSize specifica quante ennuple devono essere
contenute nella pagina, e tramite la proprietà PageCount, è
possibile determinare il numero complessivo di pagine. E' Possibile accedere ad una
determinata pagina tramite la proprietà AbsolutePage. Il
programma richiede un solo file ASP per eseguire tutto il processo di navigazione.
ESEMPIO DI INTERROGAZIONE CON PAGINAZIONE
|
SQL (che si pronuncia sequel) è l'abbreviazione di Structured Query Language e rappresenta lo standard per la definizione, l'interrogazione e l'aggiornamento di database relazionali. In questo tutorial mi limiterò nel spiegare la più semplice e generale struttura del linguaggio SQL.
Le istruzioni in SQL vengono raggruppate a blocchi; ciascun blocco contiene tre tipi di clausole, la clausola SELECT, la clausola FROM, e la clausola WHERE.
SELECT nomi di attributi
FROM nomi di relazioni
WHERE condizione di ricerca sui dati,
Ad esempio, l'interrogazione per trovare il valore di IDENTIFICATIVO per l'azienda TRANSISTOR è espressa come segue:
SELECT IDENTIFICATIVO
FROM AZIENDE
WHERE NOMEAZIENDA = TRANSISTOR
Le tre clausole individuano rispettivamente:
Un'altra importante parola chiave è DISTINCT che prevede l'eliminazione delle ripetizioni dai risultati. Si utilizza immediatamente dopo la parola chiave SELECT.
SELECT DISTINCT Provincia
FROM Indirizzo
Le condizioni elementari che compaiono nella clausola WHERE possono avere altre forme, oltre a quelle già viste per l'operatore di selezione. Esse sono le seguenti.
I primi due casi selezionano rispettivamente i records in cui il valore dell'attributo è uguale ad uno dei valori elencati nella lista, e i records in cui il valore dell'attributo è compreso fra i due valori specificati o uguale ad uno di essi.
IN seleziona i records della relazione in cui il valore dell'attributo sia uno di quelli elencati nella lista di valori.
La parola chiave LIKE esegue un confronto selezionando i
records in cui l'attributo specificato nella stringa <stringa incompleta>
ha come valore una stringa che può essere rappresentara dalla stringa incompleta.
Molto comoda è la parola chiave COUNT, che calcola il numero di records oppure il numero di valori distinti che soddisfano una certa condizione.
OPERAZIONI DI INSERIMENTO
Le operazioni di inserimento vengono specificate per mezzo dell'istruzione INSERT che ha due possibili strutture:
INSERT INTO <nome relazione> (<lista
attributi>)
VALUES (<lista valori>)
INSERT INTO <nome relazione> (<lista
attributi>)
SELECT (<lista valori>)
OPERAZIONI DI ELIMINAZIONE
L'eliminazione di records viene specificata per mezzo dell'istruzione DELETE.
DELETE FROM <nome relazione>
WHERE <condizione>
che elimina dalla relazione tutti i records che soddisfano la condizione.
OPERAZIONI DI MODIFICA
La modifica di records viene specificata per mezzo dell'istruzione UPDATE.
UPDATE <nome relazione>
SET <attributo> = <espressione>
<attributo> = <espressione>
<attributo> = <espressione>
.......
WHERE <condizione>
|
Per una semplice interrogazione non serve conoscere molto di VBScript. Comunque il
liguaggio è un insieme di semplici caratteristiche basilari di Visual Basic for
Application.
VBScript supporta l'accesso ai dati usando sia Data Access Object (DAO) e Remote Data
Object (RDO).
Un componente che vi puo' essere utile per costruire il vostro archivio è il File Access.
Questo componente, consente l'accesso ai file di testo nel sito web. E' composto da due
oggetti:
Il primo serve per aprire e chiudere il file, TextStream serve
per leggere e scrivere sul file. Per creare l'oggetto FileSystem
si usa sempre il metodo CreateObject dell'oggetto Server.
CreateTextFile crea un nuovo file e
OpenTextFile ne apre uno esistente.
Per accedere al file db.txt:
Set objFile = Server.CreateObject("Scripting.FileSystemObject")
Set objStream = objFile.OpenTextFile("db.txt")
Per leggere nel file si usa il metodo ReadLine.
Per ulteriori informazioni sulla manipolazione dei files, è disponibile questo articolo.
Questo articolo spiega agli sviluppatori ASP come raggiungere un livello di conoscenza superiore sulle ASP. I component server-side (da ora server component) sono utili per moltissime ragioni; le più importanti: un componente migliora la velocità e la portabilità di una soluzione, protegge tutto il vostro lavoro, dato che si tratta di una DLL (Dynamic Link Library) e che quindi non espone direttamente il codice sorgente.
Ma cos'è esattamente un server component? E' una specie di controllo Active-X, ma invece di essere client side, come quelli sviluppati per Internet Explorer o lo stesso ambiente Visual Basic, sono usati in ambiente server. La differenza fondamentale tra client e server component è che l'ultimo ha l'assoluto divieto di esporre interfaccia utente, trattandosi di un componente che gira sulla macchina server, e che quindi non deve esporre finestre o pulsanti, in quando queste verrebbero visualizzate sullo schermo della macchina server.
Cosa serve per creare un server component? Un linguaggio che supporti
lo standard COM, come ad esempio, Java, Visual C++, Delphi, o Visual Basic.
Tutti i linguaggi menzionati, escluso VB, richiedono una mole di lavoro
impressionante per iniziare a conoscere i fondamenti. Visual Basic è
molto più semplice da usare e da imparare di qualsiasi altro linguaggio,
tant'è che molta gente confonde il Visual Basic Script, quello che si
usa nelle pagine ASP, con le ASP stesse, che invece di essere un linguaggio
è un contenitore, una tecnologia.
Detto questo, per operare serve un sistema operativo a 32 bit (Window 95,
98 or NT) su cui devono girare le ASP, tramite IIS o Personal Web Server (PWS).
E' necessario avere installato Visual Basic (dalla ver. 5 in poi) sullo
stesso computer su cui dovranno essere sviluppati i components, altrimenti
sarà impossibile per VB usare il riferimento agli oggetti ASP.
A questo punto è necessario far partire Visual Basic. Apparirà una finestra che chiede come partire. Selezionare "ActiveX DLL".
Dopo aver fatto doppio click su ActiveX DLL, Visual Basic
crea per te un progetto ed una classe predefinite. E' consigliabile
rinominare sia Project1 che Class1 secondo i nostri gusti. E' importante
scegliere bene il nome, dato che per richiamare il component nelle nostre
pagine sarà necessario usare Project1.Class1.
Fatto questo, è necessario fare un riferimento a "Microsoft Active
Server Pages Object Library", la libreria necessaria per usare
gli oggetti built-in ASP nel component. Dal menu di Visual Basic, bisogna
scegliere "Project", quindi "References". Una finestra
mostrerà tutti i riferimenti disponibili sul tuo sistema.
Questo riferimento si trova solo se sul sistema è installato PWS o IIS.
Nel caso in cui non lo trovaste, sarà necessario reinstallarli.
Nel nostro esempio, il nome del progetto sarà "Comp1", quello della classe "MyClass". La sintassi con cui è necessario dichiarare componenti ASP in una pagina è:
Set ObjReference = Server.CreateObject("Comp1.MyClass")Ora, una volta impostato un riferimento nella pagina ASP, sarà possibile accedere a tutte le Sub o le Function del component, mediante una sintassi del tipo:
<%
Set ObjReference = Server.CreateObject("Comp1.MyClass")
ObjReference.Prova
%>Naturalmente affinchè tutto funzioni, è necessario che nel nostro component sia presente una Sub o una Function pubblica dal nome "Prova".
Prima dicevamo della libreria per l'accesso agli oggetti built-in.
Bene, si tratta di una libreria molto importante, in quanto si rivela
molto utile per queste ragioni. Si può accedere dal component agli oggetti
Session, Application, Request, Response.
Per usarlo nel component, oltre ad aver dovuto impostare un riferimento
(come prima specificato) alla libreria ASP, è necessario inserire
una Sub OnStartPage nel codice della classe. La Sub OnStartPage viene
eseguita ogni volta che viene creata un'istanza del component, per cui
può essere utile anche per altri scopi, come quello di impostare
variabili condivise da alcune function/sub.
Risulterà una cosa del genere:
Public Sub OnStartPage(ASPScriptingContext As ScriptingContext)
Set MyScriptingContext = ASPScriptingContext
Set MyApplication = MyScriptingContext.Application
Set MyRequest = MyScriptingContext.Request
Set MyResponse = MyScriptingContext.Response
Set MyServer = MyScriptingContext.Server
Set MySession = MyScriptingContext.Session
End SubNon è tutto. E' anche necessario scrivere prima di questa sub, questo codice, per permettere a VB di non generare un errore:
Private MyScriptingContext As ScriptingContext
Private MyApplication As Application
Private MyRequest As Request
Private MyResponse As Response
Private MyServer As Server
Private MySession As SessionA questo punto creeremo anche una Sub che scarichi dalla memoria questi riferimenti, in modo da non appesantire il sistema. Per fare questo useremo la Sub OnEndPage, che viene richiamata alla chiusura della classe.
Public Sub OnEndPage()
Set MyScriptingContext = Nothing
Set MyApplication = Nothing
Set MyRequest = Nothing
Set MyResponse = Nothing
Set MyServer = Nothing
Set MySession = Nothing
End SubOra possiamo accedere dal codice VB del nostro component, a tutti i metodi e le proprietà offerte dagli oggetti built-in ASP. Ad esempio, per scrivere in una pagina ASP, potrai usare il codice MyResponse.Write, che equivale in tutto e per tutto a scrivere in una pagina ASP Response.Write.
Dopo questa lunga (e necessaria) premessa, scriviamo il nostro metodo Prova. Lo faremo tramite questa sub:
Public Sub Prova()
MyResponse.Write ("Il mio primo component in VB.
")
End SubCome è chiaro dal messaggio, si può inserire tranquillamente codice HTML,
proprio come nelle pagine ASP.
Per richiamare questo component nella nostre pagine ASP useremo:
<%
Set ObjReference = Server.CreateObject("Comp1.MyClass")
ObjReference.Prova
%>A questo punto, tramite il menu "File/Save Project" di VB, salva il tutto. Questa operazione salva il codice, ma non crea la DLL. Per farlo, è necessario stoppare PWS (o IIS) per compilare di nuovo la DLL, altrimenti sarà impossibile usare lo stesso nome. Si tratta di un bug di cui non si conosce una soluzione. Praticamente se si compila la DLL e la si usa, anche dopo aver stoppato PWS, non sarà possibile sovrascrivere quel file, perchè PWS continuerà a richiederlo (anche stoppato).
Dal menu File, ci sarà un'opzione "Make comp1.dll".
Selezionandola verrà creata la DLL.
Usando il codice ASP di cui sopra (prova.asp), sarà possibile testare
la DLL.
Dall'indirizzo http://127.0.0.1/prova/prova.asp sarà possibile
vederne i risultati.
Da ora in poi sai come creare component. Con i component è possibile fare di tutto, da interi siti automatizzati, a semplici component che calcolino dei dati particolari. Il vantaggio di usare component, è che il codice diventa più gestibile, e rimane totalmente sicuro, perchè trattandosi di codice compilato, è impossibile risalire dalla DLL al codice che è stato usato.
Il server component, per funzionare, deve essere registrato nel sistema.
In quello su cui è stato sviluppato, viene registrato direttamente
da VB, ma nel caso debba essere usato su un altro sistema, sarà necessario
utilizzare il comando regsvr32.exe, che si trova in genere in c:\windows\system.
E' necessario fare seguire al richiamo a questo file, il nome del component
da registrare. Quindi, nel caso il nostro comp1.dll si trovi in
c:\inetpub\wwwroot\prova, dovremo lanciare questo comando:
regsvr32.exe c:\inetpub\wwwroot\prova\comp1.dll.
Finalmente sappiamo come fare a creare un oggetto COM che faccia da server component per le pagine ASP. Non ci resta che buttarci a capofitto ed iniziare a fare qualche prova. E' utile sapere che, in generale, è possibile avere dei risultati soddisfacenti solo usando delle chiamate alle API (Application Program Interface), che permettono di accedere a tutte le funzioni per cui in genere si decide di usare un server component.