e-Thomas.net

Sei in: Per i Webmaster - Corso di ASP - 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.

Controlli della logica condizionale
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

<%
 If Hour(Now()) >= 0 And Hour(Now()) < 8 Then
 Response.Write "E' ancora notte fonda!!!"
 End If
%>

Una variante è data dall'istruzione If... Then... Else che permette di eseguire altro codice se la prima condizione è falsa. Ecco come si presenta:

If condizione/i Then
codice da eseguire
Else
codice alternativo da eseguire
End If

<%
 If Hour(Now()) >= 0 And Hour(Now()) < 8 Then
 Response.Write "E' ancora notte fonda."
 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 condizione/i Then
    If altra/e condizione/i Then
        codice da eseguire
    Else
        altro codice da eseguire
    End If
Else
    altro codice da eseguire
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:

If condizione/i Then
codice da eseguire
Elseif condizione/i Then
altro codice da eseguire
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.

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

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:

<%
 Dim intTemperatura, strTesto
 intTemperatura = 25
 Select Case intTemperatura
 Case 0,1,2,3,4,5,6,7,8,9
 strTesto = "fredda"
 Case 10,11,12,13,14,15,16,17,18,19
 strTesto = "temperata"
 Case 20,21,22,23,24,25,26,27,28,29
 strTesto = "calda"
 Case Else
 strTesto = "freddissima o caldissima"
 End Select
%>
Oggi è una giornata <% = strTesto %>.

Controlli della logica ciclica
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:

<%
 For intCont = 1 To 10
 Response.Write "Numero " & intCont & " "
 Next
%>

Per ottenere i numeri dispari tra 1 e 10 è sufficiente modificare la riga 2 come segue:

<%
 For intCont = 1 To 10 Step 2
 Response.Write "Numero " & intCont & " "
 Next
%>

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:

<%
 Dim Item, strCitta(2)
 strCitta(0) = "Roma"
 strCitta(1) = "Londra"
 strCitta(2) = "Parigi"
 For Each Item In strCitta
 Response.Write Item & " "
 Next
%>

La struttura Do While... Loop si presenta così:

Do While condizione
codice da eseguire
Loop

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

<%
 Dim intCont
 intCont = 1
 Do While intCont <= 10
 Response.Write "Numero " & intCont & " "
 intCont = intCont + 1
 Loop
%>

che diventa come segue nel caso si utillizzi il Do Until... Loop

<%
 Dim intCont
 intCont = 1
 Do Until intCont > 10
 Response.Write "Numero " & intCont & " "
 intCont = intCont + 1
 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.

<%
 Dim intCont
 intCont = 1
 While intCont <= 10
 Response.Write "Numero " & intCont & " "
 intCont = intCont + 1
 Wend
%>

Vai alla home del wired portal Il tuo IP: 38.103.63.60
Home	Office	Servizi SMS e MMS	Community	Utility	Vai a...	Parliamone