Visual Basic Italia

Le variabili booleane in Visual Basic Net? Le trovi su Opentraining.it Visual Basic Italia

Corso di Visual Basic:

Sesta lezione - convenzioni, algebra e variabili Booleane (a cura di Giorgio Abraini)

Come promesso, cominciamo a vedere cosa sono e come si usano le cosiddette convenzioni di scrittura del codice: tali convenzioni sono regole che ogni programmatore dovrebbe seguire, al fine di scrivere un codice facilmente comprensibile e modificabile per chiunque abbia l'occasione di leggerlo ed eventualmente correggerlo e migliorarlo; rappresentano una sorta di galateo del programmatore, che permette di standardizzare il codice e quindi di renderne più semplice la lettura, la comprensione e la diffusione. Le convenzioni più semplici sono quelle che riguardano la denominazione di oggetti e variabili: secondo tali convenzioni è bene utilizzare un prefisso di due o tre caratteri specifico per ogni tipo di oggetto o variabile: ad es., se utilizziamo un CommandButton dovremmo usare il prefisso cmd; per le etichette (c.d. Label) il prefisso è lbl, per i form è frm, e così via. Leggendo un codice di questo tipo:

frmMain.Show
lblFileName.Caption="c:\pippo.txt"
cmdSave_Click

saremmo in grado di intuire subito che prima di tutto viene visualizzato il form frmMain, dopodiché la caption di un'etichetta viene aggiornata con un nome di file opportuno, e infine viene richiamata la routine corrispondente all'evento Click di un CommandButton. Senza usare i prefissi, non avremmo potuto sapere a priori a quale oggetto si riferisse la proprietà Caption o la routine Click. Analogo discorso vale per le variabili: innanzitutto è bene usare una lettera per indicarne l'area di validità: g per le variabili globali, o pubbliche, m per quelle private ma dichiarate a livello di modulo (quindi nella sezione dichiarazioni di un form, ad esempio); per le variabili locali delle routine non si usa alcun prefisso. Poi bisognerebbe utilizzare un altro prefisso per indicare il tipo di variabile: str per le stringhe, int per gli integer, lng per i long, ecc. Ad esempio:

gstrUserName

indica una variabile pubblica che contiene il nome dell'utente (e quindi si tratta di una stringa). Ci sono poi delle convenzioni per la strutturazione del codice, ovvero l'inserimento di commenti e l'uso di una formattazione adeguata del codice: ad esempio, ogni subroutine o funzione dovrebbe includere un commento che ne indichi lo scopo, il significato delle variabili richieste in input, il valore restituito, e ogni altra informazione non direttamente intuibile dal codice ma che serve a capire meglio cosa fa e come funziona la routine. Per quanto riguarda la formattazione del codice, bisognerebbe utilizzare i rientri: consideriamo ad es. queste istruzioni:

Non preoccupatevi del significato delle istruzioni if e for: le vedremo in dettaglio più avanti. La cosa importante è sapere è sapere che queste istruzioni sono nidificate, ovvero contenute l'una nell'altra: il blocco if…end if contiene il blocco for…next, che a sua volta contiene l'istruzione di aggiornamento della label. La nidificazione è appunto immediatamente evidenziata dal rientro delle varie istruzioni: maggiore è il rientro, maggiore è il livello logico di nidificazione; è un po' lo stesso principio utilizzato da Gestione risorse per visualizzare la gerarchia delle directories: più una cartella è "rientrata", meno importante è il suo livello gerarchico. Queste sono alcune delle convenzioni di scrittura del codice: altre le vedremo strada facendo. Non pensate però che queste convenzioni servano solo se il vostro codice deve essere letto da altri: anzi, la loro utilità è rivolta soprattutto all'autore del codice, perché spesso accade che egli non si ricordi più come e perché aveva strutturato in un certo modo il codice (quando avrete un po' più di esperienza ve ne accorgerete!).

Ora introduciamo il discorso delle operazioni logiche e delle variabili booleane (pron. buleàne). Chiunque dovrebbe avere familiarità coi concetti di vero e falso, due condizioni logiche opposte che stanno alla base del nostro modo di ragionare e che sono oggetto di studi filosofici (e successivamente matematici) sin dai tempi di Aristotele. Questi due concetti sono fondamentali per l'intero mondo dei computer, anzi per lo stesso funzionamento dei computer: infatti, come tutti sanno, un computer si basa su una logica binaria, in cui ogni singolo bit può assumere due soli valori: 0 e 1, che possono essere logicamente associati ai valori falso e vero. Il logico e matematico George Boole,

