3. Nozioni di base sulla programmazione VBSCRIPT

Dopo aver descritto i possibili contesti di esecuzione di uno script VBScript, passiamo ora al linguaggio stesso. Nel prosieguo, considereremo le seguenti condizioni:

il contenitore dello script è WSH
lo script è contenuto in un file con estensione .vbs

Per presentare un concetto, procediamo in genere nel modo seguente:

si introduce il concetto, se necessario
presentiamo un programma esemplificativo con i relativi risultati
commentiamo i risultati e il programma, se necessario

I contenitori VBScript non distinguono tra maiuscole e minuscole nel testo dello script. Pertanto, è possibile scrivere indifferentemente wscript.echo "ciao" o WSCRIPT.ECHO "ciao".

I programmi presentati di seguito generano molti messaggi sullo schermo, pertanto ripasseremo i metodi di scrittura dell’oggetto wscript.

3.1. Visualizzazione di informazioni

Abbiamo già utilizzato il metodo echo dell’oggetto wscript, ma quest’ultimo dispone di altri metodi che consentono di scrivere sullo schermo, come mostra il seguente script:

Programma

Risultati

un
deuxtrois
quatre
cinq

Si notino i seguenti punti:

Qualsiasi testo inserito dopo un apostrofo viene considerato un commento dello script e non viene interpretato da WSH (riga 1).
Il metodo echo scrive i propri argomenti e passa alla riga successiva, così come il metodo writeLine (righe 2 e 6)
il metodo write scrive i propri argomenti e non passa alla riga successiva (riga 3)
un segno di fine riga è rappresentato dalla sequenza di due caratteri con codici ASCII 13 e 10. Pertanto, la riga 4 è rappresentata dall'espressione chr(13) & chr(10), dove chr(i) è il carattere con codice ASCII i e & è l'operatore di concatenazione delle stringhe. Pertanto, "chat" & "eau" forma la stringa "chateau".
Il carattere di fine riga può essere rappresentato più facilmente dalla costante vbCRLF (riga 5)

3.2. E a scrittura delle istruzioni in uno script VBScript

Per impostazione predefinita, si scrive un'istruzione per riga. Tuttavia, è possibile scrivere più istruzioni per riga separandole con il carattere : come in inst1:inst2:inst3. Se una riga è troppo lunga, è possibile suddividerla in più parti. In tal caso, le diverse parti dell’istruzione devono terminare con i due caratteri (spazio)_. Riprendiamo l’esempio precedente riscrivendo le istruzioni in modo diverso:

Programma

Risultati

un
deuxtrois
quatre
cinq

3.3. Scrivere con la funzione msgBox

Sebbene in questo documento utilizziamo quasi esclusivamente l'oggetto wscript per scrivere sullo schermo, esiste una funzione più sofisticata per visualizzare informazioni in una finestra. Si tratta della funzione msgbox, che in genere viene utilizzata con tre parametri:

msgbox messaggio, icone+pulsanti, titolo

message è il testo del messaggio da visualizzare
icone+pulsanti (facoltativo) è in realtà un numero che indica il tipo di icona e i pulsanti da inserire nella finestra del messaggio. Questo numero è solitamente la somma di due numeri: il primo determina l’icona, il secondo i pulsanti
titolo è il testo da inserire nella barra del titolo della finestra del messaggio

I valori da utilizzare per specificare l’icona e i pulsanti della finestra di visualizzazione sono i seguenti:

Costante	Valore	Descrizione
vbOKOnly	0	Visualizza solo il pulsante OK.
vbOKCancel	1	Visualizza i pulsanti OK e Annulla.
vbAbortRetryIgnore	2	Visualizza i pulsanti Abbandona, 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 "Messaggio critico".
vbQuestion	32	Visualizza l'icona "Richiesta di avviso".
vbExclamation	48	Visualizza l'icona "Messaggio di avviso".
vbInformation	64	Visualizza l'icona del messaggio informativo.
vbDefaultButton1	0	Il primo pulsante è quello predefinito.
vbDefaultButton2	256	Il secondo pulsante è quello predefinito.
vbDefaultButton3	512	Il terzo pulsante è quello predefinito.
vbDefaultButton4	768	Il quarto pulsante è quello predefinito.
vbApplicationModal	0	Applicazione modale; l'utente deve rispondere al messaggio prima di poter continuare a lavorare nell'applicazione corrente.
vbSystemModal	4096	Sistema modale; tutte le applicazioni vengono sospese finché l'utente non risponde al messaggio.

Ecco alcuni esempi:

Programma

Risultati

In alcuni casi viene visualizzata una finestra informativa che funge anche da finestra di immissione dati. Se si pone una domanda, si desidera ad esempio sapere se l'utente ha cliccato sul pulsante oui o sul pulsante non. La funzione msgBox restituisce un risultato che nel programma precedente non abbiamo utilizzato. Questo risultato è un numero intero che rappresenta il pulsante utilizzato dall’utente per chiudere la finestra di visualizzazione:

Costante	Valore	Pulsante selezionato
vbOK	1	OK
vbCancel	2	Annulla
vbAbort	3	Abbandono
vbRetry	4	Riprova
vbIgnore	5	Ignora
vbYes	6	Sì
vbNo	7	No

Il programma seguente mostra come utilizzare il risultato della funzione msgBox. Viene visualizzata 4 volte una finestra con i pulsanti Sì, No, Annulla. Si risponde nel modo seguente:

si clicca su «Sì»
si clicca su «No»
si clicca su Annulla
si chiude la finestra senza utilizzare alcun pulsante. Il programma mostra che ciò equivale a utilizzare il pulsante Annulla.

Programma

Risultati

3.4. i dati utilizzabili in VBScript

