Laboratorio di indagini campionarie
A.A. 2003-2004
Visual Basic for Application in Access 2000
Alessandro Lubisco
Indice
Definizioni ...........................................................................................................................................5
Istruzione......................................................................................................................................5
Variabile.......................................................................................................................................5
Espressione...................................................................................................................................5
Espressione numerica...................................................................................................................5
Routine .........................................................................................................................................5
Area di validità.............................................................................................................................5
Confronto fra stringhe..................................................................................................................5
Confronto bit per bit.....................................................................................................................5
Empty ...........................................................................................................................................6
Null ..............................................................................................................................................6
Tipo di dati ...................................................................................................................................6
Tipo di dati ...........................................................................................................................................6
Tipo di dati Boolean.....................................................................................................................6
Tipo di dati Byte ..........................................................................................................................6
Tipo di dati Currency ...................................................................................................................6
Tipo di dati Date ..........................................................................................................................6
Tipo di dati Decimal ....................................................................................................................6
Tipo di dati Double ......................................................................................................................6
Tipo di dati Integer.......................................................................................................................7
Tipo di dati Long..........................................................................................................................7
Tipo di dati Single........................................................................................................................7
Tipo di dati String ........................................................................................................................7
Tipo di dati Variant ......................................................................................................................7
Riepilogo dei tipi di dati.......................................................................................................................7
Riepilogo degli operatori .....................................................................................................................9
Operatori aritmetici ..............................................................................................................................9
Operatore ^.......................................................................................................................................9
Esempio di operatore ^.................................................................................................................9
Operatore *.....................................................................................................................................10
Esempio di operatore * ..............................................................................................................10
Operatore /......................................................................................................................................10
1 di 81
Esempio di operatore / ...............................................................................................................11
Operatore \......................................................................................................................................11
Esempio di operatore \ ...............................................................................................................12
Operatore Mod ...............................................................................................................................12
Esempio di operatore Mod.........................................................................................................12
Operatore + ....................................................................................................................................12
Esempio di operatore + ..............................................................................................................14
Operatore –.....................................................................................................................................14
Esempio di operatore - ...............................................................................................................15
Operatori di confronto........................................................................................................................15
Istruzione Option Compare............................................................................................................17
Esempio di istruzione Option Compare .....................................................................................18
Istruzione Option Explicit..............................................................................................................18
Esempio di istruzione Option Explicit .......................................................................................18
Operatore = ....................................................................................................................................19
Operatore Is....................................................................................................................................19
Esempio di operatore Is..............................................................................................................20
Operatore Like ...............................................................................................................................20
Esempio di operatore Like .........................................................................................................21
Esempio di operatori di confronto .................................................................................................22
Operatori di concatenamento .............................................................................................................22
Operatore &....................................................................................................................................22
Esempio di operatore & .............................................................................................................22
Operatori logici ..................................................................................................................................23
Operatore And................................................................................................................................23
Esempio di operatore And..........................................................................................................24
Operatore Eqv ................................................................................................................................24
Esempio di operatore Eqv ..........................................................................................................25
Operatore Imp ................................................................................................................................25
Esempio di operatore Imp ..........................................................................................................26
Operatore Not.................................................................................................................................26
Esempio di operatore Not ..........................................................................................................27
Operatore Or ..................................................................................................................................27
Esempio di operatore Or ............................................................................................................28
Operatore Xor ................................................................................................................................28
Esempio di operatore Xor ..........................................................................................................29
Precedenza tra gli operatori................................................................................................................29
Esecuzione condizionale del codice...................................................................................................31
Istruzione If...Then...Else...............................................................................................................31
Utilizzo di istruzioni If...Then...Else..............................................................................................32
Esempio di istruzione If...Then...Else ........................................................................................33
Istruzione Select Case ....................................................................................................................34
Esempio di istruzione Select Case .............................................................................................35
Ripetizione ciclica del codice ............................................................................................................35
Istruzione Do...Loop ......................................................................................................................36
Esempio di istruzione Do...Loop ...............................................................................................36
Utilizzo di istruzioni Do...Loop .....................................................................................................37
Ripetizione delle istruzioni fino a quando una condizione è True.............................................37
Ripetizione delle istruzioni fino a quando una condizione non diventa True............................37
Uscita da un'istruzione Do...Loop dall'interno del ciclo ............................................................38
Istruzione While...Wend ................................................................................................................38
2 di 81
Esempio di istruzione While...Wend .........................................................................................39
Istruzione For...Next ......................................................................................................................39
Esempio di istruzione For...Next ...............................................................................................40
Utilizzo di istruzioni For...Next .....................................................................................................40
Velocizzazione di cicli For...Next..................................................................................................41
Scrittura di istruzioni di Visual Basic ................................................................................................41
Aggiunta di commenti................................................................................................................42
Controllo degli errori di sintassi.................................................................................................42
Definizioni .........................................................................................................................................43
Modulo .......................................................................................................................................43
Controllo ....................................................................................................................................43
Proprietà .....................................................................................................................................43
Metodo .......................................................................................................................................43
Stato attivo .................................................................................................................................43
Indicatore a margine...................................................................................................................43
Modalità interruzione.................................................................................................................43
Punto di interruzione..................................................................................................................43
Gestione progetti ................................................................................................................................44
Elementi della finestra ...................................................................................................................44
Visualizza codice ................................................................................................................44
Visualizza oggetto................................................................................................................44
Espandi/comprimi cartelle ..................................................................................................44
Riquadro elenco .........................................................................................................................44
Finestra del codice .............................................................................................................................45
Elementi della finestra ...................................................................................................................45
Casella Oggetto ..........................................................................................................................45
Casella Routine ..........................................................................................................................45
Barra di divisione .......................................................................................................................46
Barra indicatori ..........................................................................................................................46
Icona Visualizza routine........................................................................................................46
Icona Visualizza modulo intero.............................................................................................46
Indicatori a margine .......................................................................................................................46
Icone utilizzate nel Visualizzatore oggetti e nella finestra del codice ...............................................47
Utilizzo della finestra Immediata.......................................................................................................47
Tasti di scelta rapida per la finestra del codice ..................................................................................48
Tasti di scelta rapida dei comandi di menu per la finestra del codice ...............................................49
Tasti di spostamento per la finestra del codice ..................................................................................50
Tasti per la modifica del codice .........................................................................................................50
Dichiarazione di variabili...................................................................................................................52
Istruzione Dim................................................................................................................................52
Esempio di istruzione Dim.........................................................................................................54
Utilizzo dell'istruzione Public ........................................................................................................54
Utilizzo dell'istruzione Private.......................................................................................................54
Utilizzo dell'istruzione Static .........................................................................................................54
Utilizzo dell'istruzione Option Explicit .........................................................................................55
Dichiarazione di una variabile oggetto per l'automazione .............................................................55
Creazione di una routine ....................................................................................................................55
Per creare una routine mediante la scrittura del codice .................................................................56
Per creare una routine utilizzando la finestra di dialogo Inserisci routine.....................................56
Istruzione Function ........................................................................................................................56
3 di 81
Esempio di istruzione Function..................................................................................................59
Istruzione Sub ................................................................................................................................59
Esempio di istruzione Sub..........................................................................................................62
Creazione di routine ricorsive ........................................................................................................62
Scrittura di una routine Function ...................................................................................................62
Chiamata di routine Sub e Function...............................................................................................63
Chiamata di routine Sub con più argomenti...................................................................................63
Passaggio di argomenti predefiniti.................................................................................................64
Area di validità e visibilità .............................................................................................................64
Definizione dell'area di validità a livello di routine...................................................................64
Definizione dell'area di validità a livello di modulo privato......................................................65
Vita utile delle variabili..................................................................................................................65
Funzione MsgBox ..............................................................................................................................67
Esempio di funzione MsgBox........................................................................................................69
Funzione InputBox.............................................................................................................................69
Esempio di funzione InputBox ......................................................................................................70
Uso di database con il codice VBA ...................................................................................................71
Esempio 1: Connessione alla tabella tblDati di un database Access 2000 ...............................71
Esempio 2: Connessione un database Access 2000 tramite una query SQL ............................72
Oggetto Recordset..........................................................................................................................72
Proprietà BOF ed EOF...................................................................................................................74
Esempio di proprietà BOF, EOF e Bookmark ...........................................................................75
Metodo Open (Recordset ADO) ....................................................................................................76
Metodo Close .................................................................................................................................79
Esempio di utilizzo dei metodi Open e Close ............................................................................80
Metodi MoveFirst, MoveLast, MoveNext e MovePrevious ..........................................................81
4 di 81
Definizioni
Istruzione
Unità con sintassi completa che esprime un tipo di azione, dichiarazione o definizione.
Un'istruzione è costituita, in genere, da una sola riga, sebbene sia possibile utilizzare i due punti (:)
per inserire più istruzioni sulla stessa riga. È inoltre possibile utilizzare un carattere di
continuazione riga (_) per proseguire un'unica riga logica su una seconda riga fisica.
Variabile
Posizione predefinita per la memorizzazione dei dati che possono essere modificati durante
l'esecuzione del programma. Ciascuna variabile ha un nome univoco che la identifica all'interno
dell'area di validità. La specifica del tipo di dati è facoltativa.
I nomi di variabile devono iniziare con un carattere alfabetico, devono essere univoci all'interno di
una stessa area di validità, non possono essere composti da più di 255 caratteri e non possono
contenere un punto o un carattere di dichiarazione del tipo.
Espressione
Combinazione di parole chiave, operatori, variabili e costanti che restituiscono una stringa, un
numero o un oggetto. Un'espressione può eseguire un calcolo, manipolare caratteri o eseguire prove
sui dati.
Espressione numerica
Qualsiasi espressione che possa essere valutata come un numero. Gli elementi dell'espressione
possono includere qualsiasi combinazione di parole chiave, variabili, costanti e operatori il cui
risultato sia un numero.
Routine
Sequenza predefinita di istruzioni del codice eseguite come un'unità singola. Esempi di routine sono
Function, Property e Sub. Il nome delle routine viene sempre definito a livello di modulo. Il
codice eseguibile deve sempre essere specificato all'interno di una routine. Non è possibile
nidificare le routine all'interno di altre routine.
Area di validità
Definisce la visibilità di una variabile, di una routine o di un oggetto. Una variabile dichiarata come
Public, ad esempio, è disponibile per tutte le routine in tutti i moduli di un progetto di riferimento
diretto, a meno che non sia attiva Option Private Module. Quando è attiva Option Private
Module, il modulo stesso è privato e pertanto non è visibile per i progetti di riferimento. Le
variabili dichiarate in una routine sono visibili solo all'interno della routine e non mantegono il loro
valore tra le chiamate, a meno che non vengano dichiarate con Static.
Confronto fra stringhe
Confronto fra due sequenze di caratteri. Utilizzare Option Compare per confronti binari o di testo.
Nell'impostazione Inglese (USA) viene fatta distinzione fra maiuscole e minuscole nei confronti
binari ma non nei confronti di testo.
Confronto bit per bit
Confronto dei bit che occupano posizioni identiche in due espressioni numeriche, eseguito un bit
alla volta.
5 di 81
Empty
Valore che indica che a una variabile Variant non è stato assegnato alcun valore iniziale. Le
variabili Empty sono rappresentate da 0 (in un contesto numerico) o da una stringa di lunghezza
zero ("") (in un contesto testuale).
Null
Valore che indica che una variabile non contiene dati validi. Null è il risultato di un'assegnazione
esplicita di Null a una variabile, oppure di una qualsiasi operazione fra espressioni che contengono
Null.
Tipo di dati
Caratteristica di una variabile che determina quale genere di dati essa può includere. I tipi di dati
fondamentali comprendono Byte, Boolean, Integer, Long, Currency, Decimal, Single, Double,
Date, String, Object, Variant (predefinito) e tipi definiti dall'utente, nonché tipi specifici di
oggetto.
Tipo di dati
Tipo di dati Boolean
Tipo di dati con solo due valori possibili, ovvero True (-1) o False (0). Le variabili di tipo Boolean
vengono memorizzate come numeri a 16 bit (2 byte).
Tipo di dati Byte
Tipo di dati utilizzato per contenere numeri interi positivi compresi nell'intervallo tra 0 e 255. Le
variabili di tipo Byte vengono memorizzate come numeri singoli, senza segno a 8 bit (1 byte).
Tipo di dati Currency
Tipo di dati compreso nell'intervallo da -922.337.203.685.477,5808 a 922.337.203.685.477,5807.
Utilizzato per calcoli monetari o a virgola fissa in cui la precisione è fondamentale. Il carattere di
dichiarazione del tipo che rappresenta il tipo di dati Currency in Visual Basic è il simbolo (@).
Tipo di dati Date
Tipo di dati utilizzato per memorizzare date e orari come numeri reali. Le variabili di tipo Date
vengono memorizzate come numeri a 64 bit (8 byte). Il valore a sinistra del separatore decimale
rappresenta una data e il valore a destra rappresenta un orario.
Tipo di dati Decimal
Tipo di dati che contiene numeri decimali divisi per una potenza di 10. Se il fattore di divisione è
zero (numeri senza decimali) l'intervallo valido è +/-79.228.162.514.264.337.593.543.950.335. Per i
numeri con 28 decimali, l'intervallo è +/-7,9228162514264337593543950335. Il numero diverso da
zero
più
piccolo
che
può
essere
rappresentato
come
tipo
Decimal
è
0,0000000000000000000000000001.
Si noti che attualmente il tipo di dati Decimal può essere utilizzato solo in una Variant. Non è
possibile dichiarare una variabile di tipo Decimal. È comunque possibile creare una Variant con
sottotipo Decimal utilizzando la funzione CDec.
Tipo di dati Double
Tipo di dati che contiene numeri a virgola mobile a doppia precisione a 64 bit (8 byte) compresi tra
6 di 81
-1.79769313486231E308
e
-4,94065645841247E-324
per
i
valori
negativi,
tra
4,94065645841247E-324 e 1,797693134862325E308 per i valori positivi. Il carattere di
dichiarazione del tipo che rappresenta il tipo di dati Double in Visual Basic è il simbolo di numero
(#).
Tipo di dati Integer
Tipo di dati contenente variabili memorizzate come numeri interi a 2 byte nell'intervallo da -32.768
a 32.767. Il tipo di dati Integer viene inoltre utilizzato per rappresentare valori enumerati. Il
carattere di dichiarazione del tipo che rappresenta il tipo di dati Integer in Visual Basic è il segno di
percentuale (%).
Tipo di dati Long
Intero di quattro byte, ovvero un numero intero compreso tra -2.147.483.648 e 2.147.483.647. Il
carattere di dichiarazione del tipo che rappresenta il tipo di dati Long in Visual Basic è la "e"
commerciale (&).
Tipo di dati Single
Tipo di dati che contiene variabili a virgola mobile a precisione singola a 32-bit (4 byte), compresi
tra -3,402823E38 e -1,401298E-45 per valori negativi e tra 1,401298E-45 e 3,402823E38 per valori
positivi. Il carattere di dichiarazione del tipo che rappresenta il tipo di dati Single in Visual Basic è
il punto esclamativo (!).
Tipo di dati String
Tipo di dati i cui dati sono composti da una sequenza di caratteri contigui che rappresentano i
caratteri effettivi stessi anziché un valore numerico. Può includere lettere, numeri, spazi e segni di
punteggiatura. Il tipo di dati String può contenere stringhe di lunghezza fissa con lunghezza
compresa tra 0 e circa 63 KB di caratteri, e stringhe dinamiche di lunghezza compresa tra 0 e circa 2
miliardi di caratteri. Il carattere di dichiarazione del tipo che rappresenta il tipo di dati String in
Visual Basic è il segno di dollaro ($).
Tipo di dati Variant
Particolare tipo di dati che può essere utilizzato per dati numerici, stringhe o date, tipi di dati
definiti dall'utente e i valori speciali Empty e Null. Il tipo di dati Variant può contenere numeri
che occupano uno spazio di memorizzazione massimo di 16 byte e dati fino all'intervallo consentito
per il tipo di dati Decimal. Può inoltre contenere caratteri che occupano uno spazio di
memorizzazione massimo di 22 byte (più la lunghezza della stringa) ed è in grado di memorizzare
qualsiasi tipo di testo in forma di caratteri. La funzione VarType definisce come devono essere
gestiti i dati all'interno di una Variant. Alle variabili che non vengono dichiarate in modo esplicito
con un tipo di dati specifico viene assegnato il tipo di dati Variant.
Riepilogo dei tipi di dati
La tabella che segue elenca i tipi di dati supportati e indica lo spazio su disco e l'intervallo valido
per ciascun tipo di dati.
Tipo di dati
Spazio su disco
Intervallo
Byte
1 byte
Da 0 a 255
Boolean
2 byte
True o False
7 di 81
Integer
2 byte
Da -32.768 a 32.767
Long
(intero lungo)
4 byte
Da –2.147.483.648 a 2.147.483.6477
Single
(virgola mobile a
precisione semplice)
4 byte
Da -3,402823E38 a -1,401298E-45 per valori negativi;
da 1,401298E-45 a 3,402823E38 per valori positivi
Double
(virgola mobile a
precisione doppia)
8 byte
Da -1.79769313486231E308 a
-4,94065645841247E-324 per valori negativi; da
4,94065645841247E-324 a 1,79769313486232E308
per valori positivi.
Currency
(intero diviso)
8 byte
Da -922.337.203.685.477,5808 a
922.337.203.685.477,5807
Decimal
14 byte
+/-79.228.162.514.264.337.593.543.950.335 senza
virgola;
+/-7,9228162514264337593543950335 con 28
decimali; il numero minore diverso da zero è
+/-0,0000000000000000000000000001
Date
8 byte
Dall'1 gennaio 100 al 31 dicembre 9999
Object
4 byte
Qualsiasi riferimento Object
String
(lunghezza variabile)
10 byte +
Da 0 a circa 2 miliardi
lunghezza stringa
String
(lunghezza fissa)
Lunghezza
stringa
Da 1 a circa 65.400
Variant
(con numeri)
16 byte
Qualsiasi valore numerico fino all'intervallo di un
Double
Variant
(con caratteri)
22 byte +
Stesso intervallo di String a lunghezza variabile
lunghezza stringa
Definito dall'utente
(utilizzando Type)
Numero richiesto L'intervallo di ciascun elemento è identico a quello del
dagli elementi
relativo tipo di dati sopraelencato.
Nota Le matrici di qualsiasi tipo di dati richiedono 20 byte di memoria più quattro byte per ogni
dimensione della matrice più il numero di byte occupati dai dati stessi. La memoria occupata dai
dati può essere calcolata moltiplicando il numero di elementi dei dati per le dimensioni di ciascun
elemento. I dati in una matrice unidimensionale composti da quattro elementi di dati Integer di due
byte ciascuno, ad esempio, occupano otto byte. Gli otto byte richiesti dai dati più i 24 byte di
overhead portano a 32 byte la memoria complessiva richiesta per la matrice.
Un tipo di dati Variant contenente una matrice richiede 12 byte in più rispetto al numero di byte
richiesti dalla matrice da sola.
Nota Utilizzare la funzione StrConv per la conversione del tipo di una stringa di dati in un altro
tipo.
8 di 81
Riepilogo degli operatori
Operatori
Descrizione
Operatori aritmetici
Operatori utilizzati per eseguire calcoli matematici.
Operatori di confronto
Operatori utilizzati per confrontare due espressioni.
Operatori di
concatenamento
Operatori utilizzati per ottenere il concatenamento di stringhe.
Operatori logici
Operatori utilizzati per eseguire operazioni logiche.
Operatori aritmetici
Operatore ^
Operatore *
Operatore /
Operatore \
Operatore Mod
Operatore +
Operatore -
Operatore ^
Utilizzato per elevare un numero alla potenza espressa da un esponente.
Sintassi
risultato = numero^esponente
La sintassi dell'operatore ^ è composta dalle seguenti parti:
Parte
Descrizione
risultato
Obbligatoria. Qualsiasi variabile numerica.
numero
Obbligatoria. Qualsiasi espressione numerica.
esponente Obbligatoria. Qualsiasi espressione numerica.
Osservazioni
Un numero può essere negativo soltanto se esponente è un valore intero. Quando vengono eseguite
più operazioni di elevamento a potenza in una sola espressione, l'operatore ^ viene valutato
nell'ordine in cui compare, da sinistra a destra.
Il tipo di dati di risultato è in genere un valore Double o un valore Variant che include un valore
Double. Se tuttavia numero o esponente è un'espressione Null, anche risultato sarà Null.
Esempio di operatore ^
In questo esempio l'operatore ^ viene utilizzato per elevare un numero alla potenza di un esponente.
Dim MyValue
MyValue = 2 ^ 2
' Restituisce 4.
MyValue = 3 ^ 3 ^ 3
' Restituisce 19683.
MyValue = (-5) ^ 3
' Restituisce -125.
9 di 81
Operatore *
Utilizzato per moltiplicare due numeri.
Sintassi
risultato = numero1*numero2
La sintassi dell'operatore * è composta dalle seguenti parti:
Parte
Descrizione
risultato Obbligatoria. Qualsiasi variabile numerica.
numero1 Obbligatoria. Qualsiasi espressione numerica.
numero2 Obbligatoria. Qualsiasi espressione numerica.
Osservazioni
Il tipo di dati di risultato è in genere quello dell'espressione più precisa. L'ordine di precisione
crescente è Byte, Integer, Long, Single, Double, Currency e Decimal. Esistono tuttavia alcune
eccezioni a tale tipo di ordine:
Se
Risultato sarà
La moltiplicazione viene eseguita tra valori
Single e Long,
convertito in Double.
Il tipo di dati di risultato è un valore Variant di
tipo Long, Single o Date che non rientra
nell'intervallo consentito,
convertito in un valore Variant che contiene un
valore Double.
Il tipo di dati di risultato è un valore Variant di
tipo Byte che non rientra nell'intervallo
consentito,
convertito in un valore Variant di tipo Integer.
Il tipo di dati di risultato è un valore Variant di
tipo Integer che non rientra nell'intervallo
consentito,
convertito in un valore Variant di tipo Long.
Se una o entrambe le espressioni sono espressioni Null, risultato sarà Null. Qualsiasi espressione
con valore Empty sarà considerata uguale a 0.
Nota L'ordine di precisione utilizzato per la moltiplicazione non è lo stesso utilizzato per
l'addizione e la sottrazione.
Esempio di operatore *
In questo esempio l'operatore * viene utilizzato per moltiplicare due numeri.
Dim MyValue
MyValue = 2 * 2
' Restituisce 4.
MyValue = 459.35 * 334.90
' Restituisce 153836,315.
Operatore /
Utilizzato per dividere due numeri e restituire un risultato con virgola mobile.
Sintassi
risultato = numero1/numero2
La sintassi dell'operatore / è composta dalle seguenti parti:
10 di 81
Parte
Descrizione
risultato Obbligatoria. Qualsiasi variabile numerica.
numero1 Obbligatoria. Qualsiasi espressione numerica.
numero2 Obbligatoria. Qualsiasi espressione numerica.
Osservazioni
Il tipo di dati di risultato è in genere Double o un valore Variant di tipo Double. Esistono tuttavia
alcune eccezioni a tale tipo di ordine:
Se
Risultato sarà
Entrambe le espressioni sono Byte, Integer o
Single,
un valore Single a meno che non superi
l'intervallo ammesso. In quest'ultimo caso, verrà
generato un errore.
Entrambe le espressioni sono Variant di tipo
Byte, Integer o Single,
un valore Variant di tipo Single a meno che non
superi l'intervallo ammesso. In quest'ultimo
caso, risultato sarà un valore Variant che
contiene un valore Double.
La divisione riguarda il tipo di dati Decimal e
qualsiasi altro tipo di dati,
un tipo di dati Decimal.
Se una o entrambe le espressioni sono espressioni Null, risultato sarà Null. Qualsiasi espressione
con valore Empty sarà considerata uguale a 0.
Esempio di operatore /
In questo esempio l'operatore / viene utilizzato per eseguire una divisione in virgola mobile.
Dim MyValue
MyValue = 10 / 4
MyValue = 10 / 3
' Restituisce 2,5.
' Restituisce 3,333333.
Operatore \
Utilizzato per dividere due numeri e restituire un risultato intero.
Sintassi
risultato = numero1\numero2
La sintassi dell'operatore \ è composta dalle seguenti parti:
Parte
Descrizione
risultato Obbligatoria. Qualsiasi variabile numerica.
numero1 Obbligatoria. Qualsiasi espressione numerica.
numero2 Obbligatoria. Qualsiasi espressione numerica.
Osservazioni
Prima di eseguire la divisione, le espressioni numeriche vengono arrotondate in espressioni di tipo
Byte, Integer o Long.
Il tipo di dati di risultato è in genere Byte, un valore Variant con sottotipo Byte, Integer, Variant
Integer, Long o Variant Long indipendentemente dal fatto che risultato sia o meno un numero
11 di 81
intero. La parte frazionaria verrà eliminata. Se tuttavia un'espressione è Null, risultato sarà Null.
Qualsiasi espressione con valore Empty sarà considerata uguale a 0.
Esempio di operatore \
In questo esempio l'operatore \ viene utilizzato per eseguire una divisione intera.
Dim MyValue
MyValue = 11 \ 4
MyValue = 9 \ 3
MyValue = 100 \ 3
' Restituisce 2.
' Restituisce 3.
' Restituisce 33.
Operatore Mod
Utilizzato per dividere due numeri e restituire soltanto il resto della divisione.
Sintassi
risultato = numero1 Mod numero2
La sintassi dell'operatore Mod è composta dalle seguenti parti:
Parte
Descrizione
risultato Obbligatoria. Qualsiasi variabile numerica.
numero1 Obbligatoria. Qualsiasi espressione numerica.
numero2 Obbligatoria. Qualsiasi espressione numerica.
Osservazioni
L'operatore Mod, o resto, divide numero1 per numero2, arrotondando i numeri a virgola mobile in
numeri interi e restituisce come risultato soltanto il resto della divisione. Come, ad esempio,
nell'espressione che segue in cui A (risultato) è uguale a 5.
A = 19 Mod 6.7
Il tipo di dati di risultato è in genere Byte, Variant Byte, Integer, Variant Integer, Long o Variant
che contiene un valore Long, indipendentemente dal fatto che risultato sia o meno un numero
intero. La parte frazionaria verrà troncata. Se tuttavia un'espressione è Null, risultato sarà Null.
Qualsiasi espressione con valore Empty sarà considerata uguale a 0.
Esempio di operatore Mod
In questo esempio l'operatore Mod viene utilizzato per dividere due numeri e restituire solo il resto.
Se uno dei numeri è decimale, verrà arrotondato all'intero.
Dim MyResult
MyResult = 10 Mod 5
MyResult = 10 Mod 3
MyResult = 12 Mod 4.3
MyResult = 12.6 Mod 5
' Restituisce 0.
' Restituisce 1.
' Restituisce 0.
' Restituisce 3.
Operatore +
Utilizzato per sommare due numeri.
Sintassi
risultato = espressione1+espressione2
La sintassi dell'operatore + è composta dalle seguenti parti:
Parte
Descrizione
12 di 81
risultato
Obbligatoria. Qualsiasi variabile numerica.
espressione1 Obbligatoria. Qualsiasi espressione.
espressione2 Obbligatoria. Qualsiasi espressione.
Osservazioni
L'utilizzo dell'operatore + non consente di determinare se verrà eseguita un'operazione di addizione
o di concatenamento di stringhe. Per evitare ambiguità nell'esecuzione e per fornire del codice
autoesplicativo, si consiglia di utilizzare a questo scopo l'operatore & per il concatenamento.
Se almeno una espressione non è di tipo Variant, saranno valide le seguenti regole:
Se
Operazione eseguita
Entrambe le espressioni sono costituite da tipi di
dati numerici (Byte, Boolean, Integer, Long,
Single, Double, Date, Currency o Decimal)
Addizione.
Entrambe le espressioni sono di tipo String
Concatenamento.
Un'espressione contiene dati di tipo numerico e
l'altra è di tipo Variant (diversa da Null)
Addizione.
Un'espressione è di tipo String e l'altra è di tipo
Variant (diversa da Null)
Concatenamento.
Un'espressione è un valore Variant di tipo Empty
Restituisce come risultato l'altra espressione
invariata.
Un'espressione contiene dati di tipo numerico e
l'altra è di tipo String
Viene generato l'errore Tipo non corrispondente.
Entrambe le espressioni sono Null
risultato sarà Null.
Se entrambe le espressioni sono di tipo Variant, saranno valide le seguenti regole:
Se
Operazione eseguita
Entrambe le espressioni Variant sono di tipo
numerico
Addizione.
Entrambe le espressioni Variant sono di tipo
stringa
Concatenamento.
Un'espressione Variant è di tipo numerico e l'altra Addizione.
è di tipo stringa
Nel caso di una semplice addizione aritmetica, riguardante soltanto espressioni numeriche, il tipo di
dati di risultato è in genere quello dell'espressione più precisa. L'ordine crescente di precisione è
Byte, Integer, Long, Single, Double, Currency e Decimal. Esistono tuttavia alcune eccezioni a
tale ordine:
Se
Risultato sarà
Un valore Single e uno Long vengono sommati
un Double.
Il tipo di dati di risultato è un valore Variant di
convertito in un valore Variant di tipo Double.
13 di 81
tipo Long, Single o Date che non rientra
nell'intervallo consentito,
Il tipo di dati di risultato è un valore Variant di
tipo Byte che non rientra nell'intervallo
consentito,
convertito in un valore Variant di tipo Integer.
Il tipo di dati di risultato è un valore Variant di
tipo Integer che non rientra nell'intervallo
consentito,
convertito in un valore Variant di tipo Long.
Un tipo di dati Date viene aggiunto a qualsiasi
tipo di dati,
Date.
Se una o entrambe le espressioni sono Null, risultato sarà Null. Se entrambe le espressioni hanno
valore Empty, risultato sarà Integer. Se tuttavia una sola espressione ha valore Empty, l'altra
espressione verrà restituita invariata come valore di risultato.
Nota L'ordine di precisione utilizzato per l'addizione e la sottrazione non è lo stesso utilizzato per
la moltiplicazione.
Esempio di operatore +
In questo esempio l'operatore + viene utilizzato per sommare numeri. L'operatore + può inoltre
essere utilizzato per concatenare le stringhe. Per evitare ambiguità, è tuttavia consigliabile utilizzare
l'operatore &. Se i componenti di un'espressione creata con l'operatore + includono sia stringhe che
valori numerici, verrà assegnato il risultato aritmetico. Se i componenti sono soltanto stringhe,
queste verranno concatenate.
Dim MyNumber, Var1, Var2
MyNumber = 2 + 2
' Restituisce 4.
MyNumber = 4257.04 + 98112
' Restituisce 102369,04.
Var1 = "34": Var2 = 6
MyNumber = Var1 + Var2
Var1 = "34": Var2 = "6"
MyNumber = Var1 + Var2
' Inizializza le variabili miste.
' Restituisce 40.
' Inizializza le variabili con stringhe.
' Restituisce "346" (concatenamento di stringhe).
Operatore –
Utilizzato per calcolare la differenza tra due numeri o indicare il valore negativo di una espressione
numerica.
Sintassi 1
risultato = numero1–numero2
Sintassi 2
–numero
La sintassi dell'operatore - è composta dalle seguenti parti:
Parte
Descrizione
risultato Obbligatoria. Qualsiasi variabile numerica.
numero
Obbligatoria. Qualsiasi espressione numerica.
numero1 Obbligatoria. Qualsiasi espressione numerica.
14 di 81
numero2 Obbligatoria. Qualsiasi espressione numerica.
Osservazioni
Nella sintassi 1, l'operatore - è l'operatore aritmetico di sottrazione utilizzato per calcolare la
differenza tra due numeri. Nella sintassi 2, l'operatore - viene utilizzato come operatore di
negazione unario per indicare il valore negativo di un'espressione.
Il tipo di dati di risultato è in genere quello dell'espressione più precisa. L'ordine di precisione
crescente è Byte, Integer, Long, Single, Double, Currency e Decimal. Esistono tuttavia alcune
eccezioni a tale tipo di ordine:
Se
Risultato sarà
La sottrazione viene eseguita tra valori Single e
Long,
convertito in Double.
Il tipo di dati di risultato è un valore Variant di
tipo Long, Single o Date che non rientra
nell'intervallo consentito,
convertito in un valore Variant che contiene un
valore Double.
Il tipo di dati di risultato è un valore Variant di
tipo Byte che non rientra nell'intervallo
consentito,
convertito in un valore Variant di tipo Integer.
Il tipo di dati di risultato è un valore Variant di
tipo Integer che non rientra nell'intervallo
consentito,
convertito in un valore Variant di tipo Long.
La sottrazione viene eseguita tra un tipo di dati
Date e un qualsiasi altro tipo di dati,
Date.
La sottrazione viene eseguita tra due espressioni
Date,
Double.
Se una o entrambe le espressioni sono espressioni Null, risultato sarà Null. Qualsiasi espressione
con valore Empty sarà considerata uguale a 0.
Nota L'ordine di precisione utilizzato per l'addizione e la sottrazione non è lo stesso utilizzato per
la moltiplicazione.
Esempio di operatore In questo esempio l'operatore - viene utilizzato per calcolare la differenza tra due numeri.
Dim MyResult
MyResult = 4 - 2
' Restituisce 2.
MyResult = 459.35 - 334.90
' Restituisce 124,45.
Operatori di confronto
Utilizzati per confrontare due espressioni.
Sintassi
risultato = espressione1 operatorediconfronto espressione2
risultato = oggetto1 Is oggetto2
risultato = stringa Like criterio
La sintassi degli operatori di confronto è composta dalle seguenti parti:
15 di 81
Parte
Descrizione
risultato
Obbligatoria. Qualsiasi variabile numerica.
espressione
Obbligatoria. Qualsiasi espressione.
operatorediconfronto
Obbligatoria. Qualsiasi operatore di confronto.
oggetto
Obbligatoria. Qualsiasi nome di oggetto.
stringa
Obbligatoria. Qualsiasi espressione stringa.
criterio
Obbligatoria. Qualsiasi espressione stringa o intervallo di caratteri.
Osservazioni
La seguente tabella contiene un elenco degli operatori di confronto e delle condizioni che
determinano se risultato è True, False o Null:
Operatore
True se
False se
Null se
< (Minore di)
espressione1 <
espressione2
espressione1 >=
espressione2
espressione1 o
espressione2 = Null
<= (Minore o uguale
a)
espressione1 <=
espressione2
espressione1 >
espressione2
espressione1 o
espressione2 = Null
> (Maggiore di)
espressione1 >
espressione2
espressione1 <=
espressione2
espressione1 o
espressione2 = Null
>= (Maggiore o
uguale a)
espressione1 >=
espressione2
espressione1 <
espressione2
espressione1 o
espressione2 = Null
= (Uguale a)
espressione1 =
espressione2
espressione1 <>
espressione2
espressione1 o
espressione2 = Null
<> (Diverso)
espressione1 <>
espressione2
espressione1 =
espressione2
espressione1 o
espressione2 = Null
Nota Gli operatori Is e Like eseguono il confronto in un modo specifico diverso rispetto a quello
utilizzato dagli operatori elencati nella tabella.
Confrontando due espressioni, può risultare difficile stabilire se le espressioni sono numeri o
stringhe. La tabella seguente mostra le modalità di confronto o il risultato del confronto quando una
delle due espressioni non è di tipo Variant:
Se
Risultato
Entrambe le espressioni sono tipi di dati numerici
(Byte, Boolean, Integer, Long, Single, Double,
Date, Currency o Decimal)
Viene eseguito un confronto numerico.
Entrambe le espressioni sono di tipo String
Viene eseguito un confronto fra stringhe.
Un'espressione è un valore di tipo numerico e
l'altra è di tipo Variant convertibile in un numero
Viene eseguito un confronto numerico.
Un'espressione è un valore di tipo numerico e
l'altra è una stringa di tipo Variant non
Viene generato l'errore Tipo non corrispondente.
16 di 81
convertibile in un numero
Un'espressione è di tipo String e l'altra è una
qualsiasi Variant a eccezione di Null
Viene eseguito un confronto fra stringhe.
Un'espressione ha valore Empty e l'altra è un tipo
di dati numerico
Viene eseguito un confronto numerico
utilizzando 0 come espressione con valore
Empty.
Un'espressione è Empty e l'altra è di tipo String
Viene eseguito un confronto fra stringhe
utilizzando una stringa di lunghezza zero come
espressione con valore Empty.
Se espressione1 ed espressione2 sono entrambe espressioni di tipo Variant il loro sottotipo
determinerà la modalità di confronto. La tabella seguente mostra come vengono confrontate le
espressioni o qual è il risultato del confronto in base al sottotipo Variant:
Se
Risultato
Entrambe le espressioni Variant sono numeriche
Viene eseguito un confronto numerico.
Entrambe le espressioni Variant sono stringhe
Viene eseguito un confronto fra stringhe.
Un'espressione Variant è di tipo numerico e l'altra L'espressione numerica è minore
è di tipo stringa
dell'espressione stringa.
Un'espressione Variant ha valore Empty e l'altra
è di tipo numerico
Viene eseguito un confronto numerico
utilizzando 0 come espressione con valore
Empty.
Un'espressione Variant ha valore Empty e l'altra
è di tipo stringa
Viene eseguito un confronto fra stringhe,
utilizzando una stringa di lunghezza zero ("")
come espressione con valore Empty.
Entrambe le espressioni Variant hanno valore
Empty
Le espressioni sono uguali.
Quando un valore Single viene confrontato con un valore Double, il valore Double viene
arrotondato alla precisione del valore Single.
Se un valore di tipo Currency viene confrontato con un valore di tipo Single o Double, il valore
Single o Double verrà convertito in un valore di tipo Currency. In modo analogo, se un valore
Decimal viene confrontato cun valore Single o Double, il valore Single o Double viene convertito
in Decimal. Per i valori Currency, le parti frazionarie del valore inferiori a 0,0001 potrebbero
essere perdute; per i valori Decimal, le parti frazionarie del valore inferiori a 1E-28 potrebbero
essere perdute oppure potrebbe verificarsi un errore di overflow. A causa di tale perdita della parte
frazionaria del valore sarà possibile che il risultato indichi come uguali due valori che in realtà non
lo sono.
Istruzione Option Compare
Utilizzata a livello di modulo per dichiarare la modalità di confronto predefinita da utilizzare per
confrontare i dati di una stringa.
Sintassi
Option Compare {Binary | Text | Database}
17 di 81
Osservazioni
Se si utilizza l'istruzione Option Compare, è necessario inserirla in un modulo prima di qualsiasi
altra routine.
L'istruzione Option Compare specifica il metodo di confronto di stringhe (Binary, Text o
Database) per un modulo. Se un modulo non include un'istruzione Option Compare, il metodo di
confronto testuale predefinito è Binary.
L'istruzione Option Compare Binary consente di eseguire confronti testuali sulla base di un tipo di
ordinamento derivato dalla rappresentazione binaria interna dei caratteri. In Microsoft Windows
l'ordinamento è determinato dalla tabella codici. Nell'esempio che segue viene illustrato un tipico
ordinamento binario:
A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø
L'istruzione Option Compare Text consente di eseguire confronti di stringhe sulla base di un
ordinamento testuale indipendente dalla combinazione di maiuscole e minuscole determinato dalle
impostazioni internazionali del sistema in uso. Gli stessi caratteri dell'esempio precedente, se
ordinati utilizzando l'istruzione Option Compare Text producono il risultato seguente:
(A=a) < ( À=à) < (B=b) < (E=e) < (Ê=ê) < (Z=z) < (Ø=ø)
L’istruzione Option Compare Database può essere utilizzata solo in Microsoft Access e consente
di eseguire confronti di stringhe sulla base di un ordinamento determinato dall’ID di paese del
database in cui viene eseguito il confronto.
Esempio di istruzione Option Compare
In questo esempio l'istruzione Option Compare viene utilizzata per impostare la modalità
predefinita di confronto delle stringhe. L'istruzione Option Compare viene utilizzata solo a livello
di modulo.
' Imposta il metodo di confronto stringhe su Binary.
Option compare Binary
' Esempio: "AAA" minore di "aaa".
' Imposta il metodo di confronto stringhe su Text.
Option compare Text
' Esempio: "AAA" uguale a "aaa".
Istruzione Option Explicit
Utilizzata a livello di modulo per fare in modo che tutte le variabili del modulo vengano dichiarate
in modo esplicito.
Sintassi
Option Explicit
Osservazioni
Se si utilizza l'istruzione Option Explicit, è necessario inserirla in un modulo prima di qualsiasi
altra routine.
Quando si utilizza l'istruzione Option Explicit tutte le variabili devono essere dichiarate in modo
esplicito utilizzando le istruzioni Dim, Private, Public, ReDim o Static . Se si prova a utilizzare un
nome di una variabile non dichiarata, verrà generato un errore in fase di compilazione.
Se non si utilizza l'istruzione Option Explicit, tutte le variabili non dichiarate saranno di tipo
Variant, a meno che non sia stato specificato un tipo predefinito diverso con un'istruzione Deftipo.
Nota È consigliabile utilizzare l'istruzione Option Explicit per evitare di digitare in maniera errata
il nome di una variabile esistente oppure di creare confusione nel codice nel quale l'area di validità
della variabile non è chiara.
Esempio di istruzione Option Explicit
In questo esempio l'istruzione Option Explicit viene utilizzata per forzare la dichiarazione esplicita
18 di 81
di tutte le variabili. Se si cerca di utilizzare una variabile non dichiarata, in fase di compilazione
verrà generato un errore. L'istruzione Option Explicit viene utilizzata solo a livello di modulo.
Option explicit
Dim MyVar
MyInt = 10
MyVar = 10
' Forza la dichiarazione esplicita
' delle variabili.
' Dichiara la variabile.
' La variabile non dichiarata genera un errore.
' Non vengono generati errori.
Operatore =
Descrizione
Viene utilizzato per assegnare un valore a una variabile o proprietà.
Sintassi
variabile = valore
La sintassi dell'operatore = è composta dalle seguenti parti:
Parte
Descrizione
variabile
Qualsiasi variabile o proprietà in scrittura.
valore
Qualsiasi letterale numerico o stringa, costante o espressione.
Osservazioni
Il nome a sinistra del segno uguale può essere una variabile scalare o l'elemento di una matrice. Le
proprietà a sinistra del segno uguale possono essere solo proprietà che in fase di esecuzione sono in
scrittura.
Operatore Is
Utilizzato per confrontare due variabili che fanno riferimento a oggetti.
Sintassi
risultato = oggetto1 Is oggetto2
La sintassi dell'operatore Is è composta dalle seguenti parti:
Parte
Descrizione
risultato Obbligatoria. Qualsiasi variabile numerica.
oggetto1 Obbligatoria. Qualsiasi espressione.
oggetto2 Obbligatoria. Qualsiasi espressione.
Osservazioni
Se oggetto1 e oggetto2 si riferiscono allo stesso oggetto, risultato sarà True; in caso contrario,
risultato sarà False. Due variabili possono fare riferimento allo stesso oggetto in diversi modi.
Nel seguente esempio, A è stata impostata in modo che faccia riferimento allo stesso oggetto di B:
Set A = B
Nel seguente esempio A e B sono state impostate in modo che facciano riferimento allo stesso
oggetto di C:
Set A = C
Set B = C
19 di 81
Esempio di operatore Is
In questo esempio l'operatore Is viene utilizzato per confrontare due riferimenti di oggetto. Tutte le
variabili di oggetto utilizzate nell'esempio sono nomi generici utilizzati solo a titolo esemplificativo.
Dim MyObject, YourObject, ThisObject, OtherObject, ThatObject, MyCheck
Set YourObject = MyObject
' Assegna i riferimenti di oggetto.
Set ThisObject = MyObject
Set ThatObject = OtherObject
MyCheck = YourObject Is ThisObject
' Restituisce True.
MyCheck = ThatObject Is ThisObject
' Restituisce False.
' Presume che MyObject <> OtherObject
MyCheck = MyObject Is ThatObject
' Restituisce False.
Operatore Like
Utilizzato per confrontare due stringhe.
Sintassi
risultato = stringa Like criterio
La sintassi dell'operatore Like è composta dalle seguenti parti:
Parte
Descrizione
risultato
Obbligatoria. Qualsiasi variabile numerica.
stringa
Obbligatoria. Qualsiasi espressione stringa.
criterio
Obbligatoria. Qualsiasi espressione stringa che corrisponda ai criteri di confronto
come indicato nella sezione "Osservazioni".
Osservazioni
Se stringa corrisponde a criterio, risultato sarà True; se non c'è corrispondenza, risultato sarà
False. Se stringa oppure criterio è Null, anche risultato sarà Null.
Il comportamento dell'operatore Like dipende dall'istruzione Option Compare. Il metodo di
confronto fra stringhe predefinito per tutti i moduli è Option Compare Binary.
L'istruzione Option Compare Binary consente di eseguire confronti fra stringhe sulla base di un
tipo di ordinamento derivato dalla rappresentazione binaria interna dei caratteri. Il tipo di
ordinamento è determinato dalla tabella codici. Nell'esempio che segue viene illustrato un tipico
ordinamento binario:
A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø
L'istruzione Option Compare Text consente di eseguire confronti fra stringhe sulla base di un
ordinamento testuale indipendente dalla combinazione di maiuscole/minuscole e determinato dalle
impostazioni internazionali del sistema in uso. Se gli stessi caratteri dell'esempio precedente
venissero ordinati utilizzando l'istruzione Option Compare Text verrebbe prodotto il seguente
risultato:
(A=a) < (À=à) < (B=b) < (E=e) < (Ê=ê) < (Z=z) < (Ø=ø)
I criteri di confronto incorporati rappresentano un valido strumento per i confronti fra stringhe. Tali
criteri consentono di utilizzare i caratteri jolly, elenchi di caratteri o intervalli di caratteri in
qualsiasi combinazione. La seguente tabella indica i caratteri utilizzabili in criterio e le relative
corrispondenze:
Carattere/i in criterio
Corrispondenze in stringa
?
Qualsiasi carattere singolo.
*
Zero o più caratteri.
20 di 81
#
Qualsiasi cifra singola (0-9).
[elencocaratteri]
Qualsiasi carattere singolo in elencocaratteri.
[!elencocaratteri]
Qualsiasi carattere singolo non compreso in elencocaratteri.
È possibile utilizzare un gruppo di uno o più caratteri (elencocaratteri) racchiusi tra parentesi
quadre ([ ]) per cercare una corrispondenza con qualsiasi carattere singolo in stringa. Tale gruppo
può comprendere qualsiasi codice di carattere, incluse le cifre.
Nota Per trovare i caratteri speciali parentesi quadra sinistra ([), punto interrogativo (?), simbolo di
numero (#) e asterisco (*) è necessario racchiuderli tra parentesi quadre. La parentesi quadra destra
(]) non può essere utilizzata in un gruppo per la ricerca di altre parentesi quadre destre, ma può
essere utilizzata come carattere singolo al di fuori di un gruppo.
In elencocaratteri è possibile specificare un intervallo di caratteri utilizzando un trattino (-) per
separare il limite superiore e quello inferiore dell'intervallo di caratteri. Se si specifica, ad esempio,
[A-Z] verrà trovata la corrispondenza se la posizione del carattere corrispondente in stringa
contiene una delle lettere maiuscole dell'intervallo da A a Z. È possibile inserire tra parentesi quadre
più intervalli, senza alcun carattere di delimitazione.
Il significato di un determinato intervallo dipende dall'ordinamento dei caratteri valido in fase di
esecuzione, determinato dall'istruzione Option Compare e dalle impostazioni internazionali del
sistema in cui è in esecuzione il codice. Sulla base dell'esempio sopraindicato per l'istruzione
Option Compare Binary, l'intervallo [A–E] consente di individuare le corrispondenze A, B e E. Se
si utilizza l'istruzione Option Compare Text, [A–E] consente di individuare le corrispondenze A, a,
À, à, B, b, E, e. Si noti che nel confronto le lettere Ê o ê non risultano corrispondenti in quanto
nell'ordine alfabetico i caratteri accentati seguono i caratteri non accentati.
Di seguito vengono riportate alcune delle regole più importanti relative alla corrispondenza dei
criteri:
• Un punto esclamativo (!) all'inizio di elencocaratteri significa che verrà segnalata una
corrispondenza se in stringa sarà rilevato qualsiasi carattere ad eccezione dei caratteri
contenuti in elencocaratteri. Se è utilizzato al di fuori delle parentesi quadre, il punto
esclamativo consentirà di trovare una corrispondenza con un altro punto esclamativo.
• Per ottenere una corrispondenza con il trattino (-) tale carattere dovrà essere inserito
all'inizio (dopo l'eventuale punto esclamativo) o alla fine di elencocaratteri. In qualsiasi
altra posizione, il trattino viene utilizzato per identificare un intervallo di caratteri.
• Quando si specifica un intervallo di caratteri, tali caratteri devono essere indicati in ordine
crescente (dal minore al maggiore). [A-Z] è ad esempio un criterio valido a differenza di [Z-A].
• La sequenza di caratteri [] viene considerata come una stringa di lunghezza zero ("").
L'alfabeto di alcune lingue include caratteri speciali che rappresentano l'insieme di due diversi
caratteri, come ad esempio il carattere "æ" per rappresentare "a" e "e". L'operatore Like riconosce il
singolo carattere speciale come equivalente dei due caratteri distinti.
Se nelle impostazioni internazionali di sistema viene specificata una lingua che utilizza questo tipo
di caratteri speciali, un'occorrenza del singolo carattere speciale in criterio o stringa corrisponderà
alla sequenza equivalente di due caratteri nell'altra stringa. In modo analogo, un singolo carattere
speciale in criterio racchiuso tra parentesi quadre (da solo, in un elenco o in un intervallo)
corrisponderà alla sequenza equivalente di due caratteri in stringa.
Esempio di operatore Like
In questo esempio l'operatore Like viene utilizzato per confrontare una stringa con una stringa
modello.
Dim MyCheck
MyCheck = "aBBBa" Like "a*a"
MyCheck = "F" Like "[A-Z]"
' Restituisce Vero.
' Restituisce Vero.
21 di 81
MyCheck
MyCheck
MyCheck
MyCheck
MyCheck
=
=
=
=
=
"F" Like "[!A-Z]"
' Restituisce Falso.
"a2a" Like "a#a"
' Restituisce Vero.
"aM5b" Like "a[L-P]#[!c-e]"
' Restituisce Vero.
"BAT123khg" Like "B?T*"
' Restituisce Vero.
"CAT123khg" Like "B?T*"
' Restituisce Falso.
Esempio di operatori di confronto
In questo esempio vengono illustrati i vari utilizzi degli operatori di confronto, che consentono di
confrontare espressioni.
Dim MyResult, Var1, Var2
MyResult = (45 < 35)
' Restituisce Falso.
MyResult = (45 = 45)
' Restituisce Vero.
MyResult = (4 <> 3)
' Restituisce Vero.
MyResult = ("5" > "4")
' Restituisce Vero.
Var1 = "5": Var2 = 4
' Inizializza le variabili.
MyResult = (Var1 > Var2)
' Restituisce Vero.
Var1 = 5: Var2 = Empty
MyResult = (Var1 > Var2)
' Restituisce Vero.
Var1 = 0: Var2 = Empty
MyResult = (Var1 = Var2)
' Restituisce Vero.
Operatori di concatenamento
Operatore &
Operatore +
Operatore &
Utilizzato per concatenare le stringhe di due espressioni.
Sintassi
risultato = espressione1 & espressione2
La sintassi dell'operatore & è composta dalle seguenti parti:
Parte
risultato
Descrizione
Obbligatoria. Qualsiasi variabile String o Variant.
espressione1 Obbligatoria. Qualsiasi espressione.
espressione2 Obbligatoria. Qualsiasi espressione.
Osservazioni
Quando espressione non è una stringa viene convertita in un valore Variant di tipo String. Il tipo
di dati di risultato è String se entrambe le espressioni sono espressioni stringa, altrimenti risultato è
un valore Variant di tipo String. Se entrambe le espressioni sono Null, risultato sarà Null. Se,
tuttavia, solo un'espressione è Null, tale espressione sarà considerata come una stringa di lunghezza
zero quando viene concatenata all'altra espressione. Qualsiasi espressione con valore Empty sarà
considerata equivalente a una stringa di lunghezza zero.
Esempio di operatore &
In questo esempio l'operatore & viene utilizzato per forzare il concatenamento di stringhe.
22 di 81
Dim MyStr
MyStr = "Salve" & " gente"
' Restituisce "Salve gente".
MyStr = "Prova " & 123 & " Prova"
' Restituisce "Prova 123 Prova".
Operatori logici
Operatore And
Operatore Eqv
Operatore Imp
Operatore Not
Operatore Or
Operatore Xor
Operatore And
Utilizzato per eseguire un collegamento logico tra due espressioni.
Sintassi
risultato = espressione1 And espressione2
La sintassi dell'operatore And è composta dalle seguenti parti:
Parte
Descrizione
Obbligatoria. Qualsiasi variabile numerica.
risultato
espressione1 Obbligatoria. Qualsiasi espressione.
espressione2 Obbligatoria. Qualsiasi espressione.
Osservazioni
Solo nel caso in cui entrambe le espressioni diano come risultato True, risultato sarà True. Se una
delle espressioni dà come risultato False, risultato sarà False. La seguente tabella mostra come
viene determinato risultato:
Valore di
espressione1
Valore di espressione2
Valore di risultato
True
True
True
True
False
False
True
Null
Null
False
True
False
False
False
False
False
Null
False
Null
True
Null
Null
False
False
Null
Null
Null
L'operatore And esegue un confronto bit per bit dei bit collocati nella stessa posizione in due
diverse espressioni numeriche e imposta il bit corrispondente in risultato in base alla seguente
23 di 81
tabella:
Valore del bit in
espressione1
Valore del bit in
espressione2
Valore di risultato
0
0
0
0
1
0
1
0
0
1
1
1
Esempio di operatore And
In questo esempio l'operatore And viene utilizzato per eseguire un collegamento logico di due
espressioni.
Dim A, B,
A = 10: B
MyCheck =
MyCheck =
MyCheck =
MyCheck =
C, D, MyCheck
= 8: C = 6: D = Null
' Inizializza le variabili.
A > B And B > C
' Restituisce Vero.
B > A And B > C
' Restituisce Falso.
A > B And B > D
' Restituisce Nullo.
A And B
' Restituisce 8 (confronto bit per bit).
Operatore Eqv
Utilizzato per stabilire un'equivalenza logica tra due espressioni.
Sintassi
risultato = espressione1 Eqv espressione2
La sintassi dell'operatore Eqv è composta dalle seguenti parti:
Parte
Descrizione
Obbligatoria. Qualsiasi variabile numerica.
risultato
espressione1 Obbligatoria. Qualsiasi espressione.
espressione2 Obbligatoria. Qualsiasi espressione.
Osservazioni
Quando una delle due espressioni è un valore Null, anche risultato sarà Null. Quando nessuna delle
due espressioni è Null, risultato sarà determinato in base alla seguente tabella:
Valore di
espressione1
Valore di espressione2
Valore di risultato
True
True
True
True
False
False
False
True
False
False
False
True
L'operatore Eqv esegue un confronto bit per bit dei bit collocati nella stessa posizione in due
diverse espressioni numeriche e imposta il bit corrispondente in risultato in base alla seguente
tabella:
24 di 81
Valore di
espressione1
Valore di espressione2
Valore di risultato
0
0
1
0
1
0
1
0
0
1
1
1
Esempio di operatore Eqv
In questo esempio l'operatore Eqv viene utilizzato per eseguire un'equivalenza logica tra due
espressioni.
Dim A, B,
A = 10: B
MyCheck =
MyCheck =
MyCheck =
MyCheck =
C, D, MyCheck
= 8: C = 6: D = Null
' Inizializza le variabili.
A > B Eqv B > C
' Restituisce Vero.
B > A Eqv B > C
' Restituisce Falso.
A > B Eqv B > D
' Restituisce Nullo.
A Eqv B
' Restituisce -3 (confronto bit per bit).
Operatore Imp
Utilizzato per stabilire un'implicazione logica tra due espressioni.
Sintassi
risultato = espressione1 Imp espressione2
La sintassi dell'operatore Imp è composta dalle seguenti parti:
Parte
Descrizione
Obbligatoria. Qualsiasi variabile numerica.
risultato
espressione1 Obbligatoria. Qualsiasi espressione.
espressione2 Obbligatoria. Qualsiasi espressione.
Osservazioni
La seguente tabella mostra come viene determinato risultato:
Valore di
espressione1
Valore di espressione2
Valore di risultato
True
True
True
True
False
False
True
Null
Null
False
True
True
False
False
True
False
Null
True
Null
True
True
25 di 81
Null
False
Null
Null
Null
Null
L'operatore Imp esegue un confronto bit per bit dei bit collocati nella stessa posizione in due
diverse espressioni numeriche e imposta il bit corrispondente in risultato in base alla seguente
tabella:
Valore del bit in
espressione1
Valore del bit in
espressione2
Valore di risultato
0
0
1
0
1
1
1
0
0
1
1
1
Esempio di operatore Imp
In questo esempio l'operatore Imp viene utilizzato per eseguire un'implicazione logica di due
espressioni.
Dim A, B,
A = 10: B
MyCheck =
MyCheck =
MyCheck =
MyCheck =
MyCheck =
MyCheck =
C, D, MyCheck
= 8: C = 6: D = Null
' Inizializza le variabili.
A > B Imp B > C
' Restituisce Vero.
A > B Imp C > B
' Restituisce Falso.
B > A Imp C > B
' Restituisce Vero.
B > A Imp C > D
' Restituisce Vero.
C > D Imp B > A
' Restituisce Nullo.
B Imp A
' Restituisce -1 (confronto bit per bit).
Operatore Not
Utilizzato per per eseguire una negazione logica di un'espressione.
Sintassi
risultato = Not espressione
La sintassi dell'operatore Not è composta dalle seguenti parti:
Parte
Descrizione
Obbligatoria. Qualsiasi variabile numerica.
risultato
espressione Obbligatoria. Qualsiasi espressione.
Osservazioni
La seguente tabella mostra come viene determinato risultato:
Valore di espressione
Valore di risultato
True
False
False
True
Null
Null
L'operatore Not inverte inoltre i valori dei bit in qualsiasi variabile e imposta il bit corrispondente in
26 di 81
risultato in base alla seguente tabella:
Bit in espressione
Bit in risultato
0
1
1
0
Esempio di operatore Not
In questo esempio l'operatore Not viene utilizzato per eseguire una negazione logica di
un'espressione.
Dim A, B,
A = 10: B
MyCheck =
MyCheck =
MyCheck =
MyCheck =
C, D, MyCheck
= 8: C = 6: D = Null
' Inizializza le variabili.
Not(A > B)
' Restituisce Falso.
Not(B > A)
' Restituisce Vero.
Not(C > D)
' Restituisce Nullo.
Not A
' Restituisce -11 (confronto bit per bit).
Operatore Or
Utilizzato per eseguire una disgiunzione logica tra due espressioni.
Sintassi
risultato = espressione1 Or espressione2
La sintassi dell'operatore Or è composta dalle seguenti parti:
Parte
risultato
Descrizione
Obbligatoria. Qualsiasi variabile numerica.
espressione1 Obbligatoria. Qualsiasi espressione.
espressione2 Obbligatoria. Qualsiasi espressione.
Osservazioni
Se una o entrambe le espressioni rappresentano un valore True, risultato sarà True. La seguente
tabella mostra come viene determinato risultato:
27 di 81
Valore di
espressione1
Valore di
espressione2
Valore di risultato
True
True
True
True
False
True
True
Null
True
False
True
True
False
False
False
False
Null
Null
Null
True
True
Null
False
Null
Null
Null
Null
L'operatore Or esegue un confronto bit per bit dei bit collocati nella stessa posizione in due diverse
espressioni numeriche e imposta il bit corrispondente in risultato in base alla seguente tabella:
Valore del bit in
espressione1
Valore del bit in
espressione2
Valore di risultato
0
0
0
0
1
1
1
0
1
1
1
1
Esempio di operatore Or
In questo esempio l'operatore Or viene utilizzato per eseguire una disgiunzione logica di due
espressioni.
Dim A, B,
A = 10: B
MyCheck =
MyCheck =
MyCheck =
MyCheck =
MyCheck =
C, D, MyCheck
= 8: C = 6: D = Null
' Inizializza le variabili.
A > B Or B > C
' Restituisce Vero.
B > A Or B > C
' Restituisce Vero.
A > B Or B > D
' Restituisce Vero.
B > D Or B > A
' Restituisce Nullo.
A Or B
' Restituisce 10 (confronto bit per bit).
Operatore Xor
Utilizzato per eseguire un'esclusione logica tra due espressioni.
Sintassi
[risultato =] espressione1 Xor espressione2
La sintassi dell'operatore Xor è composta dalle seguenti parti:
Parte
risultato
Descrizione
Facoltativa. qualsiasi variabile numerica.
28 di 81
espressione1 Obbligatoria. Qualsiasi espressione.
espressione2 Obbligatoria. Qualsiasi espressione.
Osservazioni
Se solo una delle due espressioni rappresenta un valore True, risultato sarà True. Tuttavia se una
delle due espressioni è Null, risultato sarà Null. Quando nessuna delle due espressioni è un valore
Null, risultato verrà determinato in base alla seguente tabella:
Valore di
espressione1
Valore di
espressione2
Valore di risultato
True
True
False
True
False
True
False
True
True
False
False
False
L'operatore Xor funziona sia da operatore logico che da operatore bit per bit. Esegue un confronto
bit per bit fra due diverse espressioni utilizzando la logica dell'OR esclusivo per formare il risultato
in base alla seguente tabella:
Valore del bit in
espressione1
Valore del bit in
espressione2
Valore di risultato
0
0
0
0
1
1
1
0
1
1
1
0
Esempio di operatore Xor
In questo esempio l'operatore Xor viene utilizzato per eseguire un'esclusione logica di due
espressioni.
Dim A, B,
A = 10: B
MyCheck =
MyCheck =
MyCheck =
MyCheck =
MyCheck =
C, D, MyCheck
= 8: C = 6: D = Null
' Inizializza le variabili.
A > B Xor B > C
' Restituisce Falso.
B > A Xor B > C
' Restituisce Vero.
B > A Xor C > B
' Restituisce Falso.
B > D Xor A > B
' Restituisce Nullo.
A Xor B
' Restituisce 2 (confronto bit per bit).
Precedenza tra gli operatori
Quando un'espressione contiene varie operazioni, ciascuna parte viene valutata e risolta secondo un
ordine prestabilito, definito "precedenza tra gli operatori".
Se le espressioni includono operatori di diverso tipo, gli operatori aritmetici vengono valutati per
primi, seguiti dagli operatori di confronto e infine dagli operatori logici. Per gli operatori di
confronto non esiste un ordine di precedenza, ovvero vengono semplicemente valutati da sinistra a
destra nell'ordine in cui compaiono. Gli operatori aritmetici e gli operatori logici vengono valutati in
base all'ordine di precedenza indicato nella seguente tabella:
29 di 81
Aritmetici
Di confronto
Logici
Elevazione a potenza (^)
Uguaglianza (=)
Not
Negazione (–)
Disuguaglianza (<>)
And
Moltiplicazione e divisione (*, /)
Minore di (<)
Or
Divisione tra interi (\)
Maggiore di (>)
Xor
Modulo aritmetico (Mod)
Minore o uguale a (<=)
Eqv
Addizione e sottrazione (+, –)
Maggiore o uguale a (>=)
Imp
Concatenamento di stringhe (&)
Like
Is
Quando in un'espressione compaiono una moltiplicazione e una divisione, ogni operazione viene
valutata nell'ordine in cui è visualizzata, da sinistra a destra. Lo stesso vale per un'addizione e una
sottrazione all'interno di una stessa espressione. Utilizzando le parentesi tonde, è possibile ignorare
l'ordine di precedenza e far in modo che alcune parti di un'espressione vengano valutate prima di
altre. Le operazioni tra parentesi tonde hanno sempre la precedenza rispetto alle altre. All'interno
delle parentesi tonde, tuttavia, viene rispettata la normale precedenza tra gli operatori.
L'operatore di concatenamento di stringhe (&) non è un vero e proprio operatore aritmetico. Per
quanto riguarda la precedenza, segue tutti gli operatori aritmetici e precede tutti gli operatori di
confronto.
L'operatore Like, pur avendo precedenza uguale a tutti gli operatori di confronto è di fatto un
operatore per il confronto fra criteri di ricerca.
L'operatore Is viene utilizzato per il confronto del riferimento degli oggetti. Non confronta infatti
gli oggetti e i loro valori ma verifica soltanto se due riferimenti di oggetto sono relativi allo stesso
oggetto.
30 di 81
Esecuzione condizionale del codice
Istruzione If...Then...Else
Consente l'esecuzione condizionale di un gruppo di istruzioni in base al valore di un'espressione.
Sintassi
If condizione Then [istruzioni] [Else istruzionielse]
In alternativa, è possibile utilizzare la seguente sintassi a blocchi:
If condizione Then
[istruzioni]
[ElseIf condizione-n Then
[istruzionielseif] ...
[Else
[istruzionielse]]
End If
La sintassi dell’istruzione If...Then...Else è composta dalle seguenti parti
Parte
condizione
Descrizione
Obbligatoria. Uno o più dei due tipi di espressione indicati di seguito:
Un’espressione numerica o un’espressione stringa che può dare come
risultato True o False. Se condizione è Null, viene considerata come
False.
Un’espressione nella forma TypeOf nomeoggetto Is tipooggetto.
L’argomento nomeoggetto è qualsiasi riferimento di oggetto e
tipooggetto è qualsiasi tipo di oggetto valido. L'espressione dà come
risultato True se nomeoggetto è del tipo di oggetto specificato da
tipooggetto; in caso contrario il risultato è False.
istruzioni
Facoltativa nella sintassi a blocchi; Obbligatoria nella sintassi a riga
singola, che non prevede una proposizione Else. Una o più istruzioni
separate da due punti, eseguite se la valutazione di condizione dà come
risultato True.
condizione-n
Facoltativa. Come condizione.
istruzionielseif
Facoltativa. Una o più istruzioni eseguite se la valutazione della
condizione-n associata dà come risultato True.
istruzionielse
Facoltativa. Una o più istruzioni eseguite se la valutazione di nessuna
espressione condizione o condizione-n precedente dà come risultato
True.
Osservazioni
La forma su una sola riga (prima sintassi) è utile per eseguire brevi e semplici test. La forma a
blocco (seconda sintassi) consente una maggiore strutturazione e flessibilità rispetto alla forma su
31 di 81
una sola riga e in genere facilita la lettura, il controllo e il debug.
Nota La sintassi su una sola riga consente di eseguire istruzioni multiple come risultato di una
decisione If...Then. Le istruzioni devono comunque essere incluse nella stessa riga e separate da
due punti come nell'istruzione di seguito riportata:
If A > 10 Then A = A + 1 : B = B + A : C = C + B
Un'istruzione If in forma di blocco deve essere la prima istruzione di una riga. Le parti Else, ElseIf
e End If dell’istruzione possono essere precedute soltanto da un numero di riga o da un’etichetta di
riga. Il blocco If deve terminare con un’istruzione End If.
Per determinare se un'istruzione è un blocco If, esaminare gli elementi successivi alla parola chiave
Then. Se dopo tale parola chiave e sulla stessa riga non vi sono altri elementi a eccezione di un
commento, l'istruzione viene considerata un'istruzione If su una sola riga.
Le proposizioni Else e ElseIf sono entrambe facoltative. Un blocco If può contenere un numero
qualsiasi di proposizioni ElseIf, nessuna delle quali deve tuttavia apparire dopo una proposizione
Else. Le istruzioni If a blocchi possono essere nidificate, ovvero inserite una all’interno dell’altra.
Nell'esecuzione di un blocco If (seconda sintassi) viene analizzata condizione. Se condizione è
True, verranno eseguite le istruzioni successive a Then. Se condizione è False, verranno valutate
singolarmente le condizioni ElseIf eventualmente presenti. Quando viene individuata una
condizione True, vengono eseguite le istruzioni immediatamente successive all'istruzione Then
associata. Se nessuna delle condizioni ElseIf risulta True (o in assenza di proposizioni ElseIf),
verranno eseguite le istruzioni che seguono l'istruzione Else. Dopo l'esecuzione delle istruzioni che
seguono Then o Else, verrà eseguita l'istruzione che segue EndIf.
Suggerimento L’istruzione Select Case può risultare più utile per la valutazione di un'espressione
singola che include diverse azioni possibili. La proposizione TypeOf nomeoggetto Is tipooggetto
non può essere tuttavia utilizzata con l'istruzione Select Case.
Nota La proposizione TypeOf non può essere utilizzata con tipi di dati diversi da Object, quali
Long, Integer e così via.
Utilizzo di istruzioni If...Then...Else
Le istruzioni If...Then...Else consentono l'esecuzione di un'istruzione specifica o di un blocco di
istruzioni, in base al valore di una condizione. Le istruzioni If...Then...Else possono essere
nidificate fino al livello desiderato. Tuttavia, per motivi di leggibilità, è consigliabile utilizzare
un'istruzione Select Case anziché più livelli di istruzioni If...Then...Else nidificate.
Esecuzione di istruzioni quando una condizione è True
Per eseguire una singola istruzione quando una condizione è True, è possibile utilizzare la sintassi a
riga singola dell'istruzione If...Then...Else, illustrata nell'esempio seguente. In questo caso la parola
chiave Else viene omessa.
Sub FixDate()
myDate = #2/13/95#
If myDate < Now Then myDate = Now
End Sub
Per eseguire più righe di codice, è necessario utilizzare la sintassi a blocco, che include l'istruzione
End If, come illustrato nel seguente esempio:
Sub AlertUser(value as Long)
If value = 0 Then
AlertLabel.ForeColor = "Rosso"
AlertLabel.Font.Bold = True
AlertLabel.Font.Italic = True
End If
End Sub
Esecuzione di determinate istruzioni se una condizione è True e di altre istruzioni se è False
Le istruzioni If...Then...Else consentono di definire due blocchi di istruzioni eseguibili. Un blocco
32 di 81
viene eseguito se la condizione è True e l'altro blocco viene eseguito se la condizione è False.
Sub AlertUser(value as Long)
If value = 0 Then
AlertLabel.ForeColor =
AlertLabel.Font.Bold =
AlertLabel.Font.Italic
Else
AlertLabel.Forecolor =
AlertLabel.Font.Bold =
AlertLabel.Font.Italic
End If
End Sub
vbRed
True
= True
vbBlack
False
= False
Verifica di una seconda condizione se la prima condizione è False
È possibile aggiungere a un'istruzione If...Then...Else istruzioni ElseIf che consentono di verificare
una seconda condizione se la prima condizione risulta False. La seguente routine di funzioni
calcola, ad esempio, un premio da assegnare in base alla classifica dei rendimenti. L'istruzione
successiva all'istruzione Else viene eseguita se le condizioni di tutte le istruzioni If e ElseIf
risultano False.
Function Bonus(performance, salary)
If performance = 1 Then
Bonus = salary * 0.1
ElseIf performance = 2 Then
Bonus = salary * 0.09
ElseIf performance = 3 Then
Bonus = salary * 0.07
Else
Bonus = 0
End If
End Function
Esempio di istruzione If...Then...Else
In questo esempio vengono illustrati alcuni utilizzi della sintassi a blocco e della sintassi a riga
singola dell'istruzione If...Then...Else. Viene inoltre illustrato l'utilizzo dell'istruzione If
TypeOf...Then...Else.
Dim Number, Digits, MyString
Number = 53
' Inizializza la variabile.
If Number < 10 Then
Digits = 1
ElseIf Number < 100 Then
' Se la valutazione della condizione dà come risultato
' True, viene eseguita l'istruzione successiva.
Digits = 2
Else
Digits = 3
End If
' Assegna un valore utilizzando la sintassi a
' riga singola.
If Digits = 1 Then MyString = "Uno" Else MyString = "Maggiore di uno"
In questo esempio la struttura If TypeOf viene utilizzata per determinare se il controllo passato in
una routine è una casella di testo.
Sub ControlProcessor(MyControl As Control)
If TypeOf MyControl Is CommandButton Then
Debug.Print "È stato passato un controllo " & TypeName(MyControl)
ElseIf TypeOf MyControl Is CheckBox Then
Debug.Print "È stato passato un controllo " & TypeName(MyControl)
ElseIf TypeOf MyControl Is TextBox Then
Debug.Print "È stato passato un controllo " & TypeName(MyControl)
End If
33 di 81
End Sub
Istruzione Select Case
Esegue uno dei vari blocchi di istruzioni sulla base del valore di un’espressione.
Sintassi
Select Case espressioneprova
[Case elencoespressioni-n
[istruzioni-n]] ...
[Case Else
[istruzionielse]]
End Select
La sintassi dell'istruzione Select Case è composta dalle seguenti parti:
Parte
Descrizione
espressioneprova
Obbligatoria. Qualsiasi espressione numerica o espressione stringa.
elencoespressioni-n
Obbligatoria in presenza di Case. Elenco delimitato in una delle
seguenti forme: espressione, espressione To espressione, oppure Is
operatoreconfronto espressione. La parola chiave To specifica un
intervallo di valori. Se si utilizza la parola chiave To il valore minore
deve apparire prima di To. Utilizzare la parola chiave Is con gli
operatori di confronto (a esclusione di Is e Like) per specificare un
intervallo di valori. Se non viene indicata, la parola chiave Is verrà
inserita automaticamente.
istruzioni-n
Facoltativa. Una o più istruzioni eseguite se espressioneprova
corrisponde a una qualsiasi parte di elencoespressioni-n.
istruzionielse
Facoltativa. Una o più istruzioni eseguite se espressioneprova non
corrisponde a nessun elemento della proposizione Case.
Osservazioni
Se espressioneprova corrisponde all'espressione elencoespressioni, associata a una proposizione
Case, le istruzioni che seguono tale proposizione Case verranno eseguite fino alla proposizione
Case successiva. L'ultimo blocco di istruzioni verrà eseguito fino a End Select. Il controllo passerà
quindi all'istruzione successiva a End Select. Se espressioneprova corrisponde a un'espressione
elencoespressioni in più di una proposizione Case, verranno eseguite solo le istruzioni che seguono
la prima corrispondenza.
La proposizione Case Else viene utilizzata per indicare le istruzionielse da eseguire se non viene
trovata corrispondenza tra espressioneprova e elencoespressioni in una delle altre selezioni Case.
Sebbene non sia obbligatorio, è consigliabile includere un'istruzione Case Else in un blocco Select
Case per gestire valori di espressioneprova non previsti. Se nessuna elencoespressioni Case
corrisponde a espressioneprova e non è stata specificata un'istruzione Case Else, verrà eseguita
l'istruzione successiva a End Select.
In ciascuna proposizione Case, è possibile utilizzare più espressioni o intervalli. La riga di seguito
riportata è, ad esempio, valida:
Case 1 To 4, 7 To 9, 11, 13, Is > MaxNumber
34 di 81
Nota Si noti che l'operatore di confronto Is e la parola chiave Is utilizzata nell'istruzione Select
Case sono elementi diversi.
È inoltre possibile specificare intervalli e più di un'espressione per le stringhe di caratteri. In questo
esempio, Case consente di confrontare le stringhe che corrispondono esattamente a everything, le
stringhe comprese tra nuts e soup in ordine alfabetico e il valore corrente di TestItem:
Case "everything", "nuts" To "soup", TestItem
Le istruzioni Select Case possono essere nidificate. A ciascuna istruzione Select Case nidificata
deve corrispondere un'istruzione End Select.
Esempio di istruzione Select Case
In questo esempio l'istruzione Select Case viene utilizzata per valutare il valore di una variabile. La
seconda proposizione Case contiene il valore della variabile in corso di valutazione e quindi viene
eseguita solo l'istruzione associata.
Dim Number
Number = 8
' Inizializza la variabile.
Select Case Number
' Valuta Number.
Case 1 To 5
' Number tra 1 e 5, compresi.
Debug.Print "Tra 1 e 5"
' Questa è l'unica proposizione Case la cui valutazione
' dà come risultato True.
Case 6, 7, 8
' Number tra 6 e 8.
Debug.Print "Tra 6 e 8"
Case 9 To 10
' Number è 9 o 10.
Debug.Print "Maggiore di 8"
Case Else
' Altri valori.
Debug.Print "Non compreso tra 1 e 10"
End Select
Ripetizione ciclica del codice
L'utilizzo di istruzioni condizionali e di ripetizione ciclica (denominate anche strutture di controllo)
consente di scrivere codice che è in grado di eseguire scelte e ripetere azioni. Un'altra struttura di
controllo che può risultare utile è l'istruzione With, che consente di eseguire una serie di istruzioni
senza dover riqualificare un oggetto.
Utilizzo di istruzioni condizionali per l'esecuzione di scelte
Le istruzioni condizionali valutano se una condizione è True o False e quindi specificano una o più
istruzioni per l'esecuzione, in base al risultato ottenuto. Una condizione è in genere un'espressione
che utilizza un operatore di confronto per confrontare un valore o una variabile con un altro valore o
un'altra variabile.
Scelta di un'istruzione condizionale
• If...Then...Else: Esecuzione di un passaggio quando una condizione risulta vera o falsa
• Select Case: Selezione di un passaggio da un gruppo di condizioni
Utilizzo di cicli per la ripetizione del codice
La ripetizione ciclica consente di eseguire più volte un gruppo di istruzioni. Alcuni cicli ripetono le
istruzioni fino a quando una condizione non risulta falsa. Altri ripetono le istruzioni fino a quando
una condizione non risulta vera. Esistono inoltre cicli che ripetono le istruzioni per un determinato
numero di volte o per ciascun oggetto di un insieme.
Scelta di un ciclo
• Do...Loop: Esecuzione del ciclo mentre o fino a quando una condizione è True.
• For...Next: Utilizzo di un contatore per l'esecuzione di istruzioni per un determinato numero
di volte.
• For Each...Next: Ripetizione di un gruppo di istruzioni per ciascun oggetto di un insieme.
Esecuzione di numerose istruzioni per lo stesso oggetto
35 di 81
In Visual Basic, è in genere necessario specificare un oggetto prima di poterne eseguire uno dei
relativi metodi oppure modificarne le proprietà. Per specificare una sola volta un oggetto per
un'intera serie di istruzioni, è possibile utilizzare l'istruzione With.
• With: Esecuzione di una serie di istruzioni per lo stesso oggetto.
Istruzione Do...Loop
Ripete un blocco di istruzioni finché la valutazione di una condizione dà come risultato True o fino
a quando non dà come risultato True.
Sintassi
Do [{While | Until} condizione]
[istruzioni]
[Exit Do]
[istruzioni]
Loop
In alternativa, è possibile utilizzare la seguente sintassi equivalente:
Do
[istruzioni]
[Exit Do]
[istruzioni]
Loop [{While | Until} condizione]
La sintassi dell’istruzione Do... Loop è composta dalle seguenti parti:
Parte
Descrizione
condizione
Facoltativa. Espressione numerica o espressione stringa che può dare come
risultato True o False. Se condizione è Null, viene considerata come False.
istruzioni
Una o più istruzioni ripetute finché la valutazione di condizione è True.
Osservazioni
È possibile inserire un qualsiasi numero di istruzioni Exit Do in qualsiasi punto dell'istruzione
Do...Loop come metodo alternativo per uscire dall'istruzione Do...Loop. Exit Do viene spesso
utilizzata dopo la valutazione di una condizione, ad esempio If...Then, per trasferire il controllo
all'istruzione immediatamente successiva all'istruzione Loop.
Quando le istruzioni Do...Loop sono nidificate, il controllo viene trasferito al ciclo che si trova al
livello di nidificazione immediatamente superiore al ciclo in cui ha luogo Exit Do.
Esempio di istruzione Do...Loop
In questo esempio vengono illustrati alcuni utilizzi dell'istruzione Do...Loop. L'istruzione
Do...Loop interna si ripete 10 volte, imposta il valore del flag su False ed esce grazie all'istruzione
Exit Do. Il ciclo esterno si conclude immediatamente dopo aver eseguito il controllo del valore del
flag.
Dim Check, Counter
Check = True: Counter = 0
Do
' Ciclo esterno.
Do While Counter < 20
Counter = Counter + 1
' Inizializzazione delle variabili.
' Ciclo interno.
' Incrementa il contatore.
36 di 81
If Counter = 10 Then
Check = False
Exit Do
End If
Loop
Loop Until Check = False
' Se la condizione è True.
' Imposta il valore del flag su False.
' Esce dal ciclo interno.
' Esce immediatamente dal ciclo esterno.
Utilizzo di istruzioni Do...Loop
Le istruzioni Do...Loop consentono di eseguire un blocco di istruzioni per un numero indefinito di
volte. Le istruzioni vengono ripetute fino a quando una condizione è True o fino a quando non
diventa True.
Ripetizione delle istruzioni fino a quando una condizione è True
Per verificare una condizione all'interno di un'istruzione Do...Loop, è possibile utilizzare la parola
chiave While in due modi. È possibile verificare la condizione prima di avviare il ciclo oppure dopo
che il ciclo è stato eseguito almeno una volta.
Nella seguente routine ChkFirstWhile la condizione viene verificata prima dell'avvio del ciclo. Se
myNum viene impostata su 9 anziché su 20, le istruzioni nel ciclo non verranno eseguite. Nella
routine ChkLastWhile le istruzioni all'interno del ciclo verranno eseguite solo una volta prima che la
condizione diventi False.
Sub ChkFirstWhile()
counter = 0
myNum = 20
Do While myNum > 10
myNum = myNum - 1
counter = counter + 1
Loop
MsgBox "Il ciclo è stato eseguito " & counter & " volte."
End Sub
Sub ChkLastWhile()
counter = 0
myNum = 9
Do
myNum = myNum - 1
counter = counter + 1
Loop While myNum > 10
MsgBox "Il ciclo è stato eseguito " & counter & " volte."
End Sub
Ripetizione delle istruzioni fino a quando una condizione non diventa True
Per verificare una condizione all'interno di un'istruzione Do...Loop, è possibile utilizzare la parola
chiave Until in due modi. È possibile verificare la condizione prima di avviare il ciclo (come
illustrato nella routine ChkFirstUntil) oppure dopo che il ciclo è stato eseguito almeno una volta
(come illustrato nella routine ChkLastUntil). La ripetizione del ciclo prosegue fino a quando la
condizione rimane False.
Sub ChkFirstUntil()
counter = 0
myNum = 20
Do Until myNum = 10
myNum = myNum - 1
counter = counter + 1
Loop
MsgBox "Il ciclo è stato eseguito " & counter & " volte."
End Sub
37 di 81
Sub ChkLastUntil()
counter = 0
myNum = 1
Do
myNum = myNum + 1
counter = counter + 1
Loop Until myNum = 10
MsgBox "Il ciclo è stato eseguito " & counter & " volte."
End Sub
Uscita da un'istruzione Do...Loop dall'interno del ciclo
Per uscire da un'istruzione Do...Loop, è possibile utilizzare l'istruzione Exit Do. Ad esempio, per
uscire da un ciclo ripetuto all'infinito, è possibile utilizzare l'istruzione Exit Do nel gruppo di
istruzioni True di un'istruzione If...Then...Else oppure Select Case. Se la condizione è False, il
ciclo verrà eseguito come di norma.
Nell'esempio seguente a myNum viene assegnato un valore che crea un ciclo ripetuto all'infinito.
L'istruzione If...Then...Else verifica la condizione e quindi esce, evitando che il ciclo venga
ripetuto all'infinito.
Sub ExitExample()
counter = 0
myNum = 9
Do Until myNum = 10
myNum = myNum - 1
counter = counter + 1
If myNum < 10 Then Exit Do
Loop
MsgBox "Il ciclo è stato eseguito " & counter & " volte."
End Sub
Nota Per interrompere un ciclo infinito, premere ESC o CTRL+INTERR.
Istruzione While...Wend
Esegue una serie di istruzioni finché la valutazione di una determinata condizione dà come risultato
True.
Sintassi
While condizione
[istruzioni]
Wend
La sintassi dell'istruzione While...Wend è composta dalle seguenti parti:
Parte
Descrizione
condizione
Obbligatoria. Espressione numerica o espressione stringa che può dare come
risultato True o False. Se condizione è Null, viene considerata False.
istruzioni
Facoltativa. Una o più istruzioni eseguite finché la condizione è True.
Osservazioni
Se condizione è True, verranno eseguite tutte le istruzioni fino all’istruzione Wend. Il controllo
tornerà quindi all'istruzione While e condizione verrà analizzata nuovamente. Se condizione è
ancora True, il processo verrà ripetuto. Se non è True, l'esecuzione riprenderà con l'istruzione
successiva all'istruzione Wend.
I cicli While...Wend possono essere nidificati a qualsiasi livello. Ciascuna istruzione Wend
corrisponderà all’istruzione While più recente.
38 di 81
Suggerimento L’istruzione Do...Loop consente un'esecuzione dei cicli più strutturata e flessibile.
Esempio di istruzione While...Wend
In questo esempio l'istruzione While...Wend viene utilizzata per incrementare una variabile
contatore. Le istruzioni nel ciclo vengono eseguite fino a quando la valutazione della condizione dà
come risultato True.
Dim Counter
Counter = 0
' Inizializza la variabile.
While Counter < 20
' Controlla il valore di Counter.
Counter = Counter + 1
' Incrementa Counter.
Wend
' Termina il ciclo While quando Counter > 19.
Debug.Print Counter
' Scrive 20 nella finestra Immediata.
Istruzione For...Next
Ripete un gruppo di istruzioni per il numero di volte specificato.
Sintassi
For contatore = inizio To fine [Step incremento]
[istruzioni]
[Exit For]
[istruzioni]
Next [contatore]
La sintassi dell'istruzione For...Next è composta dalle seguenti parti:
Parte
Descrizione
contatore
Obbligatoria. Variabile numerica utilizzata come contatore di ciclo. La variabile
non può essere Boolean o un elemento di una matrice.
inizio
Obbligatoria. Valore iniziale del contatore.
fine
Obbligatoria. Valore finale del contatore.
incremento
Facoltativa. Quantità di cui viene incrementato il contatore al compimento di
ciascun ciclo. Se non viene specificato, incremento assume per impostazione
predefinita il valore 1.
istruzioni
Facoltativa. Una o più istruzioni comprese tra For e Next da eseguire per il
numero di volte specificato
Osservazioni
L’argomento incremento può essere sia positivo che negativo. Il valore dell'argomento incremento
determina l'esecuzione del ciclo come di seguito indicato:
Valore
Il ciclo viene eseguito se
Positivo o 0 contatore <= fine
Negativo
contatore >= fine
Dopo che si è entrati nel ciclo e che tutte le istruzioni del ciclo sono state eseguite, incremento viene
sommato a contatore. A questo punto verranno eseguite di nuovo le istruzioni del ciclo, in base allo
stesso test che ha causato la prima esecuzione del ciclo, oppure il ciclo terminerà e l'esecuzione
continuerà con l'istruzione successiva a Next.
39 di 81
Suggerimento La modifica del valore di un contatore dall’interno di un ciclo può complicare la
lettura e il debug del codice.
È possibile inserire un qualsiasi numero di istruzioni Exit For nel ciclo, come metodo d’uscita
alternativo. Exit For viene spesso utilizzata dopo la valutazione di una condizione, ad esempio
If...Then, per trasferire il controllo all'istruzione immediatamente successiva all'istruzione Next.
È possibile nidificare cicli For...Next inserendo un ciclo For...Next all’interno di un altro.
Assegnare come contatore a ciascun ciclo un nome di variabile univoco. La seguente costruzione è
corretta:
For I = 1 To 10
For J = 1 To 10
For K = 1 To 10
...
Next K
Next J
Next I
Nota Se si omette contatore in un'istruzione Next, l'istruzione verrà eseguita come se contatore
fosse incluso. Se l'istruzione Next viene incontrata prima dell'istruzione For corrispondente, verrà
generato un errore.
Esempio di istruzione For...Next
In questo esempio l'istruzione For...Next viene utilizzata per creare una stringa che contiene 10
istanze dei numeri da 0 a 9. Le stringhe verranno separate da uno spazio. Il ciclo esterno utilizza una
variabile di contatore di ciclo che viene ridotta ad ogni ciclo.
Dim Words, Chars, MyString
For Words = 10 To 1 Step -1
' Imposta 10 ripetizioni.
For Chars = 0 To 9
' Imposta 10 ripetizioni.
MyString = MyString & Chars
' Aggiunge il numero alla stringa.
Next Chars
' Incrementa contatore
MyString = MyString & " "
' Aggiunge uno spazio.
Next Words
Utilizzo di istruzioni For...Next
Le istruzioni For...Next consentono di ripetere un blocco di istruzioni per il numero di volte
specificato. Nei cicli For viene utilizzata una variabile contatore il cui valore viene incrementato o
diminuito ogni volta che il ciclo si ripete.
La seguente routine fa sì che nel computer venga emesso un segnale acustico 50 volte. L'istruzione
For specifica la variabile contatore x e i relativi valori di inizio e di fine. L'istruzione Next
incrementa la variabile contatore di 1.
Sub Beeps()
For x = 1 To 50
Beep
Next x
End Sub
La parola chiave Step consente di incrementare o diminuire la variabile contatore in base al valore
specificato. Nell'esempio seguente, la variabile contatore j viene incrementata di 2 ad ogni
ripetizione del ciclo. Al termine del ciclo, total rappresenta la somma di 2, 4, 6, 8 e 10.
Sub TwosTotal()
For j = 2 To 10 Step 2
total = total + j
Next j
MsgBox "Il totale è " & total
End Sub
Per diminuire la variabile contatore, è possibile utilizzare un valore Step negativo ed è necessario
specificare un valore finale inferiore a quello iniziale. Nell'esempio seguente, la variabile contatore
40 di 81
myNum viene diminuita di 2 ad ogni ripetizione del ciclo. Al termine del ciclo, total rappresenta la
somma di 16, 14, 12, 10, 8, 6, 4 e 2.
Sub NewTotal()
For myNum = 16 To 2 Step -2
total = total + myNum
Next myNum
MsgBox "Il totale è " & total
End Sub
Nota Non è necessario includere il nome della variabile contatore dopo l'istruzione Next. Negli
esempi precedenti esso è stato incluso per semplificare la leggibilità.
Per uscire da istruzioni For...Next prima che il contatore raggiunga il valore finale, è possibile
utilizzare l'istruzione Exit For. Ad esempio, quando viene generato un errore, utilizzare l'istruzione
Exit For nel gruppo di istruzioni che danno come risultato True di un'istruzione If...Then...Else o
Select Case che controlla in modo specifico l'errore. Se l'errore non viene generato, l'istruzione
If…Then…Else dà come risultato False e il ciclo continuerà a essere eseguito come previsto.
Velocizzazione di cicli For...Next
I valori Integer non solo utilizzano una quantità di memoria minore rispetto al tipo di dati Variant,
ma consentono anche un aggiornamento più rapido. La differenza è tuttavia rilevabile solo se si
eseguono migliaia di operazioni. Ad esempio:
Dim CountFaster As Integer
For CountFaster = 0 to 32766
Next CountFaster
' Nel primo caso, utilizza Integer.
Dim CountSlower As Variant
For CountSlower = 0 to 32766
Next CountSlower
' Nel secondo caso, utilizza Variant.
Nel primo caso la velocità di esecuzione è leggermente inferiore rispetto al secondo caso. Se
tuttavia CountFaster supera il valore 32.767, verrà generato un errore. Per risolvere il problema, è
possibile cambiare CountFaster utilizzando il tipo di dati Long, per il quale è ammessa una gamma
di interi più ampia. In generale, più le dimensioni del tipo di dati sono ridotte, minore sarà il tempo
richiesto per l'aggiornamento. Le espressioni Variant sono leggermente più lente rispetto al tipo di
dati equivalente.
Scrittura di istruzioni di Visual Basic
Un' istruzione di Visual Basic è un'istruzione completa, che può includere parole chiave, operatori,
variabili, costanti e espressioni. Ogni istruzione appartiene a una delle tre categorie illustrate di
seguito:
• Istruzioni di dichiarazione, che assegnano un nome a una variabile, a una costante o a una
routine e che possono inoltre specificare un tipo di dati.
Scrittura di istruzioni di dichiarazione
• Istruzioni di assegnazione, che assegnano un valore o un'espressione a una variabile o a una
costante.
Scrittura di istruzioni di assegnazione
• Istruzioni eseguibili, che inizializzano operazioni. Queste istruzioni possono eseguire un
metodo o una funzione e possono inoltre eseguire spostamenti ciclici o passaggi tra blocchi
del codice. Le istruzioni eseguibili spesso includono operatori matematici o condizionali.
Scrittura di istruzioni eseguibili
Continuazione di un'istruzione su più righe
41 di 81
Per la scrittura di un'istruzione è in genere sufficiente una riga, ma è comunque possibile proseguire
l'istruzione nella riga successiva mediante l'utilizzo di un carattere di continuazione riga.
Nell'esempio seguente l'istruzione eseguibile MsgBox viene continuata su tre righe:
Sub DemoBox() 'Questa routine dichiara una variabile stringa,
' le assegna il valore Claudia e quindi
' visualizza un messaggio concatenato.
Dim myVar As String
myVar = "Claudia"
MsgBox Prompt:="Salve " & myVar, _
Title:="Finestra dei saluti", _
Buttons:=vbExclamation
End Sub
Aggiunta di commenti
L'inserimento di commenti consente di fornire spiegazioni relative a una routine o un'istruzione
specifica a chiunque legga il codice. I commenti verranno ignorati dal programma durante
l'esecuzione delle routine. Le righe di commento iniziano con un apostrofo (') o con Rem seguito da
uno spazio e possono essere aggiunti in qualsiasi punto di una routine. Per aggiungere un commento
nella stessa riga di un'istruzione, è possibile inserire un apostrofo dopo l'istruzione, seguito dal
commento. Per impostazione predefinita, i commenti vengono visualizzati come testo di colore
verde.
Controllo degli errori di sintassi
Se, dopo aver digitato una riga di codice, si preme INVIO e la riga viene visualizzata in colore rosso
(a volte può anche comparire un messaggio di errore), è necessario verificare quale errore è stato
commesso nella scrittura del codice e quindi correggerlo.
42 di 81
Definizioni
Modulo
Insieme di dichiarazioni e routine.
Controllo
Oggetto che è possibile inserire in un form e che prevede proprietà, metodi ed eventi specifici. I
controlli consentono di ricevere l'input dell'utente, visualizzare l'output e generare routine di eventi.
È possibile gestire la maggior parte dei controlli utilizzando i metodi. Alcuni controlli sono
interattivi, ovvero rispondono alle azioni eseguite dall'utente, mentre altri sono statici, ovvero
accessibili solo attraverso il codice.
Proprietà
Attributo predefinito di un oggetto. Le proprietà definiscono le caratteristiche degli oggetti (quali le
dimensioni, il colore, la posizione sullo schermo) o lo stato degli oggetti (attivati o meno e così via).
Metodo
Azione applicata a un oggetto.
Stato attivo
L'oggetto in cui si trova lo stato attivo è in genere contraddistinto da una didascalia o da una barra
del titolo evidenziata e solo in questo stato può ricevere i clic del mouse e l'input dalla tastiera. In
Microsoft Windows lo stato attivo si può trovare su una sola finestra, un solo form o un solo
controllo alla volta. Lo stato attivo può essere impostato dall'applicazione o dall'utente.
Indicatore a margine
Icona visualizzata nella Barra indicatori nella finestra del codice. Gli indicatori a margine
costituiscono delle indicazioni visive per agevolare la scrittura del codice.
Modalità interruzione
Sospensione temporanea dell'esecuzione del programma nell'ambiente di sviluppo. In modalità
interruzione è possibile esaminare, eseguire il debug, reimpostare, passare a punti diversi o
proseguire l'esecuzione del programma. La modalità interruzione può essere attivata nei seguenti
modi:
• In presenza di un punto di interruzione durante l'esecuzione del programma.
• Premendo CTRL+INTERR durante l'esecuzione del programma.
• In presenza di un'istruzione Stop o di un errore di run-time non intercettato durante
l'esecuzione del programma.
• Aggiungendo un'espressione di controllo Interrompi se il valore è vero. L'esecuzione si
interrompe quando il valore dell'espressione di controllo cambia e assume il valore True.
• Aggiungendo un'espressione di controllo Interrompi se il valore cambia. L'esecuzione si
interrompe quando il valore dell'espressione di controllo cambia.
Punto di interruzione
Una riga di programma selezionata, in corrispondenza della quale l'esecuzione si interrompe
automaticamente. I punti di interruzione non vengono salvati nel codice.
43 di 81
Gestione progetti
Visualizza una struttura gerarchica dei progetti e di tutti gli elementi contenuti a cui si fa riferimento
in ciascun progetto.
Elementi della finestra
Visualizza codice
Visualizza la finestra del codice in modo che sia possibile scrivere e modificare il codice associato
all'elemento selezionato.
Visualizza oggetto
Visualizza la finestra dell'oggetto relativa all'elemento selezionato, a un Documento o UserForm
esistenti.
Espandi/comprimi cartelle
Visualizza e nasconde le cartelle degli oggetti visualizzando comunque i singoli elementi in esse
contenuti.
Riquadro elenco
Visualizza l'elenco di tutti i progetti caricati e degli elementi inclusi in ogni progetto.
• Progetto
Visualizza il progetto e gli elementi che contiene.
o UserForm
Elenco di tutti i file con estensione frm associati al progetto.
o Documento
Il documento associato al progetto. In Microsoft Word, ad esempio, si tratta del
documento Word.
o Moduli
Elenco di tutti i moduli con estensione bas associati al progetto.
o Moduli di classe
Elenco di tutti i file con estensione cls associati al progetto.
o Finestra di progettazione ActiveX
Elenco di tutte le finestre di progettazione, file con estensione dsr nel progetto.
Riferimenti
o
44 di 81
Elenco dei riferimenti ad altri progetti impostati tramite il comando Riferimenti del
menu Strumenti.
Finestra del codice
La finestra del codice viene utilizzata per scrivere, modificare e visualizzare il codice Visual Basic.
Il numero di finestre del codice che è possibile aprire corrisponde al numero dei moduli disponibili.
In tal modo è possibile visualizzare il codice relativo ai vari form o moduli e copiare e incollare il
codice tra le varie finestre.
Per aprire la finestra del codice:
• Selezionare un form o un modulo nella finestra Progetto e fare clic sul pulsante Visualizza
codice.
• Fare doppio clic su un controllo o sul form nella finestra UserForm, scegliere Codice dal
menu Visualizza oppure premere F7.
È possibile trascinare il testo selezionato in una delle seguenti posizioni:
• Una posizione diversa nella stessa finestra del codice.
• Un'altra finestra del codice.
• Le finestre Immediata e Espressioni di controllo.
• Il Cestino.
Elementi della finestra
Casella Oggetto
Visualizza il nome dell'oggetto selezionato. Fare clic sulla freccia a destra della casella di riepilogo
per visualizzare l'elenco di tutti gli oggetti associati al form.
Casella Routine
Visualizza tutti gli eventi associati al form o al controllo visualizzato nella casella Oggetto. Quando
si seleziona un evento, la routine di eventi associata a tale evento viene visualizzata nella finestra
del codice.
Se nella casella Oggetto viene selezionato (generale), nella casella Routine viene visualizzato un
elenco che comprende la voce (dichiarazioni) e i nomi di tutte le routine generali create per il form.
Nella casella Routine delle finestre del codice dei moduli, vengono elencate tutte le routine generali
del modulo. In entrambi i casi la routine selezionata nella casella Routine viene visualizzata nella
45 di 81
finestra del codice.
I nomi delle routine disponibili in un modulo vengono elencati in ordine alfabetico in una singola
casella di riepilogo. Quando si seleziona una routine nelle caselle di riepilogo a discesa disponibili
nella parte superiore della finestra del codice, il cursore si sposta sulla prima riga di codice della
routine selezionata.
Barra di divisione
Trascinare questa barra verso il basso per dividere la finestra del codice in due riquadri in senso
orizzontale. In tal modo sarà possibile visualizzare contemporaneamente parti diverse del codice. Le
informazioni visualizzate nelle caselle Oggetto e Routine si riferiscono al codice contenuto nel
riquadro su cui si trova lo stato attivo. Per chiudere un riquadro, trascinare la barra sul bordo
inferiore o superiore della finestra oppure fare doppio clic sulla barra.
Barra indicatori
Area di colore grigio in cui vengono visualizzati gli indicatori a margine, situata lungo il margine
sinistro della finestra del codice.
Icona Visualizza routine
Visualizza la routine selezionata. Nella finestra del codice viene visualizzata una sola routine alla
volta.
Icona Visualizza modulo intero
Visualizza tutto il codice contenuto nel modulo.
Indicatori a margine
In Visual Basic sono disponibili gli indicatori a margine che forniscono indicazioni visive su alcune
operazioni relative al codice. Se a una riga corrispondono più operazioni, verranno visualizzati gli
indicatori appropriati.
Gli indicatori a margine vengono visualizzati sulla barra indicatori lungo il margine sinistro della
finestra del codice.
Per attivare o disattivare la barra indicatori, utilizzare la scheda Formato editor della finestra di
dialogo Opzioni.
Indicatore a
margine
Nome dell'indicatore a
margine
Descrizione
Punto di interruzione
Indica che è stato impostato un punto di
interruzione tramite il comando
Imposta/rimuovi punto di interruzione del
menu Debug. Per attivare o disattivare il punto
di interruzione, posizionare il puntatore del
mouse sull'area degli indicatori a margine e fare
clic.
Riga di esecuzione corrente Indica quale riga di codice verrà eseguita
successivamente. È possibile trascinare
l'indicatore a margine in una nuova posizione
all'interno di un modulo di codice in esecuzione.
Se si trascina l'indicatore su un'area o una riga
non valida, non viene eseguita alcuna
operazione e l'indicatore torna nuovamente nella
posizione originale.
46 di 81
Segnalibro
Indica la posizione di un segnalibro impostato
tramite il comando Imposta/rimuovi
segnalibro del menu Modifica.
Indicatore dello stack di
chiamate
Indica le righe che si trovano nello stack di
chiamate. Questo indicatore viene visualizzato
solo in modalità interruzione.
Icone utilizzate nel Visualizzatore oggetti e nella
finestra del codice
Nel Visualizzatore oggetti e nella finestra del codice vengono visualizzate numerose icone che
rappresentano classi e membri. Di seguito vengono elencate le icone e gli elementi che
rappresentano.
Icona
Elemento rappresentato
Utilizzo della finestra Immediata
Nella finestra Immediata vengono visualizzati i risultati delle istruzioni di debug contenute nel
codice oppure derivanti dai comandi digitati direttamente nella finestra.
Per visualizzare la finestra Immediata
• Scegliere Finestra Immediata (CTRL+G)dal menu Visualizza.
Per eseguire codice nella finestra Immediata
1. Digitare una riga di codice nella finestra Immediata.
2. Premere INVIO per eseguire l'istruzione.
Utilizzare la finestra Immediata per:
• Eseguire verifiche funzionali di codice nuovo o problematico.
47 di 81
Eseguire query o modificare il valore di una variabile durante l'esecuzione di
un'applicazione. Mentre l'esecuzione è sospesa, assegnare alla variabile un nuovo valore
mediante la stessa procedura utilizzata nel codice.
• Eseguire query o modificare il valore di una proprietà durante l'esecuzione di
un'applicazione.
• Richiamare routine con la stessa procedura utilizzata nel codice.
• Visualizzare l'output delle operazioni di debug durante l'esecuzione dell'applicazione.
Nota Le istruzioni della finestra Immediata vengono eseguite in un contesto, ovvero come se
fossero incluse in un modulo specifico.
Se mentre si utilizza la finestra Immediata si desiderano informazioni della Guida sulla sintassi di
funzioni, istruzioni, proprietà o metodi, selezionare la parola chiave, oppure il nome della proprietà
o metodo e quindi premere F1.
•
Tasti di scelta rapida per la finestra del codice
Nella finestra del codice è possibile utilizzare i seguenti tasti di scelta rapida:
Per
Tasti di scelta rapida
Aprire la finestra del codice
F7
Aprire il Visualizzatore oggetti
F2
Trovare il testo
CTRL+F
Sostituire il testo
CTRL+H
Trovare il testo di ricerca successivo
F3
Trovare il testo di ricerca precedente
MAIUSC+F3
Passare alla routine successiva
CTRL+FRECCIA GIÙ
Passare alla routine precedente
CTRL+FRECCIA SU
Visualizzare la definizione
MAIUSC+F2
Spostare il cursore di una schermata verso il basso
CTRL+PGGIÙ
Spostare il cursore di una schermata verso l'alto
CTRL+PGSU
Passare all'ultima posizione di modifica
CTRL+MAIUSC+F2
Passare all'inizio del modulo
CTRL+HOME
Passare alla fine del modulo
CTRL+FINE
Spostare il cursore di una parola a destra
CTRL+FRECCIA DESTRA
Spostare il cursore di una parola a sinistra
CTRL+FRECCIA SINISTRA
Spostare il cursore alla fine della riga
FINE
Spostare il cursore all'inizio della riga
HOME
Annullare l'ultima operazione
CTRL+Z
Eliminare la riga corrente
CTRL+Y
Eliminare i caratteri fino alla fine della parola
CTRL+CANC
Aumentare il rientro
TAB
48 di 81
Ridurre il rientro
MAIUSC+TAB
Rimuovere tutti i punti di interruzione
CTRL+MAIUSC+F9
Visualizzare il menu di scelta rapida
MAIUSC+F10
Tasti di scelta rapida dei comandi di menu per la
finestra del codice
Per scegliere alcuni comandi di menu quando è attiva la finestra del codice, è possibile utilizzare le
seguenti combinazioni di tasti:
Premere
Per scegliere il comando
CTRL+P
Stampa
CTRL+Z
Annulla
CTRL+V
Incolla
CANC o CANCELLA
Elimina
CTRL+F
Trova
MAIUSC+F4
Trova successivo
CTRL+H
Sostituisci
TAB
Aumenta rientro
MAIUSC+TAB
Riduci rientro
MAIUSC+F2
Definizione
CTRL+MAIUSC+F2
Ultima posizione
F2
Visualizzatore oggetti
CTRL+G
Finestra Immediata
CTRL+R
Gestione progetti
F4
Finestra Proprietà
F8
Esegui istruzione
MAIUSC+F8
Esegui istruzione/routine
CTRL+F8
Esegui fino al cursore
F9
Imposta/rimuovi punto di interruzione
CTRL+MAIUSC+F9
Rimuovi punti di interruzione
F5
Esegui Sub/Form o Esegui macro
CTRL+INTERR
Interrompi
MAIUSC+F10
Per visualizzare il menu di scelta rapida
CTRL+J
Elenca proprietà/metodi
CTRL+MAIUSC+J
Elenca costanti
49 di 81
MAIUSC+F9
Controllo immediato
CTRL+M
Importa file
CTRL+E
Esporta file
CTRL+I
Informazioni rapide
CTRL+MAIUSC+I
Informazioni parametri
CTRL+BARRA SPAZIATRICE
Completa parola
Tasti di spostamento per la finestra del codice
Per le operazioni di spostamento all'interno della finestra del codice è possibile utilizzare le seguenti
combinazioni di tasti:
Premere
Per
CTRL+F2
Spostare il punto di inserimento nella casella Oggetto.
MAIUSC+F2
Passare alla definizione della routine selezionata.
CTRL+FRECCIA GIÙ
Visualizzare la routine successiva.
CTRL+FRECCIA SU
Visualizzare la routine precedente.
PGGIÙ
Scorrere di una pagina verso il basso nel codice.
PGSU
Scorrere di una pagina verso l'alto nel codice.
CTRL+MAIUSC+F2
Passare all'ultima riga del codice in cui è stata eseguita
un'operazione di modifica.
CTRL+HOME
Passare all'inizio del modulo.
CTRL+FINE
Passare alla fine del modulo.
CTRL+FRECCIA DESTRA
Spostare il cursore di una parola verso destra.
CTRL+FRECCIA SINISTRA
Spostare il cursore di una parola verso sinistra.
FINE
Spostare il cursore alla fine della riga.
HOME
Spostare il cursore all'inizio della riga.
CTRL+PGGIÙ
Spostare il cursore alla fine della routine corrente.
CTRL+PGSU
Spostare il cursore all'inizio della routine corrente.
F6
Spostarsi tra i riquadri della finestra del codice (quando la finestra
è divisa).
Tasti per la modifica del codice
Per eseguire operazioni di modifica nella finestra del codice, è possibile utilizzare le seguenti
combinazioni di tasti:
Premere
Per
CTRL+C
Copiare negli Appunti il testo selezionato.
50 di 81
CTRL+X
Tagliare il testo selezionato e copiarlo negli Appunti.
CANC o CANCELLA
Eliminare il testo selezionato senza copiarlo negli Appunti.
CTRL+V
Incollare il contenuto degli Appunti in corrispondenza del punto di
inserimento.
CTRL+Z
Annullare l'ultima modifica apportata alla riga corrente.
CTRL+Y
Tagliare la riga corrente e copiarla negli Appunti.
CTRL+CANC
Eliminare tutti i caratteri fino alla fine della parola.
CTRL+BACKSPACE
Eliminare tutti i caratteri fino all'inizio della parola.
MAIUSC+F4
Trova successivo: ripetere la ricerca nel testo del codice verso il basso. Se
non è stata eseguita alcuna ricerca, verrà visualizzata la finestra di dialogo
Trova.
MAIUSC+F3
Trova precedente: ripetere la ricerca nel testo del codice verso l'alto. Se
non è stata eseguita alcuna ricerca, verrà visualizzata la finestra di dialogo
Trova.
MAIUSC+TAB
Rimuovere il rientro.
51 di 81
Dichiarazione di variabili
Per dichiarare una variabile viene in genere utilizzata un'istruzione Dim. Un'istruzione di
dichiarazione può essere posizionata all'interno di una routine per creare una variabile a livello di
routine oppure può essere posizionata all'inizio di un modulo, nella sezione Dichiarazioni, per
creare una variabile a livello di modulo.
Nell'esempio seguente viene creata la variabile strName e viene specificato il tipo di dati String.
Dim strName As String
Se questa istruzione compare in una routine, la variabile strName potrà essere utilizzata solo in tale
routine. Se compare nella sezione Dichiarazioni di un modulo, la variabile strName sarà disponibile
per tutte le routine del modulo, ma non per le routine di altri moduli del progetto. Per rendere questa
variabile disponibile per tutte le routine del progetto, è necessario farla precedere dall'istruzione
Public, come illustrato nell'esempio seguente:
Public strName As String
Per informazioni sulla denominazione delle variabili, vedere "Convenzioni di denominazione di
Visual Basic" nella Guida di Visual Basic.
Il tipo di dati delle variabili può essere: Boolean, Byte, Integer, Long, Currency, Single, Double,
Date, String (per stringhe di lunghezza variabile), String * lunghezza (per stringhe di lunghezza
fissa), Object o Variant. Se non viene specificato un tipo di dati, verrà assegnato per impostazione
predefinita il tipo di dati Variant. È inoltre possibile creare un tipo definito dall'utente utilizzando
l'istruzione Type. Per ulteriori informazioni sui tipi di dati, vedere "Riepilogo dei tipi di dati" nella
Guida di Visual Basic.
È possibile dichiarare diverse variabili in una singola istruzione. Per specificare un tipo di dati, è
necessario includere il tipo di dati per ciascuna variabile. Nell'istruzione seguente, le variabili intX,
intY e intZ vengono dichiarate di tipo Integer.
Dim intX As Integer, intY As Integer, intZ As Integer
Nell'istruzione seguente, le variabili intX e intY vengono dichiarate di tipo Variant e solo la variabile
intZ viene dichiarata di tipo Integer.
Dim intX, intY, intZ As Integer
Nell'istruzione di dichiarazione non è necessario specificare il tipo di dati della variabile. Se il tipo
di dati viene omesso, la variabile sarà di tipo Variant.
Istruzione Dim
Dichiara le variabili e assegna lo spazio di archiviazione.
Sintassi
Dim [WithEvents] nomevariabile[([indici])] [As [New] tipo] [, [WithEvents]
nomevariabile[([indici])] [As [New] tipo]] . . .
La sintassi dell'istruzione Dim è composta dalle seguenti parti:
Parte
Descrizione
WithEvents
Facoltativa. Parola chiave che specifica che nomevariabile è una variabile
oggetto utilizzata per rispondere agli eventi generati da un oggetto ActiveX.
Valida solo nei moduli di classe. È possibile dichiarare il numero desiderato
di variabili con WithEvents, ma non è possibile creare matrici con
WithEvents. Non è consentito utilizzare New con WithEvents.
nomevariabile
Obbligatoria. Nome della variabile, espresso in base alle convenzioni di
denominazione standard delle variabili.
52 di 81
indici
Facoltativa. Dimensioni di una variabile matrice. È possibile dichiarare fino a
60 dimensioni multiple. La sintassi dell'argomento indici è descritta di
seguito:
[inferiore To] superiore [, [inferiore To] superiore] . . .
Se non specificato in modo esplicito con inferiore, il limite inferiore di una
matrice viene controllato dall'istruzione Option Base. Se non è presente
un'istruzione Option Base il limite inferiore sarà zero.
New
Facoltativa. Parola chiave che consente di creare un oggetto in modo
implicito. Se si utilizza New per la dichiarazione della variabile oggetto, verrà
creata una nuova istanza dell'oggetto in occasione del primo riferimento a tale
oggetto e pertanto non è necessario utilizzare l'istruzione Set per assegnare il
riferimento all'oggetto. La parola chiave New non può essere utilizzata per
dichiarare variabili di qualsiasi tipo di dati intrinseco, per dichiarare istanze di
oggetti dipendenti e con WithEvents.
tipo
Facoltativa. Tipo di dati della variabile; può essere Byte, Boolean, Integer,
Long, Currency, Single, Double, Decimal (non ancora supportato), Date,
String (per stringhe di lunghezza variabile), String * lunghezza (per stringhe
di lunghezza fissa), Object, Variant, un tipo definito dall'utente oppure un tipo
di oggetto. Utilizzare una proposizione As tipo distinta per ciascuna variabile
da dichiarare.
Osservazioni
Le variabili dichiarate con Dim a livello di modulo sono disponibili per tutte le routine incluse in
tale modulo. A livello di routine, le variabili sono disponibili solo all'interno della routine.
Utilizzare un'istruzione Dim a livello di modulo o di routine per dichiarare il tipo di dati di una
variabile. L'istruzione che segue, ad esempio, dichiara una variabile di tipo Integer.
Dim NumberOfEmployees As Integer
L'istruzione Dim può essere inoltre utilizzata per dichiarare il tipo di oggetto di una variabile.
L'istruzione che segue dichiara una variabile per una nuova istanza di un foglio di lavoro
(Worksheet).
Dim X As New Worksheet
Se la parola chiave New non viene utilizzata nella dichiarazione di una variabile oggetto, alla
variabile che fa riferimento all'oggetto deve essere assegnato un oggetto esistente tramite
l'istruzione Set prima di poter essere utilizzata. Fino a quando non le viene assegnato un oggetto, la
variabile oggetto dichiarata avrà il valore speciale Nothing, che indica che tale variabile non si
riferisce a nessuna istanza particolare di un oggetto.
È inoltre possibile utilizzare l'istruzione Dim con parentesi vuote per dichiarare matrici dinamiche.
Dopo aver dichiarato una matrice dinamica, utilizzare l'istruzione ReDim all'interno di una routine
per definire il numero di dimensioni e di elementi della matrice. Se si prova a ridichiarare una
dimensione di una variabile matrice di cui sono già state dichiarate le dimensioni con un'istruzione
Private, Public o Dim, verrà generato un errore.
Se non si specifica un tipo di dati o un tipo di oggetto e il modulo non include un'istruzione Deftipo,
la variabile sarà di tipo Variant per impostazione predefinita.
Le variabili numeriche vengono inizializzate su 0. Le stringhe di lunghezza variabile vengono
inizializzate come stringhe di lunghezza zero e le stringhe di lunghezza fissa vengono riempite con
zeri. Le variabili Variant vengono inizializzate su Empty. Gli elementi di tipo definito dall'utente
vengono inizializzati come se fossero variabili distinte.
Nota Quando si utilizza l'istruzione Dim in una routine, in genere l'istruzione Dim viene inserita
all'inizio della routine stessa.
53 di 81
Esempio di istruzione Dim
In questo esempio viene illustrata l'istruzione Dim utilizzata per dichiarare le variabili. L'istruzione
Dim viene inoltre utilizzata per dichiarare le matrici. Il limite inferiore predefinito per gli indici di
matrice è 0 e può essere modificato a livello di modulo utilizzando l'istruzione Option Base.
' AnyValue e MyValue vengono dichiarate come
' Variant per impostazione predefinita con valori
' impostati su Empty.
Dim AnyValue, MyValue
' Dichiara in modo esplicito una variabile
' di tipo Integer.
Dim Number As Integer
' Più dichiarazioni sulla stessa riga. AnotherVar è di
' tipo Variant visto che non è indicato il suo tipo.
Dim AnotherVar, Choice As Boolean, BirthDate As Date
' DayArray è una matrice di valori Variant che include
' 51 elementi da 0 a 50. Si presuppone che per il
' modulo corrente Option Base sia impostato su 0
' (valore predefinito).
Dim DayArray(50)
' Matrix è una matrice bidimensionale di interi.
Dim Matrix(3, 4) As Integer
' MyMatrix è una matrice tridimensionale di valori
' Double con limiti espliciti.
Dim MyMatrix(1 To 5, 4 To 9, 3 To 5) As Double
' BirthDay è una matrice di date con indici da 1 a 10.
Dim BirthDay(1 To 10) As Date
' MyArray è una matrice dinamica di valori Variant.
Dim MyArray()
Utilizzo dell'istruzione Public
L'istruzione Public consente di dichiarare variabili pubbliche a livello di modulo.
Public strName As String
Le variabili pubbliche sono disponibili per tutte le routine del progetto. Se una variabile pubblica
viene dichiarata in un modulo standard o in un modulo di classe, è inoltre possibile utilizzarla in
tutti i progetti che fanno riferimento al progetto in cui essa viene dichiarata.
Utilizzo dell'istruzione Private
L'istruzione Private consente di dichiarare variabili private a livello di modulo.
Private MyName As String
Le variabili private sono disponibili solo per le routine del modulo in cui vengono dichiarate.
Nota Se viene utilizzata a livello di modulo, l'istruzione Dim è equivalente all'istruzione Private.
L'istruzione Private consente tuttavia di semplificare la lettura e l'interpretazione del codice.
Utilizzo dell'istruzione Static
Se invece dell'istruzione Dim viene utilizzata l'istruzione Static, il valore della variabile dichiarata
verrà mantenuto tra le chiamate.
54 di 81
Utilizzo dell'istruzione Option Explicit
Per dichiarare una variabile in modo implicito è sufficiente utilizzarla in un'istruzione di
assegnazione. Tutte le variabili dichiarate in modo implicito sono di tipo Variant. Tali variabili
richiedono maggiori risorse di memoria rispetto alla maggior parte delle altre variabili. Per
migliorare le prestazioni dell'applicazione, può quindi risultare utile dichiarare le variabili in modo
esplicito e con un tipo di dati specifico. La dichiarazione esplicita consente infatti di ridurre gli
errori per conflitti di nome e gli errori di ortografia.
Per evitare che le variabili vengano dichiarate in modo implicito, è possibile posizionare l'istruzione
Option Explicit in un modulo prima di qualsiasi altra routine. Questa istruzione forza la
dichiarazione esplicita di tutte le variabili del modulo. Quando in un modulo viene utilizzata
l'istruzione Option Explicit e viene incontrato un nome di variabile non dichiarata o digitato in
modo non corretto, verrà generato un errore in fase di compilazione.
Nell'ambiente di programmazione di Visual Basic è disponibile un'opzione che consente di
includere automaticamente l'istruzione Option Explicit in tutti i nuovi moduli. Per informazioni
sulla modifica delle opzioni di ambiente di Visual Basic, vedere la documentazione
dell'applicazione in uso. Si noti che questa opzione non modifica il codice già scritto.
Nota Le matrici fisse e le matrici dinamiche devono essere dichiarate in modo esplicito.
Dichiarazione di una variabile oggetto per l'automazione
Se un'applicazione viene utilizzata per gestire oggetti di un'altra applicazione, è consigliabile
impostare un riferimento alla libreria dei tipi dell'altra applicazione. Dopo aver impostato un
riferimento, è possibile dichiarare variabili oggetto in base al tipo più specifico. Se, ad esempio, in
Microsoft Word viene impostato un riferimento alla libreria dei tipi di Microsoft Excel, è possibile
dichiarare una variabile di tipo Worksheet da Microsoft Word per rappresentare un oggetto
Worksheet di Microsoft Excel.
Se per gestire oggetti di Microsoft Access viene utilizzata un'altra applicazione, nella maggior parte
dei casi sarà possibile dichiarare variabili oggetto in base al tipo più specifico. È inoltre possibile
utilizzare la parola chiave New per creare in modo automatico una nuova istanza di un oggetto. Può
risultare tuttavia necessario specificare che si tratta di un oggetto di Microsoft Access. Se, ad
esempio, viene dichiarata una variabile oggetto che rappresenta una maschera di Microsoft Access,
è necessario distinguere l'oggetto Form di Microsoft Access dall'oggetto Form di Visual Basic. A
tale scopo, è possibile includere il nome della libreria dei tipi nella dichiarazione della variabile,
come è illustrato nell'esempio seguente:
Dim frmOrders As New Access.Form
Alcune applicazioni non riconoscono i singoli tipi di oggetti di Microsoft Access. Anche se viene
impostato un riferimento alla libreria dei tipi di Microsoft Access, è necessario che tutte le variabili
oggetto di Microsoft Access vengano dichiarate come variabili di tipo Object. Inoltre, non è
possibile utilizzare la parola chiave New per creare una nuova istanza dell'oggetto. Nell'esempio
seguente viene illustrata la dichiarazione di una variabile che rappresenta un'istanza dell'oggetto
Application di Microsoft Access da un'applicazione che non è in grado di riconoscere i tipi di
oggetti di Microsoft Access. L'applicazione crea quindi un'istanza dell'oggetto Application.
Dim appAccess As Object
Set appAccess = CreateObject("Access.Application.7")
Per determinare la sintassi supportata da un'applicazione, vedere la relativa documentazione.
Creazione di una routine
Il codice di un modulo è composto di routine che specificano come eseguire determinate operazioni.
Utilizzare le routine per suddividere il codice complesso in unità più semplici da gestire.
55 di 81
Per creare una routine mediante la scrittura del codice
1. Aprire il modulo per il quale di desidera scrivere la routine.
2. È possibile creare una routine Sub, Function o Property.
3. Digitare Sub, Function o Property.
Per ottenere informazioni della Guida sulla sintassi corretta da utilizzare, premere F1.
4. Digitare il codice per la routine.
La routine verrà conclusa con l'istruzione End Sub, End Function o End Property
appropriata.
Per creare una routine utilizzando la finestra di dialogo
Inserisci routine
1. Aprire il modulo per il quale si desidera scrivere la routine.
2. Scegliere Routine dal menu Inserisci.
3. Digitare un nome per la routine nella casella Nome della finestra di dialogo Inserisci
routine.
4. Selezionare il tipo di routine che si desidera creare: Sub, Function o Property.
5. Impostare l'area di validità della routine su Public o Private.
6. Se si desidera aggiungere la parola chiave Static alla definizione della routine, selezionare la
casella Tutte le variabili locali come Static.
7. Scegliere OK.
Istruzione Function
Dichiara il nome, gli argomenti e il codice che costituiscono il corpo di una routine Function.
Sintassi
[Public | Private | Friend] [Static] Function nome [(elencoargomenti)] [As tipo]
[istruzioni]
[nome = espressione]
[Exit Function]
[istruzioni]
[nome = espressione]
End Function
La sintassi dell'istruzione Function è composta dalle seguenti parti:
Parte
Descrizione
Public
Facoltativa. Indica che la routine Function è accessibile per tutte le altre
routine in tutti i moduli. Se utilizzata in un modulo che include
un'istruzione Option Private, la routine non sarà disponibile
esternamente al progetto.
Private
Facoltativa. Indica che la routine Function è accessibile solo per le altre
routine incluse nel modulo in cui è stata dichiarata.
Friend
Facoltativa. Utilizzata solo nei moduli di classe. Indica che la routine
Function è visibile in tutto il progetto, ma non per il controller di
56 di 81
un'istanza di un oggetto.
Static
Facoltativa. Indica che le variabili locali della routine Function vengono
conservate durante le chiamate. L'attributo Static non influisce sulle
variabili dichiarate al di fuori della routine Function, anche se vengono
utilizzate nella routine stessa.
nome
Obbligatoria. Nome della routine Function, espresso in base alle
convenzioni di denominazione standard delle variabili.
elencoargomenti
Facoltativa. Elenco delle variabili che rappresentano gli argomenti passati
alla routine Function quando questa viene richiamata. Le variabili
multiple sono separate da virgole.
tipo
Facoltativa. Tipo di dati restituito dalla routine Function; può essere
Byte, Boolean, Integer, Long, Currency, Single, Double, Decimal (non
ancora supportato), Date, String (non di lunghezza fissa), Object, Variant
o di tipo definito dall'utente.
istruzioni
Facoltativa. Qualsiasi gruppo di istruzioni da eseguire nel corpo della
routine Function.
espressione
Facoltativa. Valore restituito da Function.
La sintassi dell'argomento elencoargomenti è composta dalle seguenti parti:
[Optional] [ByVal | ByRef] [ParamArray] nomevariabile[( )] [As tipo] [= valorepredefinito]
Parte
Descrizione
Optional
Facoltativa. Indica che un argomento non è obbligatorio. Se viene
utilizzata, anche tutti gli argomenti successivi in elencoargomenti devono
essere facoltativi e dichiarati con la parola chiave Optional. La parola
chiave Optional non può essere utilizzata per nessun argomento se si
utilizza ParamArray.
ByVal
Facoltativa. Indica che l'argomento viene passato per valore.
ByRef
Facoltativa. Indica che l'argomento viene passato per riferimento.
Impostazione predefinita in Visual Basic.
ParamArray
Facoltativa. Utilizzata solo come ultimo argomento di elencoargomenti,
indica che l'ultimo argomento è una matrice Optional di elementi di tipo
Variant. La parola chiave ParamArray consente di indicare un numero
arbitrario di argomenti. Non può essere utilizzata con ByVal, ByRef
oppure Optional.
nomevariabile
Obbligatoria. Nome della variabile che rappresenta l'argomento passato
alla routine, espresso in base alle convenzioni di denominazione standard
delle variabili.
tipo
Facoltativa. Dichiara il tipo di dati dell'argomento passato alla routine:
Byte, Boolean, Integer, Long, Currency, Single, Double, Decimal (non
ancora supportato) Date, String (solo di lunghezza variabile), Object,
Variant o un tipo di oggetto specifico. Se il parametro non è Optional, è
inoltre possibile specificare un tipo definito dall'utente.
57 di 81
valorepredefinito
Facoltativa. Qualsiasi costante o espressione costante. Valida solo per i
parametri Optional. Se il tipo è Object, un valore predefinito esplicito
può essere solo Nothing.
Osservazioni
Le routine Function sono Public per impostazione predefinita, se non diversamente specificato in
modo esplicito con Public, Private o Friend. Se non si utilizza Static, il valore delle variabili
locali non viene conservato tra le chiamate. La parola chiave Friend può essere utilizzata solo nei
moduli di classe. Alle routine Friend, tuttavia, possono accedere le routine di qualsiasi modulo di
un progetto. Una routine Friend non compare nella libreria dei tipi della classe superiore e non
supporta l'associazione tardiva.
Attenzione Le routine Function possono essere ricorsive, ovvero possono richiamare se stesse per
eseguire un'operazione specifica. Si noti che la ricorsione può causare problemi di overflow dello
stack. La parola chiave Static in genere non viene utilizzata con le routine Function ricorsive.
Tutto il codice eseguibile deve essere incluso in routine. Non è possibile definire una routine
Function all'interno di un'altra routine Function, Sub o Property.
L'istruzione Exit Function consente di uscire immediatamente da una routine Function. Il
programma continuerà con l'istruzione successiva all'istruzione che ha richiamato la routine
Function. In una routine Function è possibile inserire un qualsiasi numero di istruzioni Exit
Function in qualsiasi posizione.
Analogamente a una routine Sub, una routine Function è una routine distinta che può includere
argomenti, eseguire una serie di istruzioni e modificare i valori degli argomenti in essa inclusi.
Diversamente dalla routine Sub, una routine Function può essere utilizzata a destra di
un'espressione nello stesso modo in cui si utilizzano le funzioni intrinseche, quali Sqr, Cos o Chr,
quando si desidera utilizzare il valore risultante dalla funzione.
È possibile richiamare una routine Function utilizzandone il nome in un'espressione, seguito
dall'elenco degli argomenti tra parentesi. Per informazioni dettagliate su come richiamare le routine
Function, vedere l'istruzione Call.
Per ottenere un valore come risultato di una funzione, è necessario assegnare il valore al nome della
funzione. È possibile inserire un qualsiasi numero di assegnazioni di questo tipo in qualsiasi
posizione all'interno della routine. Se a nome non viene assegnato alcun valore, la routine restituirà
un valore predefinito. Una funzione numerica restituirà 0 (zero), una funzione stringa restituirà una
stringa di lunghezza zero ("") e una funzione Variant restituirà Empty. Una funzione che restituisce
un riferimento a un oggetto restituirà Nothing, se non si è assegnato alcun riferimento a un oggetto
a nome all'interno di Function utilizzando Set.
Nell'esempio che segue vengono descritte le modalità di assegnazione di un valore restituito a una
funzione denominata BinarySearch. In questo caso al nome viene assegnato False per indicare che
alcuni valori non sono stati trovati.
Function BinarySearch(. . .) As Boolean
. . .
' Valore non trovato. Restituisce il valore False.
If lower > upper Then
BinarySearch = False
Exit Function
End If
. . .
End Function
Le variabili utilizzate nelle routine Function rientrano in due categorie, ovvero le variabili
dichiarate in modo esplicito all'interno della routine o le variabili non dichiarate in modo esplicito.
Le variabili dichiarate utilizzando l'istruzione Dim o istruzioni equivalenti sono sempre locali
rispetto alla routine. Le altre variabili utilizzate ma non dichiarate in una routine sono locali se non
dichiarate in modo esplicito a un livello superiore esternamente alla routine.
58 di 81
Attenzione In una routine è possibile utilizzare una variabile non dichiarata in modo esplicito nella
routine, ma è possibile che si verifichi un conflitto di nome se un qualsiasi altro elemento definito a
livello di modulo ha lo stesso nome. Se la routine si riferisce a una variabile non dichiarata che ha lo
stesso nome di un'altra routine, costante o variabile, si presuppone che la routine faccia riferimento
a tale nome a livello di modulo. È consigliabile dichiarare le variabili in modo esplicito per evitare
conflitti di questo tipo. Per fare in modo che la dichiarazione delle variabili sia sempre esplicita è
possibile utilizzare l'istruzione Option Explicit.
Attenzione Le espressioni aritmetiche possono essere riorganizzate automaticamente allo scopo di
aumentare l'efficienza interna. È opportuno evitare di utilizzare una routine Function in
un'espressione aritmetica, se la funzione modifica il valore delle variabili nella stessa espressione.
Esempio di istruzione Function
In questo esempio l'istruzione Function viene utilizzata per dichiarare il nome, gli argomenti e il
codice che costituiscono il corpo di una routine Function. Nell'ultimo esempio vengono utilizzati
argomenti Optional inizializzati con tipo fisso.
' La seguente funzione definita dall'utente restituisce
' la radice quadrata dell'argomento passato.
Function CalculateSquareRoot(NumberArg As Double) As Double
If NumberArg < 0 Then
' Valuta l'argomento.
Exit Function
' Esce dalla routine e torna alla routine chiamante.
Else
CalculateSquareRoot = Sqr(NumberArg)
' Restituisce la radice
quadrata.
End If
End Function
Utilizzando la parola chiave ParamArray, una funzione accetta un numero variabile di argomenti.
Nella seguente definizione, FirstArg viene passato per valore.
Function CalcSum(ByVal FirstArg As Integer, ParamArray OtherArgs())
Dim ReturnValue
' Se la funzione viene richiamata come:
ReturnValue = CalcSum(4, 3 ,2 ,1)
' Le variabili locali assumono i seguenti valori: FirstArg = 4,
' OtherArgs(1) = 3, OtherArgs(2) = 2, e così via,
' partendo dal presupposto che il limite inferiore
' predefinito delle matrici sia uguale a 1.
Per gli argomenti Optional è possibile impostare valori predefiniti di tipi diversi da Variant.
' Se gli argomenti di una funzione vengono definiti
' come:
Function MyFunc(MyStr As String, Optional MyArg1 As _ Integer = 5, Optional
MyArg2 = "Dolly")
Dim RetVal
' La funzione può essere richiamata in uno
' dei seguenti modi:
RetVal = MyFunc("Salve", 2, "Gente")
' Tutti e tre gli argomenti.
RetVal = MyFunc("Test", , 5)
' Secondo argomento omesso.
' Argomenti uno e tre utilizzando argomenti
' predefiniti.
RetVal = MyFunc(MyStr:="Salve ", MyArg1:=7)
Istruzione Sub
Dichiara il nome, gli argomenti e il codice che costituiscono il corpo di una routine Sub.
Sintassi
59 di 81
[Private | Public | Friend] [Static] Sub nome [(elencoargomenti)]
[istruzioni]
[Exit Sub]
[istruzioni]
End Sub
La sintassi dell'istruzione Sub è composta dalle seguenti parti:
Parte
Descrizione
Public
Facoltativa. Indica che la routine Sub è accessibile per tutte le altre
routine in tutti i moduli. Se utilizzata in un modulo che include
un'istruzione Option Private, la routine non sarà disponibile
esternamente al progetto.
Private
Facoltativa. Indica che la routine Sub è accessibile solo per le altre
routine incluse nel modulo in cui è stata dichiarata.
Friend
Facoltativa. Utilizzata solo nei moduli di classe. Indica che la routine Sub
è visibile in tutto il progetto, ma non per il controller di un'istanza di un
oggetto.
Static
Facoltativa. Indica che le variabili locali della routine Sub vengono
conservate durante le chiamate. L'attributo Static non influisce sulle
variabili dichiarate al di fuori della routine Sub, anche se vengono
utilizzate nella routine stessa.
nome
Obbligatoria. Nome della routine Sub, espresso in base alle convenzioni
di denominazione standard delle variabili.
elencoargomenti
Facoltativa. Elenco delle variabili che rappresentano gli argomenti passati
alla routine Sub , quando questa viene richiamata. Le variabili multiple
sono separate da virgole.
istruzioni
Facoltativa. Qualsiasi gruppo di istruzioni da eseguire nel corpo della
routine Sub.
La sintassi dell'argomento elencoargomenti è composta dalle seguenti parti:
[Optional] [ByVal | ByRef] [ParamArray] nomevariabile[( )] [As tipo] [= valorepredefinito]
Parte
Descrizione
Optional
Facoltativa. Parola chiave che indica che un argomento non è
obbligatorio. Se viene utilizzata, anche tutti gli argomenti successivi in
elencoargomenti devono essere facoltativi e dichiarati con la parola
chiave Optional. La parola chiave Optional non può essere utilizzata per
nessun argomento se si utilizza ParamArray.
ByVal
Facoltativa. Indica che l'argomento viene passato per valore.
ByRef
Facoltativa. Indica che l'argomento viene passato per riferimento.
Impostazione predefinita in Visual Basic.
ParamArray
Facoltativa. Utilizzata solo come ultimo argomento di elencoargomenti,
60 di 81
indica che l'ultimo argomento è una matrice Optional di elementi
Variant. La parola chiave ParamArray consente di indicare un numero
arbitrario di argomenti. Non può essere utilizzata con ByVal, ByRef
oppure Optional.
nomevariabile
Obbligatoria. Nome della variabile che rappresenta l'argomento passato
alla routine, espresso in base alle convenzioni di denominazione standard
delle variabili.
tipo
Facoltativa. Tipo di dati dell'argomento passato alla routine: Byte,
Boolean, Integer, Long, Currency, Single, Double, Decimal (non ancora
supportato), Date, String (solo di lunghezza variabile), Object, Variant o
un tipo di oggetto specifico. Se il parametro non è Optional, è inoltre
possibile specificare un tipo definito dall'utente.
valorepredefinito
Facoltativa. Qualsiasi costante o espressione. Valida solo per i parametri
Optional. Se il tipo è Object, un valore predefinito esplicito può essere
solo Nothing.
Osservazioni
Le routine Sub sono Public per impostazione predefinita, se non diversamente specificato in modo
esplicito con Public, Private o Friend. Se non si utilizza Static, il valore delle variabili locali non
viene conservato tra le chiamate. La parola chiave Friend può essere utilizzata solo nei moduli di
classe. Alle routine Friend, tuttavia, possono accedere le routine di qualsiasi modulo di un progetto.
Una routine Friend non compare nella libreria dei tipi della classe superiore e non supporta
l'associazione tardiva.
Attenzione Le routine Sub possono essere ricorsive, ovvero possono richiamare se stesse per
eseguire un'operazione specifica. Si noti che la ricorsione può causare problemi di overflow dello
stack. La parola chiave Static in genere non viene utilizzata con le routine Sub ricorsive.
Tutto il codice eseguibile deve essere incluso in una routine. Non è possibile definire una routine
Sub all'interno di un'altra routine Function, Sub o Property.
L'istruzione Exit Sub consente di uscire immediatamente da una routine Sub. Il programma
continuerà con l'istruzione successiva all'istruzione che ha richiamato la routine Sub. In una routine
Sub è possibile inserire qualsiasi numero di istruzioni Exit Sub in qualsiasi posizione.
Analogamente a una routine Function, una routine Sub è una routine distinta che può includere
argomenti, eseguire una serie di istruzioni e modificare i valori degli argomenti in essa inclusi.
Diversamente dalla routine Function, che restituisce un valore, una routine Sub non può essere
utilizzata in un'espressione.
È possibile richiamare una routine Sub utilizzandone il nome, seguito dall'elenco degli argomenti.
Per informazioni dettagliate su come richiamare le routine Sub, vedere l'istruzione Call.
Le variabili utilizzate nelle routine Sub rientrano in due categorie, ovvero le variabili dichiarate in
modo esplicito all'interno della routine o le variabili non dichiarate. Le variabili dichiarate
utilizzando l'istruzione Dim o istruzioni equivalenti sono sempre locali rispetto alla routine. Le altre
variabili utilizzate ma non dichiarate in una routine sono locali se non vengono dichiarate in modo
esplicito a un livello superiore esternamente alla routine.
Attenzione In una routine è possibile utilizzare una variabile non dichiarata in modo esplicito nella
routine, ma è possibile che si verifichi un conflitto di nome se un qualsiasi altro elemento definito a
livello di modulo ha lo stesso nome. Se la routine si riferisce a una variabile non dichiarata che la lo
stesso nome di un'altra routine, costante o variabile, si presuppone che la routine faccia riferimento
a tale nome a livello di modulo. È consigliabile dichiarare le variabili in modo esplicito per evitare
conflitti di questo tipo. Per fare in modo che la dichiarazione delle variabili sia sempre esplicita è
possibile utilizzare l'istruzione Option Explicit.
61 di 81
Nota Non è possibile utilizzare GoSub, GoTo o Return per entrare o uscire da una routine Sub.
Esempio di istruzione Sub
In questo esempio l'istruzione Sub viene utilizzata per dichiarare il nome, gli argomenti e il codice
che costituiscono il corpo di una routine Sub.
' Definizione di routine Sub.
' Routine Sub con due argomenti.
Sub SubComputeArea(Length, TheWidth)
Dim Area As Double
' Dichiara una variabile locale.
If Length = 0 Or TheWidth = 0 Then
' Se uno degli argomenti è = 0.
Exit Sub
' Esce subito dalla routine.
End If
Area = Length * TheWidth
' Calcola l'area del rettangolo.
Debug.Print Area
' Scrive l'area nella finestra Debug.
End Sub
Creazione di routine ricorsive
Per le routine è disponibile una quantità limitata si spazio per le variabili. Ogni volta che una
routine richiama se stessa, viene utilizzata una quantità di spazio maggiore rispetto a quello
disponibile. Questo tipo di routine viene definita routine ricorsiva. Una routine ricorsiva che
richiama se stessa all'infinito genererà un errore. Ad esempio:
Function RunOut(Maximum)
RunOut = RunOut(Maximum)
End Function
Questo errore può risultare meno ovvio nel caso in cui due routine si chiamino l'un l'altra all'infinito
oppure nel caso in cui non si incontri mai una condizione che limiti la ricorsione. Il processo di
ricorsione ha comunque varie funzioni. La routine riportata nell'esempio seguente utilizza una
funzione ricorsiva per calcolare valori fattoriali:
Function Factorial (N)
If N <= 1 Then
' Fine delle chiamate ricorsive.
Factorial = 1
' (N = 0) quindi esce dalle chiamate.
Else
' Chiama di nuovo Factorial se N > 0.
Factorial = Factorial(N - 1) * N
End If
End Function
È consigliabile verificare una routine ricorsiva per accertarsi che non richiami se stessa fino a
esaurimento di memoria. Se viene generato un errore, verificare che la ricorsione non sia impostata
all'infinito. Cercare inoltre di risparmiare memoria nei seguenti modi:
• Eliminando le variabili non necessarie.
• Utilizzando tipi di dati diversi da Variant.
• Riesaminando la logica della routine. Una ricorsione può spesso essere sostituita da cicli
nidificati.
Scrittura di una routine Function
Una routine Function è una serie di istruzioni di Visual Basic racchiusa tra l'istruzione Function e
l'istruzione End Function. Una routine Function è simile a una routine Sub, ma a differenza di
quest'ultima può restituire un valore. Può inoltre includere argomenti, quali costanti, variabili o
espressioni, che le vengono passati da una routine di chiamata. Se una routine Function non include
alcun argomento, l'istruzione Function corrispondente deve contenere un gruppo vuoto di parentesi.
Una funzione restituisce un valore se al relativo nome viene assegnato un valore in una o più
istruzioni della routine.
62 di 81
Nell'esempio seguente, la funzione Celsius calcola i gradi Celsius dai gradi Fahrenheit. Quando la
funzione viene richiamata dalla routine Main, alla funzione viene passata una variabile contenente
il valore dell'argomento. Il risultato del calcolo viene restituito alla routine di chiamata e
visualizzato in una finestra di messaggio.
Sub Main()
temp = Application.InputBox(Prompt:= _
"Immettere la temperatura in gradi F.", Type:=1)
MsgBox "La temperatura è " & Celsius(temp) & " gradi C."
End Sub
Function Celsius(fDegrees)
Celsius = (fDegrees - 32) * 5 / 9
End Function
Chiamata di routine Sub e Function
Per eseguire una chiamata a una routine Sub da un'altra routine, digitare il nome della routine
desiderata e includere i valori degli eventuali argomenti richiesti. L'istruzione Call non è
obbligatoria, ma se viene utilizzata, è necessario includere gli argomenti tra parentesi.
È possibile utilizzare una routine Sub per organizzare altre routine in modo da semplificarne la
comprensione e le operazioni di debug. Nell'esempio seguente, la routine Sub Main esegue una
chiamata alla routine Sub MultiBeep e come argomento viene passato il valore 56. Dopo l'esecuzione
di MultiBeep, il controllo viene restituito a Main, che esegue una chiamata alla routine Sub Message.
Message visualizza quindi una finestra di messaggio. Quando l'utente fa clic su OK, il controllo
viene restituito a Main, che viene terminata.
Sub Main()
MultiBeep 56
Message
End Sub
Sub MultiBeep(numbeeps)
For counter = 1 To numbeeps
Beep
Next counter
End Sub
Sub Message()
MsgBox "È ora di fare una pausa"
End Sub
Chiamata di routine Sub con più argomenti
Nell'esempio seguente vengono illustrati due metodi per eseguire una chiamata a una routine Sub
con più argomenti. Per la seconda chiamata a HouseCalc, è necessario racchiudere gli argomenti tra
parentesi poiché viene utilizzata l'istruzione Call.
Sub Main()
HouseCalc 99800, 43100
Call HouseCalc(380950, 49500)
End Sub
Sub HouseCalc(price As Single, wage As Single)
If 2.5 * wage <= 0.8 * price Then
MsgBox "Il prezzo di questa casa è troppo alto"
Else
MsgBox "Il prezzo di questa casa è equo"
End If
End Sub
63 di 81
Utilizzo delle parentesi nelle chiamate alle routine Function
Per utilizzare il valore restituito da una funzione, è possibile assegnare la funzione a una variabile e
inserire gli argomenti tra parentesi, come è illustrato nell'esempio seguente.
Answer3 = MsgBox("Sei soddisfatto del tuo stipendio?", 4, "Domanda 3")
Se non si desidera utilizzare il valore restituito da una funzione, è possibile eseguire una chiamata
alla funzione con lo stesso metodo utilizzato per la chiamata a una routine Sub. Evitare l'utilizzo
delle parentesi, elencare gli argomenti e non assegnare la funzione a una variabile, come è illustrato
nell'esempio seguente.
MsgBox "Attività completata", 0, "Casella delle attività"
Attenzione Se nell'esempio precedente vengono incluse le parentesi, verrà generato un errore di
sintassi.
Passaggio di argomenti predefiniti
In un'istruzione di una routine Sub o Function è possibile passare valori alle routine chiamate
utilizzando argomenti predefiniti. Gli argomenti predefiniti possono comparire nell'elenco in
qualsiasi ordine. Un argomento predefinito è rappresentato dal nome dell'argomento seguito da due
punti e dal segno uguale (:=) e dal valore assegnato all'argomento.
Nell'esempio seguente viene eseguita una chiamata alla funzione MsgBox utilizzando argomenti
predefiniti e senza che venga restituito alcun valore.
MsgBox Title:="Casella attività", Prompt:="Attività completata"
Nell'esempio seguente viene eseguita una chiamata alla funzione MsgBox utilizzando argomenti
predefiniti. Il valore restituito viene assegnato alla variabile answer3.
answer3 = MsgBox(Title:="Domanda 3", _
Prompt:="Sei soddisfatto del tuo stipendio?", Buttons:=4)
Area di validità e visibilità
L'area di validità si riferisce alla disponibilità di utilizzo di una variabile, di una costante o di una
routine da parte di un'altra routine. Esistono tre livelli di validità: a livello di routine, a livello di
modulo privato e a livello di modulo pubblico.
L'area di validità di una variabile viene specificata nella relativa dichiarazione. È consigliabile
dichiarare tutte le variabili in modo esplicito, allo scopo di evitare errori di conflitto di nome tra
variabili con aree di validità diverse.
Definizione dell'area di validità a livello di routine
Una variabile o costante definita all'interno di una routine non è visibile al di fuori di tale routine.
Di conseguenza, una variabile può essere utilizzata solo dalla routine che contiene la relativa
dichiarazione. Nell'esempio seguente, la prima routine visualizza una finestra di messaggio
contenente una stringa. La seconda routine visualizza una finestra di messaggio vuota, poiché la
variabile strMsg è una variabile locale della prima routine.
Sub LocalVariable()
Dim strMsg As String
strMsg = "Questa variabile non può essere utilizzata al di fuori di questa
routine."
MsgBox strMsg
End Sub
Sub OutsideScope()
MsgBox strMsg
End Sub
64 di 81
Definizione dell'area di validità a livello di modulo privato
È possibile specificare variabili e costanti a livello di modulo nella sezione Dichiarazioni di un
modulo. Le variabili a livello di modulo possono essere pubbliche o private. Le variabili pubbliche
sono disponibili per tutte le routine di tutti i moduli di un progetto. Le variabili private sono
disponibili solo per le routine del modulo specificato. Per impostazione predefinita, l'area di validità
delle variabili dichiarate utilizzando l'istruzione Dim nella sezione Dichiarazioni è privata. Se,
tuttavia, alla variabile viene fatta precedere la parola chiave Private, l'area di validità risulterà
chiara nel codice.
Nell'esempio seguente, la variabile stringa strMsg è disponibile per qualsiasi routine definita nel
modulo. Quando viene richiamata la seconda routine, il contenuto della variabile stringa strMsg
verrà visualizzato in una finestra di dialogo.
' Aggiunge il seguente testo nella sezione
' Dichiarazioni del modulo.
Private strMsg sAs String
Sub InitializePrivateVariable()
strMsg = "Questa variabile non può essere utilizzata al di fuori di questo
modulo."
End Sub
Sub UsePrivateVariable()
MsgBox strMsg
End Sub
Nota Le routine pubbliche di un modulo standard o di un modulo di classe sono disponibili per
qualsiasi progetto di riferimento. Per limitare l'area di validità di tutte le routine di un modulo al
progetto corrente, è possibile aggiungere un'istruzione Option Private Module alla sezione
Dichiarazioni del modulo. Le variabili e le procedure pubbliche saranno ancora disponibili per le
altre routine del progetto corrente, ma non per i progetti di riferimento.
Definizione dell'area di validità a livello di modulo pubblico
Se una variabile a livello di modulo viene dichiarata come pubblica, essa sarà disponibile per tutte
le routine del progetto. Nell'esempio seguente, la variabile stringa strMsg può essere utilizzata da
tutte routine di tutti i moduli del progetto.
' Includere nella sezione Dichiarazioni del modulo.
Public strMsg As String
Tutte le routine sono pubbliche per impostazione predefinita, ad eccezione delle routine di eventi.
Quando viene creata una routine di eventi, prima della dichiarazione di routine verrà inserita
automaticamente la parola chiave Private. Per tutte le altre routine, è necessario dichiarare in modo
esplicito la routine con la parola chiave Private, se si desidera che non sia pubblica.
È possibile utilizzare routine, variabili e costanti pubbliche dichiarate o definite in moduli standard
o in moduli di classe da progetti di riferimento. È tuttavia necessario impostare innanzitutto un
riferimento al progetto in cui vengono dichiarate o definite.
Le routine, le variabili e le costanti dichiarate o definite in moduli diversi dai moduli standard o dai
moduli di classe, quali i moduli di form o i moduli di report, non sono disponibili per i progetti di
riferimento, poiché tali moduli sono privati e quindi accessibili solo dal progetto in cui risiedono.
Vita utile delle variabili
La vita utile di una variabile è il periodo di tempo in cui essa conserva il proprio valore. Tale valore
può variare nel corso della vita utile, ma non può tuttavia risultare annullato. Quando una variabile
perde la propria area di validità, essa non avrà più un valore.
Quando inizia l'esecuzione di una routine, vengono inizializzate tutte le variabili. Le variabili
numeriche vengono inizializzate su zero, le stringhe di lunghezza variabile su una stringa di
65 di 81
lunghezza zero ("") e le stringhe di lunghezza fissa vengono riempite con il carattere rappresentato
dal codice di carattere ASCII 0 o Chr(0). Le variabili di tipo Variant vengono inizializzate su
Empty. Ogni elemento di una variabile di tipo definito dall'utente viene inizializzato come se fosse
una variabile distinta.
Quando viene definita una variabile oggetto, viene riservato uno spazio di memoria, ma il relativo
valore sarà impostato su Nothing fino a quando non viene assegnato ad essa un riferimento
all'oggetto mediante l'istruzione Set.
Se il valore di una variabile non viene modificato durante l'esecuzione del codice, esso verrà
conservato fino a quando la variabile non perde la propria area di validità.
Il valore di una variabile a livello di routine dichiarata mediante l'istruzione Dim viene conservato
fino a quando non viene terminata l'esecuzione della routine. Se la routine richiama altre routine, il
valore della variabile verrà conservato anche durante l'esecuzione delle routine.
Se nella dichiarazione di una variabile a livello di routine è inclusa la parola chiave Static, la
variabile conserva il proprio valore fino a quando è in corso l'esecuzione del codice in qualsiasi
modulo. Quando l'esecuzione dell'intero codice è terminata, la variabile perde la propria area di
validità e il proprio valore. La vita utile della variabile è uguale a quella di una variabile a livello di
modulo.
Una variabile a livello di modulo si differenzia da una variabile statica. In un modulo standard o in
un modulo di classe, essa conserva il proprio valore fino a quando non viene interrotta l'esecuzione
del codice. In un modulo di classe, essa conserva il proprio valore fino a quando esiste un'istanza
della classe. Le variabili a livello di modulo utilizzano memoria fino a quando non vengono
reimpostati i relativi valori ed è quindi consigliabile utilizzarle solo se strettamente necessario.
Se prima di un'istruzione Sub o Function viene inclusa la parola chiave Static, i valori delle
variabili a livello di routine all'interno della routine vengono conservati tra le chiamate.
66 di 81
Funzione MsgBox
Visualizza un messaggio in una finestra di dialogo e attende che l'utente scelga un pulsante, quindi
restituisce un valore Integer che indica quale pulsante l'utente ha scelto.
Sintassi
MsgBox(prompt[, buttons] [, title] [, helpfile, context])
La sintassi della funzione MsgBox è composta dai seguenti argomenti predefiniti:
Parte
Descrizione
prompt
Obbligatoria. Espressione stringa che costituisce il messaggio visualizzato nella
finestra di dialogo. La lunghezza massima di prompt è di circa 1024 caratteri e
dipende dalla larghezza dei caratteri utilizzati. Se prompt è suddiviso su più righe, è
possibile includere, tra ciascuna coppia di righe, un ritorno a capo (Chr(13)), un
carattere di avanzamento riga (Chr(10)) o una sequenza ritorno a capoavanzamento riga (Chr(13) & Chr(10)). In alternativa è possibile utilizzare la
costante vbCrLf
buttons
Facoltativa. Espressione numerica che indica la somma dei valori che specificano il
numero e il tipo di pulsante da visualizzare, lo stile di icona da utilizzare, il tipo di
pulsante da utilizzare come impostazione predefinita e la modalità della finestra di
messaggio. Se omesso il valore predefinito di buttons è 0.
title
Facoltativa. Espressione stringa visualizzata nella barra del titolo della finestra di
dialogo. Se l'argomento title viene omesso, nella barra del titolo verrà indicato il
nome dell'applicazione.
helpfile
Facoltativa. Espressione stringa che identifica il file della Guida da utilizzare per
ottenere informazioni di Guida sensibili al contesto relative alla finestra di dialogo.
Se si indica helpfile è necessario indicare anche context.
context
Facoltativa. Espressione numerica che corrisponde al numero del contesto della
Guida assegnato all'argomento corrispondente della Guida. Se si indica context è
necessario indicare anche helpfile.
Impostazioni
Le possibili impostazioni dell'argomento buttons sono:
Costante
Valore
Descrizione
vbOKOnly
0
Visualizza solo il pulsante OK.
vbOKCancel
1
Visualizza i pulsanti OK e Annulla.
vbAbortRetryIgnore
2
Visualizza i pulsanti Termina, Riprova, e Ignora.
vbYesNoCancel
3
Visualizza i pulsanti Sì, No e Annulla.
vbYesNo
4
Visualizza i pulsanti Sì e No.
vbRetryCancel
5
Visualizza i pulsanti Riprova e Annulla.
vbCritical
16
Visualizza l'icona di messaggio critico.
vbQuestion
32
Visualizza l'icona di richiesta di avviso.
67 di 81
vbExclamation
48
Visualizza l'icona di messaggio di avviso.
vInformation
64
Visualizza l'icona di messaggio di informazione.
vbDefaultButton1
0
Il primo pulsante è il predefinito.
vbDefaultButton2
256
Il secondo pulsante è il predefinito.
vbDefaultButton3
512
Il terzo pulsante è il predefinito.
vbDefaultButton4
768
Il quarto pulsante è il predefinito
vbApplicationModal
0
Finestra di messaggio a scelta obbligatoria
nell'applicazione. L'utente deve rispondere alla
finestra di messaggio prima di poter continuare a
lavorare nell'applicazione corrente.
vbSystemModal
4096
Finestra di messaggio a scelta obbligatoria nel
sistema. Tutte le applicazioni vengono sospese fino
a quando l'utente non risponde alla finestra di
messaggio.
vbMsgBoxHelpButton
16384
Aggiunge un pulsante della Guida nella finestra di
messaggio.
vbMsgBoxSetForeground
65536
Specifica che la finestra di messaggio è in primo
piano.
vbMsgBoxRight
524288
Il testo è allineato a destra.
vbMsgBoxRtlReading
1048576
Specifica che il testo viene visualizzato da destra a
sinistra per i sistemi ebraico e arabo.
Il primo gruppo di valori (0-5) descrive il numero e il tipo dei pulsanti visualizzati nella finestra di
messaggio. Il secondo gruppo (16, 32, 48, 64) descrive lo stile dell'icona. Il terzo gruppo (0, 256,
512, 768) determina il pulsante predefinito e il quarto gruppo (0, 4096) determina se la finestra di
messaggio è a scelta obbligatoria nell'applicazione o nel sistema. Quando si sommano dei numeri
per la creazione di un valore finale dell'argomento buttons, utilizzare soltanto un numero per
ciascun gruppo.
Nota Di seguito sono elencate le costanti specificate o riconosciute da Visual Basic, Applications
Edition utilizzabili in qualsiasi punto del codice in sostituzione dei valori effettivi.
Valori restituiti
Costante
Valore
Descrizione
vbOK
1
OK
vbCancel
2
Annulla
vbAbort
3
Termina
vbRetry
4
Riprova
vbIgnore
5
Ignora
vbYes
6
Sì
vbNo
7
No
68 di 81
Osservazioni
Se vengono inclusi sia l'argomento helpfile che l'argomento context gli utenti potranno premere F1
(Windows) oppure AIUTO (Macintosh) per visualizzare l'argomento della Guida corrispondente a
context. In alcune applicazioni host, ad esempio Microsoft Excel, verrà inoltre aggiunto
automaticamente il pulsante della Guida (?) nella finestra di dialogo.
Se nella finestra di dialogo è visualizzato un pulsante Annulla, il tasto ESC avrà la stessa funzione
del pulsante Annulla. Se nella finestra di dialogo è incluso un pulsante della Guida (?), significa
che per la finestra di dialogo è disponibile la Guida sensibile al contesto. Non verrà restituito
comunque nessun valore, se non dopo aver scelto almeno uno degli altri pulsanti.
Nota Se si desidera specificare altri argomenti, oltre al primo predefinito, è necessario utilizzare
MsgBox in un'espressione. Se si desidera omettere alcuni argomenti di posizione, è necessario
aggiungere la virgola di delimitazione corrispondente.
Esempio di funzione MsgBox
In questo esempio la funzione MsgBox viene utilizzata per visualizzare un messaggio di errore
critico in una finestra di dialogo che include i pulsanti Sì e No. Il pulsante No viene indicato come
risposta predefinita. Il valore restituito dalla funzione MsgBox dipende dal pulsante scelto.
Nell'esempio, si presuppone che DEMO.HLP sia un file della Guida che include un argomento con
numero di contesto uguale a 1000.
Dim Msg, Style, Title, Help, Ctxt, Response, MyString
Msg = "Continuare ?"
' Definisce il messaggio.
Style = vbYesNo + vbCritical + vbDefaultButton2
' Definisce i pulsanti.
Title = "Dimostrazione MsgBox"
' Definisce il titolo.
Help = "DEMO.HLP"
' Definisce il file della Guida.
Ctxt = 1000
' Definisce il contesto dell'argomento.
' Visualizza il messaggio.
Response = MsgBox(Msg, Style, Title, Help, Ctxt)
If Response = vbYes Then
' L'utente sceglie il pulsante Sì.
MyString = "Sì"
' Esegue un'azione.
Else
' L'utente sceglie il pulsante No.
MyString = "No"
' Esegue un'azione.
End If
Funzione InputBox
Visualizza un messaggio in una finestra di dialogo, attendendo che l'utente immetta del testo o
scelga un pulsante, quindi restituisce un valore String che include il contenuto della casella di testo.
Sintassi
InputBox(prompt[, title] [, default] [, xpos] [, ypos] [, helpfile, context])
La sintassi della funzione InputBox è composta dai seguenti argomenti predefiniti:
Parte
prompt
Descrizione
Obbligatoria. Espressione stringa che costituisce il messaggio visualizzato nella
finestra di dialogo. La lunghezza massima di prompt è di circa 1024 caratteri e
dipende dalla larghezza dei caratteri utilizzati. Se prompt è suddiviso su più righe, è
possibile includere, tra ciascuna coppia di righe, un ritorno a capo (Chr(13)), un
carattere di avanzamento riga (Chr(10)) o una sequenza ritorno a capo-avanzamento
riga (Chr(13) & Chr(10)).
69 di 81
title
Facoltativa. Espressione stringa visualizzata nella barra del titolo della finestra di
dialogo. Se l'argomento title viene omesso, nella barra del titolo verrà indicato il nome
dell'applicazione.
default
Facoltativa. Espressione stringa visualizzata nella casella di testo come risposta
predefinita quando non sono forniti altri input. Se default è omesso, verrà visualizzata
una casella di testo vuota.
xpos
Facoltativa. Espressione numerica che specifica la distanza orizzontale in twip del
bordo sinistro della finestra di dialogo dal margine sinistro dello schermo. Se xpos è
omesso, la finestra di dialogo apparirà centrata in senso orizzontale.
ypos
Facoltativa. Espressione numerica che specifica la distanza verticale in twip del bordo
superiore della finestra di dialogo dal margine superiore dello schermo. Se ypos è
omesso, la finestra di dialogo verrà posizionata verticalmente a circa un terzo dal
margine superiore dello schermo.
helpfile
Facoltativa. Espressione stringa che identifica il file della Guida da utilizzare per
ottenere informazioni di Guida sensibili al contesto relative alla finestra di dialogo. Se
si indica helpfile è necessario indicare anche context.
context
Facoltativa. Espressione numerica che corrisponde al numero del contesto della Guida
assegnato all'argomento corrispondente della Guida. Se si indica context è necessario
indicare anche helpfile.
Esempio di funzione InputBox
In questo esempio vengono illustrati vari utilizzi della funzione InputBox per richiedere
l'immissione di un valore. Se le posizioni x e y vengono omesse, la finestra di dialogo risulterà
automaticamente centrata in relazione ai rispettivi assi. La variabile MyValue contiene il valore
immesso dall'utente se l'utente fa clic su OK o preme INVIO. Se l'utente fa clic su Annulla, verrà
restituita una stringa di lunghezza zero.
Sub Messaggio()
Dim Message, Title, Default, MyValue
Message = "Immettere un valore da 1 a 3"
' Imposta il messaggio.
Title = "Demo InputBox"
' Imposta il titolo.
Default = "1"
' Imposta il valore predefinito.
' Visualizza il messaggio, il titolo e il valore predefinito.
MyValue = InputBox(Message, Title, Default)
' Utilizza il file della Guida e il contesto.
' Il pulsante di Guida viene aggiunto automaticamente.
MyValue = InputBox(Message, Title, , , , "DEMO.HLP", 10)
' Visualizza la finestra di dialogo nella posizione 100,100
MyValue = InputBox(Message, Title, Default, 100, 100)
End Sub
70 di 81
Uso di database con il codice VBA
Attraverso il codice VBA è possibile accedere alle informazioni contenute nelle tabelle di un
database.
L’operazione consiste nel definire una Connessione per la quale vengono definiti, tra gli altri, i
seguenti parametri:
• Tipo di database al quale si vuole accedere
• Utente
• Nome del database
• Tipo di accesso (esclusivo o meno)
• Motore del database
• …
Tale definizione porterebbe alla scrittura di una stringa del tipo:
Provider=Microsoft.Jet.OLEDB.4.0;User ID=Admin; _
Data Source=C:\Percorso\NomeDatabase.mdb;_
Mode=Share Deny None; Extended Properties=""; _
Jet OLEDB:System database=C:\PROGRA~1\MICROS~1\OFFICE\SYSTEM.MDW; _
Jet OLEDB:Registry Path=""; _
Jet OLEDB:Database Password=""; _
Jet OLEDB:Engine Type=5; _
Jet OLEDB:Database Locking Mode=1; _
Jet OLEDB:Global Partial Bulk Ops=2; _
Jet OLEDB:Global Bulk Transactions=1; _
Jet OLEDB:New Database Password=""; _
Jet OLEDB:Create System Database=False; _
Jet OLEDB:Encrypt Database=False; _
Jet OLEDB:Don't Copy Locale on Compact=False; _
Jet OLEDB:Compact Without Replica Repair=False; _
Jet OLEDB:SFP=False
Una volta definita la connessione si tratta di creare un oggetto Recordset che conterrà l’insieme dei
record richiesti. Il Recordset può riprodurre il contenuto di un’intera tabella, ma può essere anche il
risultato di una query specificata da una stringa SQL.
Operando nell’ambiente VB di Access, la definizione della connessione diventa semplice in quanto
vengono messi a disposizione oggetti che fanno direttamente riferimento al database in uso.
Qui di seguito vengono riportati alcuni esempi di codice per accedere ai record delle tabelle di un
database Access 2000.
Esempio 1: Connessione alla tabella tblDati di un database
Access 2000
Private Sub ConnettiTabella()
Dim con As Object
Dim rs As Object
' Definizione della connessione al database
Set con = Application.CurrentProject.Connection
' Definizione del recordset di tipo ADODB (Access 2000)
Set rs = CreateObject("ADODB.Recordset")
' Apertura del recordset;
' il recordset conterrà tutti i record della tabella tblDati
rs.Open "tblDati", con, 1
' 1 = adOpenKeyset
' Chiusura del recordset
71 di 81
rs.Close
' Cancellazione dell’area di memoria riservata
' per le due variabili oggetto "rs" e "con"
Set rs = Nothing
Set con = Nothing
End Sub
Esempio 2: Connessione un database Access 2000 tramite una
query SQL
Private
Dim
Dim
Dim
Sub ConnettiTabella()
con As Object
rs As Object
strSql As String
' Definizione della connessione al database
Set con = Application.CurrentProject.Connection
' Definizione del recordset di tipo ADODB (Access 2000)
Set rs = CreateObject("ADODB.Recordset")
' Definizione della stringa di interrogazione del database
strSql = " SELECT * " _
& " FROM tblDati " _
& " WHERE fldClasse = 1 "
' Apertura del recordset;
' il recordset conterrà i record della tabella tblDati
' che hanno il valore 1 nel campo fldClasse
rs.Open strSql, con, 1
' 1 = adOpenKeyset
' Chiusura del recordset
rs.Close
' Cancellazione dell’area di memoria riservata
' per le due variabili oggetto "rs" e "con"
Set rs = Nothing
Set con = Nothing
End Sub
Oggetto Recordset
Un oggetto Recordset rappresenta il set di record ottenuto da una tabella di base o dai risultati di un
comando eseguito. L'oggetto Recordset fa riferimento solo a un unico record all'interno del set
come al record corrente.
Osservazioni
Gli oggetti Recordset vengono utilizzati per manipolare i dati forniti da un provider. Quando si
utilizza ADO, i dati vengono manipolati quasi esclusivamente tramite gli oggetti Recordset. Tutti
gli oggetti Recordset vengono creati utilizzando record (righe) e campi (colonne). A seconda della
funzionalità supportata dal provider, è possibile che alcuni metodi o proprietà di un oggetto
Recordset non siano disponibili.
ADOR.Recordset e ADODB.Recordset sono ID programmatici utilizzabili per creare un oggetto
Recordset. Gli oggetti Recordset risultanti si comportano in modo identico indipendentemente
dall'ID programmatico. ADOR.Recordset viene installato con Microsoft® Internet Explorer;
mentre ADODB.Recordset viene installato con ADO. Il comportamento di un oggetto Recordset è
influenzato dall'ambiente, vale a dire dal client, dal server, da Internet Explorer e così via. Le
differenze sono descritte negli argomenti della Guida in linea relativi a proprietà, metodi ed eventi.
72 di 81
In ADO sono disponibili quattro diversi tipi di cursore:
• Cursore dinamico: consente di visualizzare aggiunte, modifiche ed eliminazioni eseguite
da altri utenti e di effettuare tutti i tipi di movimento tramite il Recordset che non si basano
sui segnalibri. Consente inoltre di inserire segnalibri se supportati dal provider.
• Cursore direzionale: si comporta come un cursore dinamico ad eccezione del fatto che non
consente di visualizzare record aggiunti da altri utenti e di accedere a record cancellati da
altri utenti. I dati modificati da altri utenti saranno ancora visibili. Supporta segnalibri e
consente di effettuare tutti i tipi di movimento tramite il Recordset.
• Cursore statico: fornisce una copia statica di un set di record da utilizzare per trovare dati o
generare relazioni; consente di inserire segnalibri e di effettuare tutti i tipi di movimento
tramite il Recordset. Aggiunte, modifiche o eliminazioni eseguite da altri utenti non saranno
visibili. È l'unico tipo di cursore disponibile quando si apre un oggetto Recordset del client
(ADOR)
• Cursore a scorrimento in avanti: si comporta esattamente come un cursore statico ad
eccezione del fatto che consente di scorrere i record solo in avanti. In questo modo si
migliorano le prestazioni quando è necessario effettuare un solo passaggio all'interno di un
Recordset.
Impostare la proprietà CursorType prima di aprire il Recordset per scegliere il tipo di cursore o
passare un argomento TipoCursore con il metodo Open. Alcuni provider non supportano tutti i tipi
di cursore. Consultare la documentazione del provider. Se non viene specificato un tipo di cursore,
in base all'impostazione predefinita verrà aperto un cursore a scorrimento in avanti.
Se la proprietà CursorLocation viene impostata su adUseClient per aprire un Recordset, la
proprietà UnderlyingValue sugli oggetti Field non è disponibile nell'oggetto Recordset restituito.
Quando utilizzati con alcuni provider quali Microsoft ODBC Provider for OLE DB unitamente a
Microsoft SQL Server, è possibile creare oggetti Recordset indipendentemente da un oggetto
Connection definito in precedenza passando una stringa di connessione con il metodo Open. ADO
creerà sempre un oggetto Connection, senza tuttavia assegnarlo a una variabile di oggetto. Se
vengono tuttavia aperti più oggetti Recordset tramite la stessa connessione, sarà necessario creare e
aprire esplicitamente un oggetto Connection, in modo da assegnarlo a una variabile oggetto. Se non
si utilizza questa variabile di oggetto quando si aprono gli oggetti Recordset, ADO creerà un nuovo
oggetto Connection per ciascun nuovo Recordset, anche se si passa la stessa stringa di
connessione.
È possibile creare un numero di oggetti Recordset illimitato.
Quando si apre un Recordset, il record corrente corrisponde al primo record se disponibile, mentre
le proprietà BOF and EOF vengono impostate a False. Se non sono disponibili record,
l'impostazione per BOF e EOF è True.
È possibile utilizzare i metodi MoveFirst, MoveLast, MoveNext, MovePrevious e Move, e le
proprietà AbsolutePosition, AbsolutePage e Filter per riposizionare il record corrente, purché il
provider supporti la relativa funzionalità. Gli oggetti Recordset a scorrimento in avanti supportano
solo il metodo MoveNext. Quando si utilizzano i metodi Move per visualizzare ciascun record o
enumerare il Recordset, è possibile utilizzare le proprietà BOF ed EOF per verificare se è stato
superato l'inizio o la fine del Recordset.
Gli oggetti Recordset supportano l'aggiornamento immediato e l'aggiornamento in modalità batch.
Nell'aggiornamento immediato tutte le modifiche apportate ai dati vengono immediatamente scritte
sull'origine dati di livello inferiore quando si richiama il metodo Update. È inoltre possibile passare
serie di valori come parametri con i metodi AddNew e Update e aggiornare contemporaneamente
vari campi di un record.
Se il provider supporta l'aggiornamento in modalità batch, è possibile memorizzare nella cache le
modifiche apportate a più record, quindi trasmetterle con un sola chiamata al database con il metodo
UpdateBatch. Si tratta di una procedura valida per le modifiche apportate con i metodi AddNew,
73 di 81
Update e Delete. Dopo aver richiamato il metodo UpdateBatch, è possibile utilizzare la proprietà
Status per verificare e risolvere eventuali conflitti di dati.
Nota Per eseguire una query senza utilizzare un oggetto Command, passare una stringa della
query al metodo Open di un oggetto Recordset. È tuttavia necessario specificare un oggetto
Command quando si desidera mantenere il testo del comando e rieseguirlo oppure utilizzare i
parametri della query.
Proprietà BOF ed EOF
BOF indica che il record corrente si trova prima del primo record di un oggetto Recordset.
EOF indica che il record corrente si trova dopo l'ultimo record di un oggetto Recordset.
Valore restituito
Le proprietà BOF ed EOF restituiscono valori booleani.
Osservazioni
Utilizzare le proprietà BOF e EOF per determinare se un oggetto Recordset contenga record o se
siano stati superati i limiti di un oggetto Recordset durante lo spostamento da un record all'altro.
La proprietà BOF restituisce True (-1) se il record corrente si trova prima del primo record e False
(0) se si trova in corrispondenza del primo record o dopo di esso.
La proprietà EOF restituisce True se il record corrente si trova dopo l'ultimo record e False se si
trova in corrispondenza dell'ultimo record o prima di esso.
Se entrambi le proprietà BOF ed EOF restituiscono True, non è disponibile alcun record corrente.
Se si apre un oggetto Recordset per cui non è disponibile alcun record, le proprietà BOF ed EOF
saranno impostate su True e la proprietà RecordCount dell'oggetto Recordset sarà impostata su
zero. Quando si apre un oggetto Recordset con almeno un record, il primo record sarà quello
corrente e le proprietà BOF ed EOF saranno impostate su False.
Se si elimina l'ultimo record dell'oggetto Recordset, è possibile che le proprietà BOF ed EOF
risultino impostate su False fino a quando non si prova a riposizionare il record corrente.
Nella tabella che segue vengono illustrati i metodi Move consentiti con combinazioni diverse delle
proprietà BOF ed EOF.
•
•
MoveFirst,
MoveLast
MovePrevious,
Move < 0
Move 0
MoveNext,
Move > 0
BOF=True,
EOF=False
Consentito
Errore
Errore
Consentito
BOF=False,
EOF=True
Consentito
Consentito
Errore
Errore
Entrambe True
Errore
Errore
Errore
Errore
Entrambe False
Consentito
Consentito
Consentito Consentito
La possibilità di eseguire un metodo Move non garantisce l'individuazione di un record, ma indica
solo che richiamando un metodo Move specificato non verrà generato un errore.
Nella tabella che segue viene illustrato il modo in cui è possibile modificare le impostazioni delle
proprietà BOF ed EOF quando si richiamano vari metodi Move senza riuscire a individuare un
record.
BOF
MoveFirst, MoveLast
EOF
Impostato su True Impostato su True
74 di 81
Move 0
Nessuna modifica
Nessuna modifica
MovePrevious, Move < 0
Impostato su True Nessuna modifica
MoveNext, Move > 0
Nessuna modifica
Impostato su True
Esempio di proprietà BOF, EOF e Bookmark
In questo esempio vengono utilizzate le proprietà BOF e EOF per la visualizzazione di un
messaggio nel caso in cui l'utente provi a spostarsi oltre il primo o l'ultimo record di un recordset.
Viene inoltre utilizzata la proprietà Bookmark per l'applicazione di un segnalibro a un determinato
record di un recordset in modo da poterlo visualizzare in un secondo momento.
Public
Dim
Dim
Dim
Dim
Dim
Sub BOFX()
rstPublishers As ADODB.Recordset
strCnn As String
strMessage As String
intCommand As Integer
varBookmark As Variant
' Aprire un recordset contenente i dati della tabella Publishers.
strCnn = "Provider=sqloledb;" & _
"Data Source=srv;Initial Catalog=pubs;User Id=sa;Password=; "
Set rstPublishers = New ADODB.Recordset
rstPublishers.CursorType = adOpenStatic
' Utilizzare il cursore client per abilitare la proprietà
' AbsolutePosition.
rstPublishers.CursorLocation = adUseClient
rstPublishers.Open "SELECT pub_id, pub_name FROM publishers " & _
"ORDER BY pub_name", strCnn, , , adCmdText
rstPublishers.MoveFirst
Do While True
' Visualizzare le informazioni sul record corrente
' e apportare le modifiche desiderate.
strMessage = "Publisher: " & rstPublishers!pub_name & _
vbCr & "(record " & rstPublishers.AbsolutePosition & _
" of " & rstPublishers.RecordCount & ")" & vbCr & vbCr & _
"Enter command:" & vbCr & _
"[1 - next / 2 - previous /" & vbCr & _
"3 - set bookmark / 4 - go to bookmark]"
intCommand = Val(InputBox(strMessage))
Select Case intCommand
' Spostarsi in avanti o all'indietro fino all'inizio
' o alla fine del file.
Case 1
rstPublishers.MoveNext
If rstPublishers.EOF Then
MsgBox "Moving past the last record." & _
vbCr & "Try again."
rstPublishers.MoveLast
End If
Case 2
rstPublishers.MovePrevious
If rstPublishers.BOF Then
MsgBox "Moving past the first record." & _
vbCr & "Try again."
rstPublishers.MoveFirst
End If
75 di 81
' Salvare il segnalibro per il record corrente.
Case 3
varBookmark = rstPublishers.Bookmark
' Posizionarsi sul record indicato dal segnalibro
' memorizzato.
Case 4
If IsEmpty(varBookmark) Then
MsgBox "No Bookmark set!"
Else
rstPublishers.Bookmark = varBookmark
End If
Case Else
Exit Do
End Select
Loop
rstPublishers.Close
End Sub
In questo esempio vengono utilizzate le proprietà Bookmark e Filter per la creazione di una
modalità di visualizzazione limitata del recordset, nella quale è possibile accedere solo ai record
contrassegnati dalla matrice dei segnalibri.
Public Sub BOFX2()
Dim rs As New ADODB.Recordset
Dim bmk(10)
rs.CursorLocation = adUseClient
rs.ActiveConnection = "Provider=sqloledb;" & _
"Data Source=srv;Initial Catalog=pubs;User Id=sa;Password=;"
rs.Open "select * from authors", , adOpenStatic, adLockBatchOptimistic
Debug.Print "Number of records before filtering: ", rs.RecordCount
ii = 0
While rs.EOF <> True And ii < 11
bmk(ii) = rs.Bookmark
ii = ii + 1
rs.Move 2
Wend
rs.Filter = bmk
Debug.Print "Number of records after filtering: ", rs.RecordCount
rs.MoveFirst
While rs.EOF <> True
Debug.Print rs.AbsolutePosition, rs("au_lname")
rs.MoveNext
Wend
End Sub
Metodo Open (Recordset ADO)
Apre un cursore.
Sintassi
76 di 81
recordset.Open Origine, ConnessioneAttiva, TipoCursore, TipoBlocco, Opzioni
Parametri
Origine Elemento Variant che restituisce un nome di variabile oggetto Command valido,
un'istruzione SQL, un nome di tabella, una chiamata di una stored procedure oppure il nome del file
di un recordset protetto (opzionale).
ConnessioneAttiva Elemento Variant che restituisce un nome di variabile oggetto Connection
valido o un elemento String contenente i parametri ConnectionString (opzionale).
TipoCursore Valore CursorTypeEnum che determina il tipo di cursore che il provider deve
utilizzare quando apre il Recordset (opzionale). Tale valore può essere una delle costanti che
seguono. Per ulteriori informazioni, vedere la proprietà CursorType.
Costante
Descrizione
adOpenForwardOnly
Apre un cursore a scorrimento in avanti (impostazione predefinita).
adOpenKeyset
Apre un cursore direzionabile.
adOpenDynamic
Apre un cursore dinamico.
adOpenStatic
Apre un cursore statico.
TipoBlocco Valore LockTypeEnum che determina il tipo di blocco o concorrenza che il provider
deve utilizzare quando apre il recordset (opzionale). Tale valore può essere una delle costanti che
seguono. Per ulteriori informazioni, vedere la proprietà LockType.
Costante
Descrizione
adLockReadOnly
Sola lettura – Impossibile modificare i dati (impostazione
predefinita).
adLockPessimistic
Blocco pessimistico record per record - Il provider esegue le
operazioni necessarie per assicurare la corretta modifica dei
record, in genere vincolando i record nell'origine dati in fase di
modifica.
adLockOptimistic
Blocco ottimistico record per record - Il provider utilizza il
blocco ottimistico, vincolando i record solo quando viene
chiamato il metodo Update.
adLockBatchOptimistic
Aggiornamento batch ottimistico - Richiesto per la modalità di
aggiornamento batch in contrapposizione con la modalità di
aggiornamento immediato.
Opzioni Valore Long che indica come il provider deve valutare l'argomento Origine se questo non
rappresenta un oggetto Command o che il recordset deve essere ripristinato da un file in cui era
stato precedentemente salvato (opzionale). Tale valore può essere una delle varianti che seguono.
Per ulteriori informazioni sulle prime cinque costanti dell'elenco, vedere la proprietà
CommandType.
Costante
Descrizione
adCmdText
Indica che il provider dovrà valutare Origine come una definizione
in formato testo di un comando.
adCmdTable
Indica che ADO dovrà generare una query SQL per restituire tutte le
77 di 81
righe della tabella indicata nell'argomento Origine.
adCmdTableDirect
Indica che il provider dovrà restituire tutte le righe della tabella
indicata nell'argomento Origine.
adCmdStoredProc
Indica che il provider dovrà valutare Origine come una stored
procedure.
adCmdUnknown
Indica che il tipo di comando nell'argomento Origine non è
conosciuto.
adCmdFile
Indica che il Recordset fissato o salvato dovrà essere ripristinato dal
file indicato nell'argomento Origine.
adAsyncExecute
Indica che Origine dovrà essere eseguito in modalità asincrona.
adAsyncFetch
Indica che dopo il fetch della quantità iniziale specificata nella
proprietà Initial Fetch Size deve essere eseguito il fetch asincrono
sulle righe rimanenti. Se è richiesta una riga per la quale non è stato
eseguito il fetch, il thread principale viene bloccato finché la riga
richiesta diviene disponibile.
adAsyncFetchNonBlocking Indica che il thread principale non viene mai bloccato durante le
operazioni di fetch. Se per la riga richiesta non è stato eseguito il
fetch, la riga corrente passa automaticamente alla fine del file.
Osservazioni
Utilizzando il metodo Open su un oggetto Recordset si apre un cursore che rappresenta record di
una tabella di base, i risultati di una query o un recordset salvato in precedenza.
Utilizzare l'argomento Origine opzionale per specificare un'origine dati con una variabile oggetto
Command, un'istruzione SQL, una stored procedure, un nome di tabella o il percorso completo di
un file. Se Origine è il nome e percorso di un file, può essere sia un percorso completo
("c:\dir\file.rst"), sia un percorso relativo ("..\file.rst"), sia un URL ("http://files/file.rst").
L'argomento ConnessioneAttiva corrisponde alla proprietà ActiveConnection e specifica durante
quale connessione aprire l'oggetto Recordset. Se si passa una definizione di connessione per questo
argomento, verrà aperta una nuova connessione utilizzando i parametri specificati. È possibile
modificare il valore di questa proprietà dopo avere aperto il recordset per inviare aggiornamenti a
un altro provider. In Microsoft Visual Basic è anche possibile impostare questa proprietà su
Nothing per disconnettere il recordset da qualsiasi provider.
Per gli altri argomenti che corrispondono direttamente alle proprietà di un oggetto Recordset,
ovvero Origine, TipoCursore e TipoBlocco, la relazione tra gli argomenti e le proprietà è la
seguente:
• La proprietà è di lettura/scrittura prima che l'oggetto Recordset venga aperto.
• Le impostazioni delle proprietà vengono utilizzate a meno che non si passino gli argomenti
corrispondenti durante l'esecuzione del metodo Open. Se si passa un argomento, questo avrà
la priorità sull'impostazione della proprietà corrispondente e l'impostazione verrà aggiornata
con il valore dell'argomento.
• Dopo l'apertura dell'oggetto Recordset queste proprietà diventano di sola lettura.
Nota Nel caso di oggetti Recordset la cui proprietà Source è impostata su un oggetto Command
valido la proprietà ActiveConnection è di sola lettura anche se l'oggetto Recordset non è stato
aperto.
78 di 81
Se si passa un oggetto Command nell'argomento Origine insieme a un argomento
ConnessioneAttiva, si verificherà un errore. La proprietà ActiveConnection dell'oggetto
Command deve essere già impostata su un oggetto Connection o su una stringa di connessione.
Se non si passa un oggetto Command nell'argomento Origine, sarà possibile utilizzare l'argomento
Opzioni per ottimizzare la valutazione dell'argomento Origine. Se l'argomento Opzioni non è
definito, le prestazioni potranno risultare ridotte dal momento che è necessario effettuare chiamate
al provider per determinare se l'argomento è un'istruzione SQL, una stored procedure o un nome di
tabella. Se si conosce il tipo di Origine in uso, impostando l'argomento Opzioni si indicherà ad
ADO di andare direttamente al codice che interessa. Se l'argomento Opzioni non corrisponde al tipo
Origine, si verificherà un errore.
Il valore predefinito per l'argomento Opzioni sarà adCmdFile se non vi è alcuna connessione
associata al recordset. Questo è il caso tipico per gli oggetti Recordset salvati.
Se l'origine dati non restituisce alcun record, il provider imposterà le proprietà BOF e EOF su True
e la posizione del record corrente non verrà definita. È ancora possibile aggiungere nuovi dati a
questo oggetto Recordset vuoto se il tipo di cursore lo consente.
Una volta concluse le operazioni su un oggetto Recordset aperto, utilizzare il metodo Close per
rendere disponibili le risorse di sistema associate. Se si chiude un oggetto, questo non verrà rimosso
dalla memoria. Sarà infatti possibile modificarne le impostazioni delle proprietà e utilizzare il
metodo Open per riaprirlo in un secondo momento. Per eliminare completamente un oggetto dalla
memoria impostare la variabile oggetto su Nothing.
Chiamare Open senza operandi e prima che la proprietà ActiveConnection venga impostata per
creare un'istanza di un recordset creato accodando campi all'insieme Recordset Fields.
Se si è impostata la proprietà CursorLocation su adUseClient, è possibile recuperare righe in
modalità asincrona in due modi. Il metodo consigliato è di impostare Opzioni su adAsyncFetch. In
alternativa, è possibile utilizzare la proprietà dinamica Asynchronous Rowset Processing
dell'insieme Properties, ma in questo caso è possibile che gli eventi recuperati vengano persi se il
parametro Options non è impostato su adAsyncFetch
Nota Le operazioni di fetch in background del provider MSRemote sono supportate soltanto
attraverso il parametro Opzioni del metodo Open.
Metodo Close
Chiude un oggetto aperto e i relativi oggetti dipendenti.
Sintassi
oggetto.Close
Osservazioni
Utilizzare il metodo Close per chiudere un oggetto Connection o un oggetto Recordset per rendere
disponibili le eventuali risorse di sistema associate. Se si chiude un oggetto, questo non verrà
rimosso dalla memoria. È tuttavia possibile modificarne le impostazioni delle proprietà e riaprire
l'oggetto in un secondo momento. Per eliminare completamente un oggetto dalla memoria,
impostare la variabile oggetto su Nothing.
Connessione
Se si utilizza il metodo Close per chiudere un oggetto Connection, verranno chiusi anche tutti gli
oggetti Recordset attivi associati alla connessione. Un oggetto Command associato all'oggetto
Connection che si sta chiudendo resterà aperto ma non sarà più associato a un oggetto Connection,
vale a dire che la proprietà ActiveConnection verrà impostata su Nothing. Tutti i parametri definiti
dal provider verranno inoltre cancellati dall'insieme Parameters dell'oggetto Command.
79 di 81
È possibile chiamare in un secondo momento il metodo Open per ristabilire la connessione con la
stessa o con un'altra origine dati. Mentre l'oggetto Connection viene chiuso, se si chiama un
metodo qualsiasi che richiede una connessione aperta con l'origine dati si genererà un errore.
Se si chiude un oggetto Connection mentre ci sono oggetti Recordset aperti sulla connessione,
verrà annullata qualsiasi modifica in sospeso in tutti gli oggetti Recordset. Se durante una
transazione si chiude un oggetto Connection chiamando il metodo Close, si genererà un errore. Se
un oggetto Connection non è compreso nell'area di validità mentre è in corso una transazione, la
transazione verrà annullata automaticamente.
Recordset
Utilizzando il metodo Close per chiudere un oggetto Recordset vengono rilasciati i dati associati e
gli eventuali accessi esclusivi ai dati effettuati tramite questo particolare oggetto Recordset. È
possibile chiamare in un secondo momento il metodo Open per riaprire il Recordset con attributi
uguali o modificati. Mentre un oggetto Recordset viene chiuso, se si chiama un metodo qualsiasi
che richiede un cursore dinamico si genererà un errore.
Se è in corso una modifica nella modalità di aggiornamento immediato, chiamando il metodo Close
si genererà un errore. Chiamare innanzitutto il metodo Update o CancelUpdate. Se si chiude
l'oggetto Recordset durante l'aggiornamento batch, tutte le modifiche dall'ultima chiamata
UpdateBatch andranno perse.
Se si utilizza il metodo Clone per creare copie di un oggetto Recordset aperto, la chiusura
dell'originale o di un clone non avrà effetto sulle altre copie.
Esempio di utilizzo dei metodi Open e Close
Nell'esempio che segue i metodi Open e Close verranno utilizzati sugli oggetti Recordset e
Connection aperti in precedenza.
Public Sub OpenX()
Dim cnn1 As ADODB.Connection
Dim rstEmployees As ADODB.Recordset
Dim strCnn As String
Dim varDate As Variant
' Apre la connessione.
strCnn = "Provider=sqloledb;" & _
"Data Source=srv;Initial Catalog=pubs;User Id=sa;Password=; "
Set cnn1 = New ADODB.Connection
cnn1.Open strCnn
' Apre la tabella Employees.
Set rstEmployees = New ADODB.Recordset
rstEmployees.CursorType = adOpenKeyset
rstEmployees.LockType = adLockOptimistic
rstEmployees.Open "employee", cnn1, , , adCmdTable
' Assegna la data di assunzione del dipendente del primo record
' a una variabile, quindi modifica la data di assunzione.
varDate = rstEmployees!hire_date
Debug.Print "Original data"
Debug.Print " Name - Hire Date"
Debug.Print " " & rstEmployees!fName & " " & _
rstEmployees!lName & " - " & rstEmployees!hire_date
rstEmployees!hire_date = #1/1/1900#
rstEmployees.Update
Debug.Print "Changed data"
Debug.Print " Name - Hire Date"
Debug.Print " " & rstEmployees!fName & " " & _
rstEmployees!lName & " - " & rstEmployees!hire_date
' Riesegue la query sul recordset e ripristina la data di assunzione.
80 di 81
rstEmployees.Requery
rstEmployees!hire_date = varDate
rstEmployees.Update
Debug.Print "Data after reset"
Debug.Print " Name - Hire Date"
Debug.Print " " & rstEmployees!fName & " " & _
rstEmployees!lName & " - " & rstEmployees!hire_date
rstEmployees.Close
cnn1.Close
End Sub
Metodi MoveFirst, MoveLast, MoveNext e MovePrevious
Sposta la posizione del record corrente sul primo, sull'ultimo, sul successivo o sul precedente record
in un oggetto Recordset specificato.
Sintassi
recordset.{MoveFirst | MoveLast | MoveNext | MovePrevious}
Osservazioni
Utilizzare il metodo MoveFirst per spostare la posizione del record corrente sul primo record del
Recordset.
Utilizzare il metodo MoveLast per spostare la posizione del record corrente sull'ultimo record del
Recordset. L'oggetto Recordset deve supportare i segnalibri o lo spostamento all'indietro del
cursore. In caso contrario, la chiamata di questo metodo genererà un errore.
Utilizzare il metodo MoveNext per spostare la posizione del record corrente sul record successivo
verso la fine del recordset. Se l'ultimo record è il record corrente e si chiama il metodo MoveNext,
il record corrente verrà impostato sulla posizione successiva all'ultimo record del recordset, ovvero
EOF è uguale a True. Se si tenta di spostare in avanti la posizione del record quando la proprietà
EOF è già uguale a True, si genererà un errore.
Utilizzare il metodo MovePrevious per spostare la posizione del record corrente sul record
precedente verso l'inizio del recordset. L'oggetto Recordset deve supportare i segnalibri o lo
spostamento all'indietro del cursore. In caso contrario, la chiamata di questo metodo genererà un
errore. Se il primo record è il record corrente e si chiama il metodo MovePrevious, il record
corrente verrà impostato sulla posizione precedente al primo record del recordset, ovvero BOF è
uguale a True. Se si tenta di spostare all'indietro la posizione del record quando la proprietà BOF è
già uguale a True, si genererà un errore. Se l'oggetto Recordset non supporta i segnalibri o lo
spostamento all'indietro del cursore, il metodo MovePrevious genererà un errore.
Se il recordset è a scorrimento in avanti e si desidera uno scorrimento sia in avanti che all'indietro,
sarà possibile utilizzare la proprietà CacheSize per creare una cache di record che supporti lo
spostamento all'indietro del cursore con il metodo Move. Dal momento che i record nella cache
vengono caricati in memoria, si consiglia di non inserire nella cache più record di quelli necessari. È
possibile chiamare il metodo MoveFirst in un oggetto Recordset a scorrimento in avanti, anche se
in questo caso il provider potrebbe rieseguire il comando che ha generato l'oggetto Recordset.
81 di 81