Sesta lezione - convenzioni, algebra e variabili Booleane
Come promesso, cominciamo a vedere cosa sono e come si usano le cosiddette convenzioni di scrittura del codice: tali convenzioni sono regole che ogni programmore 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 galeo del programmore, 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 carteri 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 visualizzo il form frmMain, dopodiché la caption di un'etichetta viene aggiorna con un nome di file opportuno, e infine viene richiama 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 prive ma dichiare 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 trta di una stringa). Ci sono poi delle convenzioni per la strutturazione del codice, ovvero l'inserimento di commenti e l'uso di una formtazione adegua del codice: ad esempio, ogni subroutine o funzione dovrebbe includere un commento che ne indichi lo scopo, il significo 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 formtazione del codice, bisognerebbe utilizzare i rientri: consideriamo ad es. queste istruzioni:
Non preoccupevi del significo delle istruzioni if e for: le vedremo in dettaglio più avanti. La cosa importante è sapere è sapere che queste istruzioni sono nidifice, 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 immediamente evidenzia dal rientro delle varie istruzioni: maggiore è il rientro, maggiore è il livello logico di nidificazione; è un po' lo stesso principio utilizzo da Gestione risorse per visualizzare la gerarchia delle directories: più una cartella è "rientra", meno importante è il suo livello gerarchico. Queste sono alcune delle convenzioni di scrittura del codice: altre le vedremo strada facendo. Non pense però che queste convenzioni servano solo se il vostro codice deve essere letto da altri: anzi, la loro utilità è rivolta soprtutto all'autore del codice, perché spesso accade che egli non si ricordi più come e perché aveva strutturo 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 memici) sin dai tempi di Aristotele. Questi due concetti sono fondamentali per l'intero mondo dei computer, anzi per lo stesso funzionamento dei computer: infti, 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 associi ai valori falso e vero. Il logico e memico 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 operori logici funzionano come le operazioni memiche (anzi, a ben guardare SONO operazioni memiche, pur essendo diverse da quelle che abbiamo studio alle elementari): legano tra di loro due espressioni booleane (cioè due valori del tipo vero/falso) e forniscono un risulto. In Visual Basic esiste un tipo di di 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 utilizze nell'ambito delle operazioni logiche booleane. Lo schema del risulto degli operori 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 è immediamente 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 alternive, 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 operori possono essere raggruppi insieme: così come si può scrivere (5+2)*3, si può anche scrivere
(True Or False) And True
il risulto di questo esempio sarà True. Ora potete capire che l'Xor è il risulto 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 operori logici disponibili in Visual Basic, che sono utilizzi 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: infti 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 operore (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 operore in Visual Basic non esiste… Comunque gli operori logici che è necessario conoscere sono solo And, Or, Not, e sarebbe bene conoscere anche Xor: la prossima volta vedremo degli esempi.
Note sul corso:
I diritti di ognuna delle lezioni presente in queste pagine appartengono all'autore Giorgio Abraini. La riproduzione e la divulgazione delle stesse sono consentite solamente dietro citazione di fonte ed autore.
Per suggerimenti, consigli o richieste conttare giorgio102@libero.it.
Fonte : VBItalia.it
Lezione 6