VBscript riconosce un solo tipo di dati: il variant. Il valore di un variant può essere un numero (4, 10,2), una stringa di caratteri ("ciao"), un valore booleano (true/false), una data (#01/01/2002#), l'indirizzo di un oggetto, un insieme di tutti questi dati inseriti in una struttura chiamata array.

Esaminiamo il seguente programma e i suoi risultati:

Programma	Risultati
	`4 i=4 10,2 r1=10,2 0,014 r2=0,014 c1=bonjour 01/10/02 d1=01/10/02 10/01/02 d2=10/01/02 -1 b1=Vrai 0 b2=Faux v=4 v=10,2 v=bonjour v=01/10/02 v=Vrai`

Commenti:

alcuni linguaggi di programmazione (C, C++, Pascal, Java, C#, ...) richiedono la dichiarazione preventiva di una variabile prima del suo utilizzo. Tale dichiarazione consiste nell'indicare il nome della variabile e il tipo di dati che può contenere (intero, reale, stringa, data, booleano, ...). La dichiarazione delle variabili consente diverse operazioni:
- conoscere lo spazio di memoria necessario alla variabile, poiché tipi di dati diversi richiedono spazi di memoria diversi
- verificare la coerenza del programma. Pertanto, se i è un intero e c una stringa di caratteri, moltiplicare i per c non ha alcun senso. Se il tipo delle variabili i e c è stato dichiarato dal programmatore, il programma incaricato di analizzare il codice prima dell’esecuzione può segnalare tale incoerenza.

Come la maggior parte dei linguaggi di scripting con un unico tipo di dati (Perl, Python, Javascript, ...), VBScript consente di non dichiarare le variabili. È proprio ciò che è stato fatto nell’esempio sopra riportato.

Si noti la sintassi dei diversi valori
- 10,2 alla riga 10 (punto decimale anziché virgola). Si noti che sullo schermo viene visualizzato 10,2.
- 1.4e-2 alla riga 13 (notazione scientifica). Sullo schermo viene visualizzato il numero 0,014
- [#01/10/2002#] (riga 26) per rappresentare la data del 10 gennaio 2002. È quindi il formato #mm/gg/aaaa# che VBScript utilizza per rappresentare la data jj del mese mm dell'anno aaaa
- i valori booleani true e false (vero/falso) nelle righe 31 e 34. Questi due valori sono rappresentati rispettivamente dai numeri interi -1 e 0, come mostra la visualizzazione delle righe 32 e 35. Quando un valore booleano viene concatenato a una stringa di caratteri, questi valori diventano rispettivamente le stringhe "Vero" e "Falso", come mostrano le righe 33 e 36. Si noti, tra l'altro, che l'operatore di concatenazione & può essere utilizzato per concatenare anche elementi diversi dalle stringhe.

Poiché una variabile v non ha un tipo assegnato, può assumere in successione valori di tipi diversi.

3.5. L' i sottotipi del tipo variant

Ecco cosa dice la documentazione ufficiale sui diversi tipi di dati che un variant può contenere:

Oltre alla semplice distinzione tra numero e stringa, un Variant può distinguere diversi tipi di informazioni numeriche. Ad esempio, alcune informazioni numeriche rappresentano una data o un'ora. Quando queste informazioni vengono utilizzate con altri dati relativi a date o ore, il risultato è sempre espresso sotto forma di data o ora. Sono disponibili anche altri tipi di informazioni numeriche, dai valori booleani ai grandi numeri in virgola mobile. Queste diverse categorie di informazioni che possono essere contenute in un Variant sono sottotipi. Nella maggior parte dei casi, è sufficiente inserire i dati in un Variant e questo si comporterà nel modo più appropriato in base a tali dati.

La tabella seguente presenta i diversi sottotipi che possono essere contenuti in un Variant.

Sottotipo	Descrizione
Empty	Il Variant non è inizializzato. Il suo valore è pari a zero per le variabili numeriche e a una stringa di lunghezza nulla ("") per le variabili stringa.
Null	Il Variant contiene intenzionalmente dati non corretti.
Boolean	Contiene True (vero) o False (falso).
Byte	Contiene un numero intero compreso tra 0 e 255.
Integer	Contiene un numero intero compreso tra -32 768 e 32 767.
Valuta	Da -922 337 203 685 477,5808 a 922 337 203 685 477,5807.
Long	Contiene un numero intero compreso tra -2 147 483 648 e 2 147 483 647.
Single	Contiene un numero in virgola mobile a precisione singola compreso tra -3,402823E38 e -1,401298E-45 per i valori negativi; da 1,401298E-45 a 3,402823E38 per i valori positivi.
Doppia precisione	Contiene un numero in virgola mobile a doppia precisione compreso tra -1,79769313486232E308 e -4,94065645841247E-324 per i valori negativi; da 4,94065645841247E-324 a 1,79769313486232E308 per i valori positivi.
Data (Ora)	Contiene un numero che rappresenta una data compresa tra il 1° gennaio 100 e il 31 dicembre 9999.
Stringa	Contiene una stringa di lunghezza variabile limitata a circa 2 miliardi di caratteri.
Oggetto	Contiene un oggetto.
Error	Contiene un numero di errore.

3.6. C onoscere il tipo esatto dei dati contenuti in un variant

Una variabile di tipo variant può contenere dati di vario tipo. A volte è necessario conoscere la natura esatta di tali dati. Se in un programma scriviamo produit=nombre1*nombre2, supponiamo che nombre1 e nombre2 siano due dati numerici. A volte non ne siamo sicuri, poiché questi valori possono provenire da un inserimento da tastiera, da un file o da una fonte esterna qualsiasi. Dobbiamo quindi verificare la natura dei dati contenuti in nombre1 e nombre2. La funzione typename(var) ci permette di conoscere il tipo di dati contenuti nella variabile var. Ecco alcuni esempi:

Programma	Risultati
	`var=1,type=Integer var=deux,type=String var=Vrai,type=Boolean var=4,5,type=Double var=11/10/01,type=Date`

Un'altra funzione possibile è vartype(var), che restituisce un numero che rappresenta il tipo dei dati contenuti nella variabile var:

Costante	Valore	Descrizione
vbEmpty	0	Vuoto (non inizializzato)
vbNull	1	Null (nessun dato valido)
vbInteger	2	Numero intero
vbLong	3	Numero intero lungo
vbSingle	4	Numero in virgola mobile a precisione singola
vbDouble	5	Numero in virgola mobile a doppia precisione
vbCurrency	6	Valuta
vbDate	7	Data
vbString	8	Canale
vbObject	9	Oggetto Automazione
vbError	10	Errore
vbBoolean	11	Booleano
vbVariant	12	Variant (utilizzato solo con array di Variant)
vbDataObject	13	Oggetto non Automation
vbByte	17	Byte
vbArray	8192	Tabella

Nota: queste costanti sono specificate da VBScript. Di conseguenza, i nomi possono essere utilizzati ovunque nel codice al posto dei valori effettivi.

Le informazioni di cui sopra provengono dalla documentazione di VBscript. Talvolta sono errate, probabilmente a causa di operazioni di copia-incolla effettuate dalla documentazione di VB. La funzione vartype di VBScript svolge solo una parte di quanto sopra descritto.

Il programma precedente, riscritto per vartype, fornisce i seguenti risultati:

Programma	Risultati
	`var=1,type=2 var=deux,type=8 var=Vrai,type=11 var=4,5,type=5 var=11/10/01,type=7`

3.7. D ichiarare le variabili utilizzate dallo script

Abbiamo indicato che non è obbligatorio dichiarare le variabili utilizzate dallo script. In questo caso, se scriviamo:


1) somme=4
...
2) somme=smme+10

Con un errore di battitura come smme al posto di "somme" nell'istruzione 2, VBScript non segnalerà alcun errore. Presumerà che smme sia una nuova variabile. La creerà e, nel contesto dell'istruzione 2, la utilizzerà inizializzandola a 0.

Questo tipo di errori può essere molto difficile da individuare. Si consiglia quindi di forzare la dichiarazione delle variabili con la direttiva Option Explicit inserita all’inizio dello script. Successivamente, ogni variabile deve essere dichiarata con un’istruzione Dim prima del suo primo utilizzo:


option explicit
...
dim somme
1) somme=4
...
2) somme=smme+10