vissuto nel XIX secolo, sviluppò un insieme di regole (che formano l'algebra booleana) per eseguire operazioni logiche sui valori vero e falso. Le principali regole, di cui probabilmente avrete già sentito parlare, sono queste:

And (congiunzione), Or (disgiunzione), Not (negazione), Xor (exclusive Or)

Questi operatori logici funzionano come le operazioni matematiche (anzi, a ben guardare SONO operazioni matematiche, pur essendo diverse da quelle che abbiamo studiato alle elementari): legano tra di loro due espressioni booleane (cioè due valori del tipo vero/falso) e forniscono un risultato. In Visual Basic esiste un tipo di dati particolare, il tipo Boolean, che indica proprio una variabile booleana, che può assumere il valore vero o falso, o meglio True o False, che sono le parole chiave utilizzate nell'ambito delle operazioni logiche booleane. Lo schema del risultato degli operatori logici And, Or, Xor è il seguente:

True And True = True
True And False = False
False And True = False
False And False = False

True Or True = True
True Or False = True
False Or True = True
False Or False = False

True Xor True = False
True Xor False = True
False Xor True = True
False Xor False = False

Come si può notare, la congiunzione (And) di due espressioni è vera solo se sono vere entrambe le espressioni ("io lavoro a Milano e a Torino" è vera solo se è contemporaneamente vero che lavoro a Milano e che lavoro a Torino); la disgiunzione (Or) è vera solo se è vera almeno una delle due espressioni ("io lavoro a Milano o a Torino" è vera se lavoro sia a Milano che a Torino, ma è vera anche se lavoro a Milano e a Brescia o se lavoro a Torino e a Roma; sarà invece falsa solo se non lavoro né a Milano né a Torino). La disgiunzione esclusiva (Xor) non è immediatamente intuibile come la congiunzione e la disgiunzione, ma è un misto di queste due operazioni e della negazione: l'Xor restituisce True solo se le due espressioni sono diverse, mentre restituisce False solo se le due espressioni sono uguali; corrisponde alla "o" disgiuntiva, come quando si dice "io lavoro o a Milano o a Torino": mentre l'Or permette la compresenza di entrambe le alternative, l'Xor ne esclude una delle due. La negazione, infine, coinvolge una sola espressione e restituisce semplicemente il suo opposto:

Not True = False
Not False = True

Questi operatori possono essere raggruppati insieme: così come si può scrivere (5+2)*3, si può anche scrivere

(True Or False) And True

il risultato di questo esempio sarà True. Ora potete capire che l'Xor è il risultato di questa espressione (x e y sono due variabili booleane):

x Xor y = ((Not x) And y) Or (x And (Not y))

Ci sono altri due operatori logici disponibili in Visual Basic, che sono utilizzati molto raramente ma che potrebbero comunque essere utili: l'equivalenza (Eqv) e l'implicazione (Imp):

True Eqv True = True
True Eqv False = False
False Eqv True = False
False Eqv False = True

True Imp True = True
True Imp False = False
False Imp True = True
False Imp False = True

In parole povere, l'Eqv è la negazione dell'Xor: infatti due espressioni sono equivalenti se sono uguali (entrambe false o entrambe vere); l'Imp corrisponde più o meno alla costruzione "se… allora" con l'uso di una condizione sufficiente ma non necessaria, ad esempio "se x>y, allora x>y/2": questa implicazione è falsa solo se fosse x>y ma xy affinché sia x>y/2. Se volessimo implementare un operatore (chiamiamolo "Nec") per le condizioni necessarie ma non sufficienti, dovrebbe venir fuori una cosa del genere:

True Nec True = True True Nec False = True False Nec True = False False Nec False = True

Ma questo operatore in Visual Basic non esiste… Comunque gli operatori logici che è necessario conoscere sono solo And, Or, Not, e sarebbe bene conoscere anche Xor: la prossima volta vedremo degli esempi.

Archivio:ndexed
Lezioni	Commenta questa lezione	Invia la tua guida	Avviso per le nuove lezioni	Proponi un argomento