Settima lezione - Utilizzo delle variabili Booleane (a cura di Giorgio Abraini)
Nella scorsa lezione abbiamo visto cosa sono le variabili booleane
e quali operazioni si possono fare con esse: ora vediamo come si usano.
L'istruzione principale che fa uso di espressioni booleane è il costrutto
"if condizione then istruzione"
che, come dice il nome, esegue una o più istruzioni
se si verifica una certa condizione. Ad esempio, l'istruzione:
|
If lblName.Visible = True Then lblName.Caption = "Pippo"
|
aggiorna la proprietà Caption dell'etichetta lblName se questa etichetta è
visibile: il tipo della proprietà Visible, infatti, è proprio Boolean. Quando Visual Basic
deve eseguire un'istruzione come quella riportata, prima di tutto verifica se
l'espressione compresa tra le parole chiave If e Then è vera o falsa: se
l'etichetta è visibile (cioè se la proprietà visible è uguale a True), la condizione è
verificata e quindi sarà eseguita l'istruzione seguente la parola chiave Then;
altrimenti la condizione non sarà verificata e l'istruzione sarà del tutto ignorata.
Solitamente i programmatori VB ("VB" è ovviamente l'abbreviazione di Visual Basic…)
utilizzano una sintassi leggermente diversa, organizzata su più di una riga (cosiddetta a blocco):
If lblName.Visible = True Then
lblName.Caption = "Pippo"
End If
|
In Visual Basic di solito si inserisce una istruzione per ogni riga,
poiché è sufficiente il ritorno a capo per far capire a Visual Basic
che l'istruzione è terminata; nel caso della If…Then, quindi, è possibile far
stare tutta l'istruzione sulla stessa riga, ma se le istruzioni che seguono
Then vengono riportate nelle righe successive, è necessario indicare
dove finiscono le istruzioni appartenenti al blocco If, e questo si fa appunto
con la parola chiave End If, esattamente come si fa con End Sub o
End Function per indicare la fine di una subroutine o di una funzione.
Personalmente ritengo che la seconda sintassi sia più chiara e comoda,
soprattutto quando le istruzioni da eseguire nel blocco sono più di una: infatti,
se volessimo utilizzare la sintassi su una singola riga, bisognerebbe separare
le varie istruzioni con i ":", ad esempio:
|
If lblName.Visible = True Then lblName.Caption = "Pippo": Form1.Caption = "Pippo": ... |
(nota: il carattere " : " può essere utilizzato per riunire più istruzioni sulla stessa
riga anche al di fuori di un'istruzione If…Then)
L'istruzione If…Then permette di eseguire certe istruzioni anche nel caso in cui la
condizione non sia verificata: ciò è possibile grazie alla parola chiave Else, ad esempio:
If strName = "Pippo" Then
frmProva.Show
Else
frmProva.Hide
End If
|
Se la variabile stringa strName è uguale a "Pippo", il form frmProva viene mostrato,
altrimenti viene nascosto.
In questo modo è possibile ottenere una certa flessibilità
nell'esecuzione condizionale di un gruppo di istruzioni; questa flessibilità è
ulteriormente aumentata dalla possibilità di utilizzare la parola chiave ElseIf:
If strName = "Pippo" Then
frmProva.Show
frmProva.lblName.Caption = "Pippo"
ElseIf strName = "Topolino" Then
frmProva.Show
frmProva.lblName.Caption = "Minnie"
ElseIf strName = "Pluto" Then
frmProva.Show
frmProva.lblName.Caption="Orazio"
Else
frmProva.Hide
End If
|
In un blocco di questo tipo, Visual Basic comincia a verificare le condizioni
una per una: quando una delle condizioni è verificata, vengono eseguite
le istruzioni relative a quella condizione, ignorando le altre; se nessuna
delle condizioni è verificata, vengono eseguite le istruzioni comprese nella
clausola else, se è presente: altrimenti non viene eseguita
alcuna istruzione. Infatti le clausole Else e ElseIf sono facoltative.
All'interno di ogni blocco If…Then è possibile inserire qualunque
istruzione, anche un'altra If…Then (si parla dei cosiddetti
blocchi annidati); ad esempio si potrebbe fare:
If intX > 10 Then
If intX > 100 Then
intY = intX / 2
Else
intY = intX + 10
End If
ElseIf intX > 5 Then
intY = 0
Else
bValue = True
End If
|
In questo blocco viene valutato il valore della variabile Integer intX: se è maggiore di
10, viene effettuato un ulteriore controllo: se intX è maggiore di 100, viene
posto intY = intX/2, altrimenti intY = intX+10; se invece intX non è maggiore di
10 (cioè intX <= 10), Visual Basic controlla se intX > 5: in questo caso si pone
intY = 0. Se infine intX <= 5, la variabile booleana bValue viene impostata a True.
E' chiaro quindi che l'istruzione If…Then permette di effettuare
confronti flessibili e ramificati per determinare quali istruzioni è opportuno eseguire.
Ma non basta: le condizioni da valutare possono essere espressioni anche molto
complesse, utilizzando gli operatori logici che abbiamo visto nella lezione precedente;
ad esempio:
If ((intX> 10 And intX < 100) Or (intX > 200 And intX<= intY / 3)) Imp bValue = False Then
...
End If
|
La valutazione della condizione segue le regole generali per l'uso delle parentesi:
dapprima viene confrontato il valore di intX con 10 e con 100: se è compreso
tra questi due valori (esclusi gli estremi), l'espressione nella prima sotto-parentesi
sarà True;
poi intX viene confrontato con 200 e con intY / 3: se è compreso tra
questi due valori, la seconda sotto-parentesi sarà True; se almeno una delle
due sotto-parentesi è True, anche la super-parentesi sarà True. Infine viene
confrontata la variabile bValue con il valore False: se bValue è False, l'espressione
"bValue = False" sarà True, e quindi lo sarà anche l'intera condizione valutata dalla If
(infatti l'operatore Imp restituisce sempre True se la seconda espressione è True:
v.lezione precedente); se invece bValue = True, la seconda espressione sarà False:
in tal caso l'intera condizione sarà True solo se anche la super-parentesi sarà False.
Un esempio dovrebbe chiarire tutto: supponiamo che intX = 90, intY = 600, bValue = True;
allora avremo:
If ((True And True) Or (False And True)) Imp False Then
|
che corrisponde a:
If (True Or False) Imp False Then
|
che corrisponde a:
SiccomeTrue Imp False restituisce False, le istruzioni successive a Then non saranno
eseguite. Vi faccio notare che Visual Basic valuta sempre tutte le espressioni, anche
se in qualche caso è inutile; supponiamo ad esempio di avere:
|
If intX > 10 And intX < 20 Then
|
con intX = 5; sapendo che intX > 10 è False e che il valore della
condizione dipende dall'operatore And, si potrebbe anche fare a
meno di confrontare intX con 20, perché qualunque sia il risultato
di questo confronto la condizione sarà comunque False, dato che la prima
espressione è False e l'And restituisce True solo se entrambe le espressioni sono
True.
In effetti alcuni linguaggi più "intelligenti" (ad esempio il C++) evitano i
confronti inutili; Visual Basic invece li fa sempre tutti, e nel caso di controlli pesanti
bisognerebbe tenerne conto, facendo in modo che vengano valutate
solo le espressioni strettamente necessarie. Ad es., l'istruzione:
If intX > 10 And intX < 20 Then
intX = intX * 2
End If
|
potrebbe essere modificata in questo modo:
If intX > 10 Then
if intX < 20 Then
IntX = IntX * 2
End If
End If
|
In questo modo, se intX=5, Visual Basic non perde tempo a
confrontare intX con 20, perché già la prima condizione è falsa,
e quindi il secondo blocco If sarà ignorato.
|