In questo esempio, VBScript segnalerà la presenza di una variabile non dichiarata, come illustrato al punto 2) nell'esempio seguente:

Programma	Risultati
	`dim1.vbs(9, 1) Erreur d'exécution Microsoft VBScript: Variable non définie: 'smme'`

Sebbene nei brevi esempi contenuti nel documento le variabili non siano per lo più dichiarate, ne imporremo la dichiarazione non appena scriveremo i primi script significativi. La direttiva Option explicit verrà quindi utilizzata sistematicamente.

3.8. Le funzioni di conversione di

VBScript trasforma i dati delle varianti in stringhe, numeri, valori booleani, ecc. a seconda del contesto. Nella maggior parte dei casi funziona bene, ma a volte riserva qualche sorpresa, come vedremo in seguito. Potrebbe quindi essere necessario “forzare” il tipo di dati della variante. VBscript dispone di funzioni di conversione che trasformano un’espressione in vari tipi di dati. Eccone alcune:

Cint (espressione)	trasforma l’espressione in un intero corto (integer)
Clng (espressione)	trasforma l’espressione in un intero lungo (long)
Cdbl (espressione)	converte l'espressione in un numero reale a doppia precisione (double)
Csng (espressione)	converte l'espressione in un numero reale di precisione singola (single)
Ccur (espressione)	converte l'espressione in un valore monetario (currency)

Ecco alcuni esempi:

Programma

Risultati

var=4,code type=8,nom type=String
var=4,code type=2,nom type=Integer
var=1000000,code type=8,nom type=String
var=1000000,code type=3,nom type=Long
var=3,4e-5,code type=8,nom type=String
var=0,000034,code type=5,nom type=Double
var=3,4e-5,code type=8,nom type=String
var=0,000034,code type=4,nom type=Single
var=1000,45,code type=8,nom type=String
var=1000,45,code type=6,nom type=Currency
var=14,code type=2,nom type=Integer
var=14,code type=8,nom type=String
var=1000,45,code type=5,nom type=Double
var=1000,code type=2,nom type=Integer
var=1000,75,code type=5,nom type=Double
var=1001,code type=2,nom type=Integer

3.9. L' e i dati digitati sulla tastiera

L'oggetto wscript consente a uno script di recuperare i dati digitati dalla tastiera. Il metodo wscript.stdin.readLine permette di leggere una riga di testo digitata dalla tastiera e confermata con il tasto "Invio". La riga letta può essere assegnata a una variabile.

Programma	Risultati
	`Tapez votre nom : st Bonjour st`

Commenti:

Nella colonna dei risultati e nella riga [Tapez votre nom : st], st è la riga digitata dall'utente.

Se il testo digitato sulla tastiera rappresenta un numero, viene comunque considerato innanzitutto come una stringa di caratteri, come mostra l'esempio riportato di seguito:

Programma

Risultati

1 2	`Tapez un nombre : 14 nombre lu=14,type=String`

Se questo numero viene utilizzato in un'operazione aritmetica, VBscript convertirà automaticamente la stringa in un numero, ma non sempre. Vediamo l'esempio seguente:

Programma

Risultati

nombre1 : 3
nombre2 : 4
3+4=34
3-4=-1
3x4=12
3/4=0,75

Nei risultati si nota che la riga 8 dello script non ha funzionato come previsto, poiché (purtroppo) in VBScript l’operatore + ha due significati: l’addizione di due numeri o la concatenazione di due stringhe (le due stringhe vengono unite tra loro). Abbiamo visto in precedenza che i numeri digitati dalla tastiera venivano interpretati come stringhe di caratteri e che VBScript le trasformava in numeri a seconda delle necessità. Lo ha fatto correttamente per le operazioni -, *, /, che possono coinvolgere solo numeri, ma non per l’operatore +, che può invece coinvolgere anche stringhe. In questo caso ha supposto che si volesse effettuare una concatenazione di stringhe.

Una soluzione semplice a questo problema consiste nel convertire le stringhe in numeri non appena vengono lette, come mostra la seguente versione migliorata del programma precedente:

Programma

Risultati

nombre1 : 3
nombre1=3,type=String
nombre1=3,type=Long
nombre2 : 4
nombre2=4,type=String
nombre2=4,type=Long
3+4=7
3-4=-1
3x4=12
3/4=0,75

3.10. S correre dati con la funzione inputbox

A volte si preferisce inserire i dati tramite un'interfaccia grafica anziché tramite la tastiera. In tal caso si utilizza la funzione inputBox. Questa funzione accetta numerosi parametri, ma solo i primi due vengono utilizzati frequentemente:

risposta=inputBox(messaggio,titolo)

messaggio: la domanda che si pone all'utente
titolo (facoltativo): il titolo che si assegna alla finestra di immissione
risposta: il testo digitato dall'utente. Se l'utente ha chiuso la finestra senza rispondere, risposta è una stringa vuota.

Ecco un esempio in cui si richiedono il nome e l’età di una persona. Per il nome si inserisce un’informazione e si seleziona OK. Per l’età, si inserisce anch’essa un’informazione ma si seleziona Annulla.

Programma

Risultati

3.11. U tilizzare oggetti strutturati

Con VBScript è possibile creare oggetti dotati di metodi e proprietà. Per non complicare le cose, presenteremo qui un oggetto con proprietà ma senza metodi. Consideriamo una persona. Essa possiede numerose proprietà che la caratterizzano: altezza, peso, colore della pelle, degli occhi, dei capelli... Ne prenderemo in considerazione solo due: il suo nome e la sua età. Prima di poter utilizzare gli oggetti, è necessario creare lo stampo che ne consentirà la creazione. In VBScript ciò avviene tramite una classe. La classe personne potrebbe essere definita come segue:


class personne
    Dim nom,age
End class

È l’istruzione [Dim nom,age] che definisce le due proprietà della classe personne. Per creare esemplari (chiamati istanze) della classe personne, si scrive:

1 2	`set personne1=new personne set personne2=new personne`

Perché non scrivere

1 2	`personne1=new personne personne2=new personne`

Perché una variante non può contenere un oggetto. Può contenere solo il suo indirizzo. Scrivendo set persona1=new persona, si verifica la seguente sequenza di eventi:

viene creato un oggetto personne. Ciò significa che gli viene allocata della memoria.
L’indirizzo di questo oggetto personne viene assegnato alla variabile personne1

Si ottiene quindi il seguente schema di memoria per le variabili personne1 e personne2:

Per convenzione, si potrebbe dire che personne1 è un oggetto personne. Si può accettare questa impropria definizione se si tiene presente che personne1 è in realtà l’indirizzo di un oggetto personne e non l’oggetto personne stesso.

Abbiamo detto che un oggetto personne aveva due proprietà: nom e age. Come sfruttare queste proprietà? Utilizzando la notazione objet.propriété, come spiegato poco sopra. Pertanto

personne1.nom indica il nome della persona 1 e personne1.age la sua età. Ecco un breve programma illustrativo:

Programma	Risultati
	`p1=(dupont,18)`

Il programma precedente potrebbe essere modificato come segue:

Programma	Risultati
	`nom=dupont age=18`

Qui abbiamo utilizzato la struttura with ... end with che permette di "fattorizzare" i nomi degli oggetti nelle espressioni. La struttura with p1 ... end with delle righe 9-12 e 15-18 consente di utilizzare successivamente la sintassi .nom al posto di p1.nom e .age al posto di p1.age. Ciò consente di semplificare la scrittura delle istruzioni in cui lo stesso nome di oggetto viene utilizzato ripetutamente.

3.12. Assegnare un valore a una variabile

Esistono due istruzioni per assegnare un valore a una variabile:

variabile=espressione
imposta variabile=espressione

La forma 2 è riservata alle espressioni il cui risultato è un riferimento a un oggetto. Per tutti gli altri tipi di espressioni è appropriata la forma 1. La differenza tra le due forme è la seguente:

nell'istruzione variable=expression, alla variabile viene assegnato un valore. Se v1 e v2 sono due variabili, scrivendo v1=v2 si assegna il valore di v1 a v2. Si ha quindi la duplicazione di un valore in due punti diversi. Se in seguito il valore di v2 viene modificato, quello di v1 rimane invariato.

nell'istruzione set variable=expression, la variabile riceve come valore l'indirizzo di un oggetto. Se v1 e v2 sono due variabili e se v2 è l'indirizzo di un oggetto obj2, scrivere set v1=v2 assegna il valore di v1 a v2, ovvero l'indirizzo dell'oggetto obj2. Quando lo script manipola successivamente v1 e v2, non sono i «valori» di v1 e v2 ad essere manipolati, ma gli oggetti a cui «puntano» v1 e v2, ovvero lo stesso oggetto in questo caso. Si dice che v1 e v2 sono due riferimenti allo stesso oggetto e che manipolare quest’ultimo tramite v1 o v2 non fa alcuna differenza. In altre parole, modificare l’oggetto a cui fa riferimento v2 modifica quello a cui fa riferimento v1.

Ecco un esempio:

Programma

Risultati

i=4
j=4
i=4
j=5
p1.nom=dupont
p1.age=18
p1.nom=dupont
p1.age=19
p2.nom=dupont
p2.age=19

3.13. E valuare le espressioni

I principali operatori che consentono di valutare le espressioni sono i seguenti:

Tipo di operatori	Operatori	Esempio
Aritmetici	+,-,*,/
		mod
		\
		^

Confronto	<, <= >, >= =,<>	a<>b è vero se a è diverso da b a=b è vero se a è uguale a b sia a che b possono essere entrambi numeri o entrambe stringhe di caratteri. In quest'ultimo caso, stringa1<stringa2 se, in ordine alfabetico, stringa1 precede stringa2. Nel confronto tra stringhe, le maiuscole precedono le minuscole nell'ordine alfabetico.
Confronto		is

Logica	and, or, not, xor	Qui gli operandi sono tutti booleani. bool1 or bool2 è vero se bool1 o bool2 è vero bool1 and bool2 è vero se sia bool1 che bool2 sono veri not bool1 è vero se bool1 è falso e viceversa bool1 xor bool2 è vero se solo uno dei valori booleani bool1 o bool2 è vero

Concatenazione	&, +	Si sconsiglia di utilizzare l'operatore + per concatenare due stringhe a causa della possibile confusione con l'addizione di due numeri. Si utilizzerà quindi esclusivamente l'operatore &.

3.14. C onrollare l'esecuzione del programma

3.14.1. E 'eseguire azioni in modo condizionale

L'istruzione VBScript che consente di eseguire azioni in base al valore vero/falso di una condizione è la seguente:


if expression then
    action-vrai-1
    action-vrai-2
    ..
else
    action-faux-1
    action-faux-2
    ...
end if

Viene valutata innanzitutto l'espressione expression. Questa espressione deve avere un valore booleano. Se il valore è vero, vengono eseguite le azioni di then; in caso contrario, vengono eseguite quelle di else, se presente.

Di seguito è riportato un programma che illustra diverse varianti della struttura if-then-else:

Programma

Risultati

3 est plus grand que 0
3 est plus grand que 2
i=4
4 est plus petit que 10
i=3

Commenti:

in VBScript è possibile scrivere istruzione1:istruzione2:...:istruzionn invece di scrivere un'istruzione per riga. È proprio questa possibilità che è stata sfruttata, ad esempio, alla riga 10.

3.14.2. E seguire azioni in modo ripetuto

Ciclo con numero di iterazioni noto

for i=idébut to ifin step ipas
    actions
next

La variabile i è qui denominata variabile di ciclo. Può avere un nome qualsiasi
i assume il valore idebut
il valore di i viene confrontato con ifin. Se i <= ifin, vengono eseguite le azioni contenute tra for... next
i viene incrementato del valore ipas (i = i + ipas)
si torna al punto 3 precedente. Dopo un numero finito di passaggi, il valore di i supererà ifin. L'esecuzione dello script prosegue con l'istruzione che segue il next
se l’incremento ipas è negativo, la condizione del passaggio 3 viene modificata. Le azioni di for...next vengono eseguite solo se i >= ifin.

È possibile uscire da un ciclo for in qualsiasi momento con l’istruzione exit for.

Ciclo con numero di iterazioni sconosciuto

do while condition
    actions
loop

viene valutata l'espressione di condizione. Se è vera, vengono eseguite le azioni di while...loop
le azioni eseguite potrebbero aver modificato il valore della condizione. Si torna al punto 1 precedente.
quando l'espressione condizionale diventa falsa, il ciclo termina

È possibile uscire da un ciclo do while in qualsiasi momento con l'istruzione exit do.

Il programma riportato di seguito illustra questi punti:

Programma

Risultati

i=0,tableau(i)=10,somme=10
i=1,tableau(i)=20,somme=30
i=2,tableau(i)=30,somme=60
i=3,tableau(i)=40,somme=100
i=0,tableau(i)=10,somme=10
i=1,tableau(i)=20,somme=30
i=2,tableau(i)=30,somme=60
i=1
i=2
i=3
i=4
i=5
i=6
i=7
i=8
i=9
i=10
i=11
i=1
i=2
i=3
i=4
i=5
i=6

Nota: nella fase di sviluppo di un programma, non è raro che un programma entri in un "ciclo infinito", c.a.d, e non si arresti mai. In genere, il programma esegue un ciclo la cui condizione di uscita non può essere verificata, come ad esempio nel seguente esempio:


' ciclo infinito
i=0
Do While 1=1
  i=i+1
  wscript.echo i
Loop

' un'altra dello stesso tipo
i=0
Do While true
  i=i+1
  wscript.echo i
Loop

Se si esegue il programma precedente, il primo ciclo non si interromperà mai da solo. È possibile forzare l'interruzione digitando CTRL-C sulla tastiera (tenendo premuti contemporaneamente il tasto CTRL e il tasto C).

3.14.3. Terminare l'esecuzione del programma

L'istruzione wscript.quit n termina l'esecuzione del programma restituendo un codice di errore pari a n. In DOS, questo codice di errore può essere verificato con l’istruzione if ERRORLEVEL n, che è vera se il codice di errore restituito dall’ultimo programma eseguito è >=n. Consideriamo il seguente programma e i suoi risultati:


	`début`

Subito dopo l’esecuzione del programma, si immettono i seguenti tre comandi DOS:

C:\>if ERRORLEVEL 5 echo 5

C:\>if ERRORLEVEL 4 echo 4
4

C: >if ERRORLEVEL 3 echo 3
3

Il comando DOS 1 verifica se il codice di errore restituito dal programma è >=5. In caso affermativo, visualizza (echo) 5, altrimenti nulla.

Il comando DOS 3 verifica se il codice di errore restituito dal programma è >=4. In caso affermativo, visualizza 4, altrimenti nulla.

Il comando DOS 5 verifica se il codice di errore restituito dal programma è >=3. Se sì, visualizza 3, altrimenti nulla.

Dai risultati visualizzati si può dedurre che il codice di errore restituito dal programma era 4.

3.15. L' e le tabelle di dati in una variante

L'xml-ph-0000@deepl.internali tabelle di dati in una variante Una variante T può contenere un elenco di valori. In tal caso si dice che si tratta di una tabella. Una tabella T possiede diverse proprietà:

Si accede all'elemento i dell'array T tramite la sintassi T(i), dove i è un numero intero chiamato indice compreso tra 0 e n-1 se T ha n elementi.
È possibile conoscere l'indice dell'ultimo elemento dell'array T con l'espressione ubound(T). Il numero di elementi dell'array T è quindi ubound(T)+1. Questo numero viene spesso chiamato dimensione dell'array.
Una variabile T può essere inizializzata con un array vuoto utilizzando la sintassi T=array() oppure con una sequenza di elementi utilizzando la sintassi T=array(elemento0, elemento1, ...., elementoN)
È possibile aggiungere elementi a un array T già creato. A tal fine, si utilizza l’istruzione redim preserve T(N), dove N è il nuovo indice dell’ultimo elemento dell’array T. L’operazione è denominata ridimensionamento (redim). La parola chiave preserve indica che, durante tale ridimensionamento, il contenuto attuale dell’array deve essere preservato. In assenza di questa parola chiave, T viene ridimensionato e svuotato dei suoi elementi.
Un elemento T(i) dell'array T è di tipo variant e può quindi contenere qualsiasi valore e, in particolare, un array. In questo caso, la notazione T(i)(j) indica l'elemento j dell'array T(i).

Queste diverse proprietà degli array sono illustrate dal programma seguente:

Programma	Risultati
	`Le tableau t1 a 5 éléments t1(0)=1 t1(1)=-4,5 t1(2)=deux t1(3)=Vrai t1(4)=10/01/02 t1=1:-4,5:deux:Vrai:10/01/02 t1(5)=10:20:30 t1(5)(1)=20 t1=1 ~ -4,5 ~ deux t1=:::`

Commenti

Qui è stata utilizzata una funzione chiamata join, spiegata più avanti.

3.16. L' e le variabili array

In VBScript esiste un altro modo per utilizzare un array, ovvero utilizzando una variabile array. A differenza delle variabili scalari, una variabile di questo tipo deve essere obbligatoriamente dichiarata tramite un'istruzione dim. Sono possibili diverse dichiarazioni:

dim array(n) dichiara un array statico di n+1 elementi numerati da 0 a n. Questo tipo di array non può essere ridimensionato
dim array() dichiara un array dinamico vuoto. Per poterlo utilizzare, dovrà essere ridimensionato tramite l’istruzione redim, allo stesso modo di un variant contenente un array
dim array(n,m) dichiara un array bidimensionale di (n+1)*(m+1) elementi. L’elemento (i,j) dell’array è indicato come tableau(i,j). Si noti la differenza rispetto a un variant, in cui lo stesso elemento sarebbe stato indicato come tableau(i)(j).

Perché esistono due tipi di array che, in fin dei conti, sono molto simili? La documentazione di VBScript non ne parla e non indica nemmeno se uno sia più performante dell’altro. Di seguito, nei nostri esempi utilizzeremo quasi esclusivamente l’array all’interno di una variante. Ricordiamo tuttavia che VBscript deriva dal linguaggio Visual Basic, che a sua volta contiene dati tipizzati (integer, double, boolean, ...). In questo caso, se si deve utilizzare un array di numeri reali, ad esempio, la variabile array sarà più efficiente della variabile variant. Si dichiarerà quindi qualcosa del tipo dim array(1000) as double per dichiarare un array di numeri reali o semplicemente dim array() as double se l’array è dinamico.

Ecco un esempio che illustra l’uso delle variabili array:

Programma

Risultati

Le tableau t1 a 5 éléments
t1(0)=1
t1(1)=-4,5
t1(2)=deux
t1(3)=Vrai
t1(4)=10/01/02
t1=1:-4,5:deux:Vrai:10/01/02
Le tableau t1 a 5 éléments
t2(0)=0
t2(1)(2)=30
t2=:::
t3(0,0)=0
t3(0,1)=1
t3(1,0)=10
t3(1,1)=11

3.17. L' lle funzioni split e join

Le funzioni split e join consentono di passare da una stringa a un array e viceversa:

Se T è un array e car una stringa, join(T,car) è una stringa formata dall'unione di tutti gli elementi dell'array T, ciascuno separato dal successivo dalla stringa car. Pertanto, join(array(1,2,3),"abcd") darà come risultato la stringa "1abcd2abcd3"
Se C è una stringa composta da una sequenza di campi separati dalla stringa car, la funzione split(C,car) restituisce un array i cui elementi sono i singoli campi della stringa C. Pertanto, split("1abcd2abcd3", "abcd") restituirà l'array (1,2,3)

Ecco un esempio:

Programma

Risultati


' trasformazione da tabella a stringa e viceversa

' array --> stringa
tableau=array("un",2,"trois")
chaine=join(tableau,",")
wscript.echo chaine

' stringa → array
tableau2=split(chaine,",")
For i=0 To ubound(tableau2)
  wscript.echo tableau2(i)
Next

un,2,trois
un
2
trois

3.18. I dizionari

Si accede a un elemento di un array T quando se ne conosce il numero i. Esso è quindi accessibile tramite la notazione T(i). Esistono array ai cui elementi si accede non tramite un numero, ma tramite una stringa di caratteri. L'esempio tipico di questo tipo di tabella è il dizionario. Quando si cerca il significato di una parola nel «Larousse» o nel «Petit Robert», vi si accede tramite la parola stessa. Si potrebbe rappresentare questo dizionario con una tabella a 2 colonne:

parola1	descrizione1
parola2	descrizione2
parola3	descrizione3
....

Si potrebbero quindi scrivere cose del tipo:

dizionario("parola1") = "descrizione1"

dizionario("parola2") = "descrizione2"

...

Ci si avvicina quindi al funzionamento di un array, con la differenza che gli indici dell'array non sono numeri interi ma stringhe di caratteri. Questo tipo di array viene chiamato dizionario (o array associativo, hashtable) e gli indici, essendo stringhe di caratteri, sono chiamati chiavi del dizionario (keys). L'uso dei dizionari è estremamente diffuso nel mondo dell'informatica. Tutti noi possediamo una tessera di previdenza sociale su cui è riportato un numero. Questo numero ci identifica in modo univoco e consente l'accesso alle informazioni che ci riguardano. Nel modello dizionario("chiave")="informazioni", "chiave" sarebbe in questo caso il numero di previdenza sociale e "informazioni" tutte le informazioni memorizzate su di noi nei computer dell'ente previdenziale.

In Windows è disponibile un oggetto ActiveX denominato «Scripting.Dictionary» che consente di creare e gestire i dizionari. Un oggetto ActiveX è un componente software che espone un’interfaccia utilizzabile da programmi scritti in diversi linguaggi, purché rispettino lo standard di utilizzo degli oggetti ActiveX. L’oggetto Scripting.dictionary è quindi utilizzabile dai linguaggi di programmazione di Windows: JavaScript, Perl, Python, C, C++, VB, VBA... e non solo da VBScript.

1	Un oggetto Scripting.Dictionary viene creato tramite un'istruzione set dico=wscript.CreateObject("Scripting.Dictionary") oppure semplicemente set dico=CreateObject("Scripting.Dictionary") CreateObject è un metodo dell'oggetto WScript che consente di creare istanze di oggetti ActiveX. La versione 2 mostra che wscript può essere un oggetto implicito. Quando un metodo non può essere "associato" a un oggetto, il contenitore WSH tenterà di associarlo all'oggetto wscript.
2	Una volta creato il dizionario, sarà possibile aggiungervi elementi con il metodo add: dico.add "chiave",valore creerà una nuova voce nel dizionario associata alla chiave "chiave". Il valore associato è un variant contenente un dato qualsiasi.
3	Per recuperare il valore associato a una determinata chiave si utilizza il metodo item del dizionario: var = dico.item("chiave") oppure set var=dico.item("chiave") se il valore associato alla chiave è un oggetto.
4	È possibile recuperare l'insieme delle chiavi del dizionario in un array variabile grazie al metodo `keys`: chiavi=dico.keys chiavi è un array i cui elementi possono essere iterati.
5	L'insieme dei valori del dizionario può essere recuperato in un array variabile tramite il metodo items: valori = diz.items `items` è un array i cui elementi possono essere iterati.
6	È possibile verificare l'esistenza di una chiave con il metodo exists: dico.exists("chiave") è vero se la chiave "chiave" è presente nel dizionario
7	È possibile rimuovere una voce dal dizionario (chiave+valore) con il metodo remove: dico.remove("chiave") rimuove dal dizionario la voce associata alla chiave "chiave". dico.removeall rimuove tutte le chiavi, c.a.d svuota il dizionario.

Il programma seguente utilizza queste diverse possibilità:

Programma


' creazione e utilizzo di un dizionario
Set dico=CreateObject("Scripting.Dictionary")

' popolamento del dizionario
dico.add "clé1","valeur1"
dico.add "clé2","valeur2"
dico.add "clé3","valeur3"

' numero di elementi
wscript.echo "Le dictionnaire a " & dico.count & " éléments"

' elenco delle chiavi
wscript.echo "liste des clés"
cles=dico.keys
For i=0 To ubound(cles)
  wscript.echo cles(i)
Next

' elenco dei valori
wscript.echo "liste des valeurs"
valeurs=dico.items
For i=0 To ubound(valeurs)
  wscript.echo valeurs(i)
Next

' elenco delle chiavi e dei valori
wscript.echo "liste des clés et valeurs"
cles=dico.keys
For i=0 To ubound(cles)
  wscript.echo "dico(" & cles(i) & ")=" & dico.item(cles(i))
Next

' ricerca di elementi
' chiave1
If dico.exists("clé1") Then
    wscript.echo "La clé clé1 existe dans le dictionnaire et la valeur associée est " & dico.item("clé1")
  Else
    wscript.echo "La clé clé1  n'existe pas dans le dictionnaire"
  End If
' chiave4  
If dico.exists("clé4") Then
    wscript.echo "La clé clé4 existe dans le dictionnaire et la valeur associée est " & dico.item("clé4")
  Else
    wscript.echo "La clé clé4  n'existe pas dans le dictionnaire"
  End If

' rimuove la chiave 1
dico.remove("clé1")

' elenco delle chiavi e dei valori
wscript.echo "liste des clés et valeurs après suppression de clé1"
cles=dico.keys
For i=0 To ubound(cles)
  wscript.echo "dico(" & cles(i) & ")=" & dico.item(cles(i))
Next

' si elimina tutto
dico.removeall

' elenco delle chiavi e dei valori
wscript.echo "liste des clés et valeurs après suppression de tous les éléments"
cles=dico.keys
For i=0 To ubound(cles)
  wscript.echo "dico(" & cles(i) & ")=" & dico.item(cles(i))
Next

' fine
wscript.quit 0

Risultati

Le dictionnaire a 3 éléments
liste des clés
clé1
clé2
clé3
liste des valeurs
valeur1
valeur2
valeur3
liste des clés et valeurs
dico(clé1)=valeur1
dico(clé2)=valeur2
dico(clé3)=valeur3
La clé clé1 existe dans le dictionnaire et la valeur associée est valeur1
La clé clé4  n'existe pas dans le dictionnaire
liste des clés et valeurs après suppression de clé1
dico(clé2)=valeur2
dico(clé3)=valeur3
liste des clés et valeurs après suppression de tous les éléments

3.19. Ordinare un array o un dizionario

È frequente voler ordinare un array o un dizionario in ordine crescente o decrescente in base ai valori o, nel caso di un dizionario, alle chiavi. Sebbene nella maggior parte dei linguaggi esistano funzioni di ordinamento, sembra che in VBScript non ce ne siano. Si tratta di una lacuna.

3.20. Gli argomenti di un programma

È possibile richiamare un programma VBScript passando dei parametri, come nel seguente esempio:

cscript prog1.vbs arg1 arg2 .... argn

Ciò consente all’utente di passare informazioni al programma. In che modo quest’ultimo le recupera? Esaminiamo il seguente programma:

Programma	Risultati
	`C:\>cscript arg1.vbs a b c Il y a 3 arguments a b c`

Commenti

WScript.Arguments è la raccolta degli argomenti passati allo script
una collezione C è un oggetto che possiede
- una proprietà count che rappresenta il numero di elementi nella collezione
- un metodo C(i) che restituisce l'elemento i della collezione

3.21. Una prima applicazione: IMPOTS

Ci proponiamo di scrivere un programma che consenta di calcolare l’imposta di un contribuente. Consideriamo il caso semplificato di un contribuente che abbia da dichiarare solo il proprio stipendio:

si calcola il numero di quote del dipendente nbParts=nbEnfants/2 +1 se non è sposato, nbEnfants/2+2 se è sposato, dove nbEnfants è il numero dei suoi figli.
si calcola il suo reddito imponibile R=0,72*S, dove S è il suo stipendio annuale
si calcola il suo coefficiente familiare Q = R/N

si calcola la sua imposta I in base ai seguenti dati

12620,0	0	0
13.190	0,05	631
15640	0,1	1290,5
24.740	0,15	2072,5
31810	0,2	3309,5
39.970	0,25	4900
48360	0,3	6898,5
55790	0,35	9316,5
92.970	0,4	12106
127.860	0,45	16754,5
151250	0,50	23147,5
172.040	0,55	30710
195.000	0,60	39312
0	0,65	49.062

Ogni riga contiene 3 campi. Per calcolare l'imposta I, si cerca la prima riga in cui QF ≤ campo1. Ad esempio, se QF = 30000, si troverà la riga

    24740        0.15        2072.5

L'imposta I è quindi pari a 0,15*R - 2072,5*nbParts. Se QF è tale che la relazione QF<=campo1 non è mai soddisfatta, allora vengono utilizzati i coefficienti dell’ultima riga. In questo caso:

    0                0.65        49062

il che dà l'imposta I=0,65*R - 49062*nbParts.

Il programma è il seguente:

Programma

' calcolo dell'imposta di un contribuente
' il programma deve essere richiamato con tre parametri: coniugato, figli, stipendio
' coniugato: carattere O se coniugato, N se non coniugato
' figli: numero di figli
' stipendio: stipendio annuo senza i centesimi

' non viene effettuata alcuna verifica della validità dei dati, ma
' si verifica che ce ne siano effettivamente tre

' dichiarazione obbligatoria delle variabili
Option Explicit

' si verifica che ci siano 3 argomenti
Dim nbArguments
nbArguments=wscript.arguments.count
If nbArguments<>3 Then
    wscript.echo "Syntaxe : pg marié enfants salaire"
    wscript.echo "marié : caractère O si marié, N si non marié"
    wscript.echo "enfants : nombre d'enfants"
    wscript.echo "salaire : salaire annuel sans les centimes"
     ' interruzione con codice di errore 1
    wscript.quit 1
End If

' si recuperano gli argomenti senza verificarne la validità
Dim marie, enfants, salaire
If wscript.arguments(0) = "O" Or wscript.arguments(0)="o" Then
    marie=true
Else
    marie=false
End If
' «enfants» è un numero intero
enfants=cint(wscript.arguments(1))
' «salaire» è un numero intero lungo
salaire=clng(wscript.arguments(2))

' si definiscono i dati necessari al calcolo dell'imposta in 3 tabelle
Dim limites, coeffn, coeffr
limites=array(12620,13190,15640,24740,31810,39970,48360, _
55790,92970,127860,151250,172040,195000,0)
coeffr=array(0,0.05,0.1,0.15,0.2,0.25,0.3,0.35,0.4,0.45, _
0.5,0.55,0.6,0.65)
coeffn=array(0,631,1290.5,2072.5,3309.5,4900,6898.5,9316.5, _
12106,16754.5,23147.5,30710,39312,49062)

' si calcola il numero di quote
Dim nbParts
If marie=true Then
    nbParts=(enfants/2)+2
Else
    nbParts=(enfants/2)+1
End If
If enfants>=3 Then nbParts=nbParts+0.5

' si calcolano il quoziente familiare e il reddito imponibile
Dim revenu, qf
revenu=0.72*salaire
qf=revenu/nbParts

' si calcola l'imposta
Dim i, impot
i=0
Do While i<ubound(limites) And qf>limites(i)
    i=i+1
Loop
impot=int(revenu*coeffr(i)-nbParts*coeffn(i))

' viene visualizzato il risultato
wscript.echo "impôt=" & impot

' si esce senza errori
wscript.quit 0

Risultati

C:\>cscript impots1.vbs o 2 200000

impôt=22504

C:\>cscript impots1.vbs o 2 20000

impôt=0

C:\>cscript impots1.vbs o 2 2000000

impôt=746064

C:\>cscript impots1.vbs n 2 200000

impôt=33388

C:\>cscript impots1.vbs n 3 200000

impôt=22504

C:\>cscript impots1.vbs

Syntaxe : pg marié enfants salaire
marié : caractère O si marié, N si non marié
enfants : nombre d'enfants
salaire : salaire annuel sans les centimes

Commenti:

il programma utilizza quanto illustrato in precedenza (dichiarazione delle variabili, argomenti, cambi di tipo, test, cicli, array in un variant)
non verifica la validità dei dati, cosa che sarebbe anomala in un programma reale
Solo il ciclo while presenta una difficoltà. Esso cerca di determinare l'indice i dell'array limites per il quale si ha limites(i)>qf, e questo per i<ubound(limites) (c.a.d. Qui i<13) poiché l'ultimo elemento dell'array limites non è rilevante. È stato aggiunto esclusivamente per consentire l’esecuzione del test [Do While i<ubound(limites) And qf>limites(i)] per i=13. Il test è quindi 13<13 e qf>limites(13) e occorre quindi (in VBScript) che limites(13) esista. All'uscita dal ciclo while, l'ultimo valore calcolato di i consente di calcolare l'imposta: [impot=int(revenu*coeffr(i)-nbParts*coeffn(i))].