Newsgroup: it.comp.os.dos
Titolo: (WHS) Lezione 2: stringhe : boolean

E rieccoci a boNba, in questa lezione affronteremo ancora
l'argomento stringhe, l'equivalente dell' ECHO e le modalita'
con cui si possono passare argomenti o parametri al WS.
Ws mette a disposizione un fornito numero di funzioni
relative alle stringhe; alcune sono di sola lettura e altre
di sola modifica.
Per "sola lettura" mi riferisco a funzioni che
possono solo consultare la stringa.
Per "sola modifica" intendo che possono solo modificarla.
E' importante ricordare che per "stringa", si puo' intendere
SIA una variabile che contiene una stringa SIA una stringa
vera e propria: facciamo qualche esempio:
"CIAO"    ' Questa e' una stringa
Dim BlaBla : BlaBla = "CIAO" ' questa e' una variabile.
Se vi state domandando "Hey Hey... frena... cosa sono
quell'apostrofo e quei 2 punti ?" significa che avete buon spirito di
osservazione, prima di proseguire con le stringhe li spiego.
L'apostrofo:
[BATCH]
REM questo e' un commento
[WS]
' questo e' un commento
A differenza che nel batch che limitava l'inserimento dei commenti
dello script tramite il comando REM ad inizio riga, il WS consente di
usare il piu' pratico apostrofo in QUALSIASI punto della riga, in questo
modo si puo' commentare ogni riga dello script; esempio pratico:
Dim Messaggio        ' creo la variabile messaggio
Messaggio = "Ciao"  ' nella variabile messaggio metto "ciao"
msgbox Messaggio   ' mostro con msgbox il contenuto di messaggio
wscript.quit             ' fine
Comodo, neh ? Sappiate comunque che il REM del BATCH funziona
uguale anche in WS (rem = ' ), ma l'utilizzo di REM e' sconsigliabile
perche' confonde nella lettura del codice, lo si potrebbe scambiare
"a colpo d'occhio" per una variabile, l'apostrofo e' piu' pratico.
Attenzione: QUALSIASI cosa a destra dell'apostrofo viene
ignorata, quindi il risultato dello script seguente
msgbox "ciao" ' " a tutti" ' "belli e brutti"
e' solo "ciao", il secondo apostrofo NON "chiude" la zona di commento;
per chi conosce HTML diro' che NON equivale al <!--commento -->; in WS
e' l'andare "a capo" che determina un nuovo comando.
Il "due punti" funziona da "separatore", in pratica consente di mettere
2 comandi sulla stessa riga mantenendoli separati, anche l'uso del
"due punti" e' comunque sconsigliabile per ragioni di "pulizia" del
codice stesso.
Ah.. ma non illudetevi, quando affronteremo i cicli FOR saro' ancora
piu' pedante nel cercare di inculcarvi la "bellezza" di un codice 
strutturato :)
Torniamo alle stringhe e alle funzioni bidirezionali/lettura/solo modifica:
"CIAO"    ' Questa e' una stringa
Dim BlaBla : BlaBla = "CIAO"     ' questa e' una variabile.
La funzione Len() consente di determinare di quanti caratteri e'
composta una stringa:
MsgBox Len("Ciao")
MsgBox Len(BlaBla)
Entrambi restituiranno 4, poiche' sia la stringa "liscia" che la variabile
BlaBla sono stringhe con 4 caratteri, attenzione, uno spazio e' comunque
un carattere, quindi
MsgBox Len("Ciao ")
restituira' 5
Len() e' una funzione che restituisce il numero di caratteri
di cui e' composta una stringa.
Attenzione, Len() restituisce UN NUMERO, non una stringa.
Trim() e' di sola modifica, cioe' consente solo di modificare
una stringa, Trim() elimina gli spazi a sinistra e a destra
di una stringa, esempio:
msgbox trim("    ciao   ")
Restituira' "ciao" senza spazi; trim() considera pero'
solo gli spazi ESTREMI, non quelli "interni", quindi
msgbox trim("    ciao      a     tutti    ")
restituira'  "ciao      a     tutti". Trim() non genera errore
se non ci sono spazi da "tagliare", quindi:
msgbox trim("    ciao   ")
msgbox trim("ciao")
restituira' sempre e comunque "ciao".
Esistono anche Ltrim() e Rtrim(), a differenza di Trim()
discriminano se togliere solo gli spazi di sinistra o di destra:
msgbox trim("    ciao   ")     '    "ciao"
msgbox Ltrim("    ciao   ")    '   "ciao   "
msgbox Rtrim("    ciao   ")    '   "    ciao"
( Ltrim = Left Trim = trim a sinistra della stringa)
( Rtrim = Right Trim = trim a destra della stringa)
Mid() richiede 2 parametri, ma ne puo' usare anche 3:
Msgbox Mid("ciao",2)     ' restituisce "iao"
Msgbox Mid("ciao",2,1)  ' restituisce "i"
Msgbox Mid("ciao",2,2)  ' restituisce "ia"
Confesso che mid() e' la mia funzione preferita, quella che nel DOS
sarebbe stata una mano santa in piu' occasioni, vediamo la nel
sintassi dettaglio:
Mid ( STRINGA, PRIMO CARATTERE , NUMERO DI CARATTERI)
Usato in lettura, Mid() "estrae" da STRINGA, partendo dal
PRIMO CARATTERE, il NUMERO DI CARATTERI indicato; per
nostra fortuna non genera errore se il numero di caratteri
"estraibili" e' inferiore a quelli indicati:
Msgbox Mid("ABCD",2,2)  ' restituisce "B"
Msgbox Mid("ABCD",2,999)  ' restituisce comunque restituisce "B"
Msgbox Mid("ABCD",999,2)  ' non restituisce nulla
Msgbox Mid("ABCD",999,999)  ' non restituisce nulla
Mid() conta come PRIMO CARATTERE partendo da sinistra verso
destra, poi prosegue per il NUMERO DI CARATTERI (se usato)
andando sempre verso destra.
Nota: A differenza di VB, in WS mid NON e' "bidirezionale": e' in sola
lettura.
Per semplificare la descrizione delle altre funzioni stringa (e non solo)
faccio una parentesi per spiegare il boolean VERO o FALSO.
Vero = True =  -1
False = False = 0
Se X e' uguale a Y allora e' TRUE, altrimenti e' FALSE:
Msgbox 5 = 5   ' restituira' vero
Msgbox 5 = 6   ' restituira' falso
Oppure:
Dim X
X = -1
msgbox x = true ' restituira' vero
Ma anche:
Dim X
X = 999
msgbox x = x ' restituira' vero
Facciamoci del male:
Dim X
X = 999
msgbox (x = x) <> false ' restituira' vero
' (nota: maggioreminore significa "diverso", e' il contrario di = )
Dim X , A
X = 999
A = (x <> x)
msgbox a = false ' restituira' vero
Confusi ? :)
La faccenda del boolean e' piu' semplice di quanto appare, in realta'
basta ricordarsi che numericamente FALSO e' uguale a ZERO, VERO e'
uguale a -1; ogni condizione soddisfatta e' VERA, ogni condizione
NON soddisfatta e' FALSA, quindi comparare 2 condizioni vere da'
vero cosi' come comparare 2 condizioni false (da' sempre vero).
In pratica:
voglio che Gino vada a scuola  ' gino va.
voglio che Gino NON vada a scuola  ' gino non va'
NON voglio che Gino NON vada a scuola  ' gino va.
NON voglio che Gino vada a scuola  ' gino non va'
La faccenda del VERO = -1 e FALSO = 0  serve quando
si considera il valore booleano dei numeri; in pratica
se un numero (o una variabile) e' ZERO, cosi' come
se una stringa e' vuota, e' falso, se contiene qualcosa
e' vero.
Esempio:
Dim X, Stringa
If X then Msgbox "Ciao"           ' se X allora messaggia "ciao"
If Stringa then Msgbox "Ciao"   ' se Stringa allora messaggia "ciao"
Non succedera' NULLA, perche' X, pur esistendo, e' VUOTO, cosi' come 
Stringa.
Dim X, Stringa
X = 0   ' zero
Stringa = ""   ' doppie graffette equivale a nulla (= svuota la variabile)
If X then Msgbox "Ciao"           ' se X allora messaggia "ciao"
If Stringa then Msgbox "Ciao"   ' se Stringa allora messaggia "ciao"
Ancora, non succedera' NULLA
Dim X, Stringa
X = 555   ' un numero diverso da zero
Stringa = " "   ' uno spazio e' COMUNQUE un carattere.
If X then Msgbox "Ciao"           ' se X allora messaggia "ciao"
If Stringa then Msgbox "Ciao"   ' se Stringa allora messaggia "ciao"
Stavolta avremo 2 messaggi "ciao", ma Ocio !
If X then Msgbox "Ciao"
e' DIVERSO da
If X=true  then Msgbox "Ciao"
proprio perche' nella prima condizione chiediamo impicitamente
se X e'  diverso da false, ma nella seconda condizione chiediamo
espressamente se il VALORE di X e' uguale a TRUE, e
sappiamo che 555 non e' -1 !
Cioe' questi 3 script danno risultato IDENTICO con x diverso da zero:
If X then Msgbox "Ciao"
If X<> 0 then Msgbox "Ciao"
If X<> false then Msgbox "Ciao"
Se non e' chiaro, chiedete :)
Torniamo alle stringhe:
Le funzioni Stringa di WS sono le seguenti:
-----------------------------------------------------------------------------
Len(stringa)
Come gia' visto, restituisce il NUMERO dei caratteri di una stringa
Msgbox Len("ciao")   ' restituira' 4
-----------------------------------------------------------------------------
Instr(Inizio,Stringa1,Stringa2,confronto)
Restituisce la posizione (NUMERO), di stringa2 in stringa1 partendo
da Inizio, usando confronto (0 o 1) come metodo :
Inizio e' opzionale, se non indicato, parte dal 1mo carattere a sinistra.
confronto e' opzionale, se non indicato equivale a 0.
confronto a 0, significa che considerera' CIAO diverso da Ciao
(maiuscole e minuscole), se invece viene posto a 1 non
terra' conto della differenza di maiuscole e minuscole.
Msgbox Instr("CIAO DA ME","A") ' restituira' 3 , trovera' la A di CIAO
Msgbox Instr(4,"CIAO DA ME","A") ' restituira' 6 , trovera' la A di DA
Msgbox Instr("CIAO DA ME","a",0) ' restituira' 0 , NON trovera' la a di CIAO
                                                  '  perche' sono diverse 
(maiuscolo minuscolo)
Msgbox Instr("CIAO DA ME","a",1) ' restituira' 3 , trovera' la a di CIAO 
perche'
                                                  ' abbiamo specificato di 
ignorare la differenza
                                                  ' maiuscole minuscole
InstrRev e' uguale a Instr, ma contera' al contrario ! quindi contera'
i caratteri partendo da DESTRA, esempio:
Msgbox Instr("xxYx","Y") ' restituira' 3
Msgbox InstrRev("xxYx","Y") ' restituira' 2
-----------------------------------------------------------------------------
UCase
LCase
Queste simpatiche funzioni convertono in TUTTOMAIUSCOLO o
in tuttominuscolo, Ucase significa UPPER CASE(=maiuscolo)
Lcase significa LOWER CASE (= minuscolo)
Msgbox Lcase("Ciao a Tutti")  ' ciao a tutti
Msgbox Ucase("Ciao a Tutti")  ' CIAO A TUTTI
-----------------------------------------------------------------------------
Mid
Left
Right
Mid lo abbiamo visto, restituisce porzioni di stringa "a destra" in
base alla posizione e al numero (opzionale) di caratteri da
estrarre, Left e Right invece restituiscono rispettivamente
una porzione di caratteri a sinistra (LEFT= SINISTRA) e a
destra (RIGHT= DESTRA) della stringa in base al numero
di caratteri da estrarre indicato:
Msgbox mid("Ciao a Tutti",8)  ' Tutti
Msgbox mid("Ciao a Tutti",8,1)  ' T
Msgbox mid("Ciao a Tutti",8,2)  ' Tu
Msgbox left("Ciao a Tutti",4)  ' Ciao
Msgbox right("Ciao a Tutti",4)  ' Tutti
-----------------------------------------------------------------------------
Replace
Replace e' una simpatica canaglia, imparerete ad amarlo e ad odiarlo :)
Replace ha 3 argomenti stringa obbligatori, gli ultimi 3 numerici opzionali.
Replace (STRINGA,COSA,CON,inizio,quante volte, confronto)
Replace sostituisce in STRINGA, il COSA con il CON, si puo'
specificare da dove deve partire (conta da destra), quante volte
deve farlo e come comparare il COSA con il CON.
Msgbox Replace("A z B z C z", "z","x")    ' "A x B x C x"
Msgbox Replace("A z B z C z", "z","x", 4)    ' "A z B x C x"
Msgbox Replace("A z B z C z", "z","x", 4,1)    ' "A z B x C z"
Msgbox Replace("A z B z C z", "Z","x", 4,1,0)    ' "A z B z C z"
Msgbox Replace("A z B z C z", "Z","x", 4,1,1)    ' "A z B x C z"
Siccome i parametri numerici vanno obbligatoriamente
forniti TUTTI, non e' possibile usare
Msgbox Replace("A z B z C z", "Z","x",,,0)
Sebbene per "inizio" (da dove deve partire) si puo' mettere 1 per
obbligarlo a considerare tutta la stringa, per il "quante volte
deve farlo" bisognerebbe sapere a priori quante volte la sostituzione
va' effettuata se si vuole specificare anche di non considerare
maiuscole e minuscole, il rischio e' di specificarne troppo poche
o troppe (troppe = errore), quindi per "aggirare" il problema
si usa il -1 per indicare a Replace() che deve sostituire TUTTE
le occorrenze.
Msgbox Replace("A z B z C z", "Z","x",1,-1,1)
Ah.. una nota :) ricordate il "true" di cui abbiamo parlato ?
Ebbene, nell'esempio qui sopra potete scrivere appunto TRUE
al posto di -1.... :P
Vi avevo anticipato che avreste imparato ad amare Replace, ma
i miei poteri jedi oltre a percepire il vostro affetto per Replace
mi dicono che vi state chiedendo anche "perche' dovrei odiarlo?"
Beh... vi dico solo; provate ad immaginare un file DB3
di 5000 righe, nel quale dovete sostituire le 63 virgole delimitatori
di campo che sono a posizioni fisse con replace, sapendo che
e' un database anagrafico e quindi potreste trovare cose del tipo:
Rossi     ,Mario     , via della gerla, 4       , milano
sapendo che la virgola tra la gerla e il 4 NON va' sostituita :P
(si puo' fare, ma in questo caso col replace e' uno sbattito
assurdo, vedremo piu' avanti come farlo in modo piu' semplice).
-----------------------------------------------------------------------------
Ltrim
Rtrim
Trim
Visti sopra, Ltrim, Rtrim e Trim restituiscono la stringa
eliminando gli spazi  ripettivamente a sinistra, destra, entrambi.
Msgbox Ltrim ("   Ciao   ") '  "Ciao   "
Msgbox Rtrim ("   Ciao   ") '  "   Ciao"
Msgbox Trim("   Ciao   ") '  "Ciao"
-----------------------------------------------------------------------------
Space
Space mette spazio, se hai bisogno di spazio, chiedi aiuto a Space !
(okay.... per questa battuta siete autorizzati a picchiarmi)
La sintassi e' semplicissima:
Space(numero di spazi da restituire)
esempio:
Dim X,Y
x="tanto"
y="spazio"
msgbox x & space(50) & y
La domanda spontanea e'.... "a che diavolo serve ?"
La risposta e'.... serve!  eccome!
Torniamo al nostro bel file DB3, dobbiamo sostituire le virgole e SOLO
quelle delimitatrici con dei puntesclamativi, sappiamo che quelle da 
sostituire
sono a posizioni fisse: la prima e' all' 11mo carattere, la seconda al 21mo
la terza al 31mo e cosi' via; giustamente visto che frulliamo il file 
vogliamo
anche metterlo in ordine, quindi se la segretaria oca ha scritto
     rossi
nel campo "cognome" con quei brutti spazi all'inizio, e noi abbiamo il
nostro bel trim che li elimina, perche' non usarlo ?
Bene... puliremo il campo "cognome", ma il puntesclamativo DEVE
essere l'11mo carattere e lo spazio tra "rossi" e il puntesclamativo
va' riempito con 5  spazi.... come gestire la cosa, sapendo che
nel campo "cognome" potrei trovare un signor cazzaniga che di spazi
ne richiede solo 3 ? Chiediamo aiuto a Trim, Len e Space !
Dim Stringa
Stringa = "     rossi"     ' segretaria oca
Stringa = trim(stringa) ' tie !... via gli spazi brutti.
Stringa = Stringa & Space(10 - len(stringa)) & "!"
L'ultima riga:
A Stringa assegna (=) quello che gia' contiene (stringa), aggiungi (&) un 
numero
di spazi (Space) ricavato da 10 meno la lunghezza (len) di stringa, poi
aggiungi (&) il puntesclamativo (!)
-----------------------------------------------------------------------------
String
String e' simile a space, ma inserisce per N volte il carattere indicato:
Msgbox String(10,"A") ' AAAAAAAAA
Msgbox String(10,"AB") ' AAAAAAAAA
Nel secondo esempio, la "B" di "AB" NON conta, e' il PRIMO carattere
indicato che viene considerato, ovvio e' che
Msgbox "pippo" & String(10," ") & "pluto"
Msgbox "pippo" & Space(10) & "pluto"
ottengo lo stesso risultato, dato che ho usato lo spazio come carattere
da ripetere, esattamente come avrebbe fatto Space(), ma Space produce
solo spazi.
String ha anche una simpatica caratteristica, puo' produrre QUALSIASI
carattere anche se fornito numericamente, in questo ultimo caso
si puo' fare riferimento alle tabelle ASCII; in ascii il carattere n. 65 e'
la A maiuscola:
Msgbox String(10,"A") ' AAAAAAAAA
Msgbox String(10, 65) ' AAAAAAAAA
Provate a usare il carattere che corrisponde all' "invio": il 13
Msgbox "ciao" & String(10, 13)  & "anche in fondo"
-----------------------------------------------------------------------------
StrReverse
StrReverse e' per gli amanti dello strano, rovescia le stringhe.. a che
serva in concreto ancora non lo so :)
MsgBox StrReverse("Scritto al Contrario) ' oirartnoC la ottirsC
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -  
- - - -
E qui finisce la 2nda lezione... avrei voluto affrontare nel dettaglio
anche msgbox inputbox e gli argomenti da riga di comando, ma
le forze mi stanno abbandonando e la concentrazione scarseggia..
Come sempre son graditi commenti, richieste, consigli e insulti, ma
con questi ultimi andateci piano che c'ho il cor sensibile. :)
Nella prox lezione affronteremo msgbox inputbox e gli
argomenti da riga di comando, arriveremo a dei rudimenti
di gestione file e (perforzadicose) i cicli di controllo e di
procedura, ma PRIMA di cio' vi ciuccerete una filippica
sullo scrivere codice in modo strutturato... imparare a
farlo e' una palla tremenda ma ne sarete contenti quando
debuggherete il Vs primo script un po' complicato...
Ciauz ! 

E rieccoci a boNba, in questa lezione affronteremo ancora
l'argomento stringhe, e i boolean







L'apostrofo:









Torniamo alle stringhe e alle funzioni bidirezionali/lettura/solo modifica:





MsgBox Len("Ciao ")
restituira' 5



msgbox trim("    ciao   ")




















Oppure:

Ma anche:

Facciamoci del male:


Confusi ?
La faccenda del boolean e' piu' semplice di quanto appare, in realta'

In pratica:


Esempio:



Ancora, non succedera' NULLA



e' DIVERSO da





Torniamo alle stringhe:







-----------------------------------------------------------------------------
UCase
LCase


-----------------------------------------------------------------------------
Mid
Left
Right


-----------------------------------------------------------------------------
Replace

Replace ha 3 argomenti stringa obbligatori, gli ultimi 3 numerici opzionali.
Replace (STRINGA,COSA,CON,inizio,quante volte, confronto)
Replace sostituisce in STRINGA, il COSA con il CON, si puo'
specificare da dove deve partire (conta da sinistra), quante volte
deve farlo e come comparare il COSA con il CON.
Msgbox Replace("A z B z C z", "z","x")    ' "A x B x C x"
Msgbox Replace("A z B z C z", "z","x", 4)    ' "A z B x C x"
Msgbox Replace("A z B z C z", "z","x", 4,1)    ' "A z B x C z"
Msgbox Replace("A z B z C z", "Z","x", 4,1,0)    ' "A z B z C z"
Msgbox Replace("A z B z C z", "Z","x", 4,1,1)    ' "A z B x C z"
Siccome i parametri numerici vanno obbligatoriamente
forniti TUTTI, non e' possibile usare
Msgbox Replace("A z B z C z", "Z","x",,,0)
Sebbene per "inizio" (da dove deve partire) si puo' mettere 1 per
obbligarlo a considerare tutta la stringa, per il "quante volte
deve farlo" bisognerebbe sapere a priori quante volte la sostituzione
va' effettuata se si vuole specificare anche di non considerare
maiuscole e minuscole, il rischio e' di specificarne troppo poche
o troppe (troppe = errore), quindi per "aggirare" il problema
si usa il -1 per indicare a Replace() che deve sostituire TUTTE
le occorrenze.
Msgbox Replace("A z B z C z", "Z","x",1,-1,1)
Ah.. una nota  ricordate il "true" di cui abbiamo parlato ?



-----------------------------------------------------------------------------
Ltrim
Rtrim
Trim


-----------------------------------------------------------------------------
Space


esempio:



     rossi




-----------------------------------------------------------------------------
String









-----------------------------------------------------------------------------
StrReverse

MsgBox StrReverse("Scritto al Contrario) ' oirartnoC la ottirsC
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
- - - -
E qui finisce la 2nda lezione... avrei voluto affrontare nel dettaglio
anche msgbox inputbox e gli argomenti da riga di comando, ma
le forze mi stanno abbandonando e la concentrazione scarseggia..
Come sempre son graditi commenti, richieste, consigli e insulti, ma
con questi ultimi andateci piano che c'ho il cor sensibile.
Nella prox lezione affronteremo msgbox inputbox e gli


 
immagino che ci imporrai di indentare il codice per una migliore 
leggibilit� ;)
-- 
/-\ /\/\ /\/\ /-\ /\/\ /\/\ /-\ T /-\

 sarebbe stata una mano santa in piu' occasioni,
nelle versioni recenti c'� qualcosa di simile nel comando SET:
May also specify substrings for an expansion.
    %PATH:~10,5%
would expand the PATH environment variable, and then use only the 5
characters that begin at the 11th (offset 10) character of the expanded
result.  If the length is not specified, then it defaults to the
remainder of the variable value.  If either number (offset or length) is
negative, then the number used is the length of the environment variable
value added to the offset or length specified.
    %PATH:~-10%
would extract the last 10 characters of the PATH variable.


 uguale a -1
non ho mai capito perchč -1...
1 era cosě comodo :(


1 era così comodo :(
Perché Falso è Zero.
Falso=0
Vero=not falso
msgbox Vero
-- 
Giovanni Cenati (Bergamo, Italy)
Write to "Reventlov" at katamail com
http://digilander.libero.it/Cenati
 (Esempi e programmi in VbScript)
-- 

 
già
in un mondo binario ho sempre pensato a Vero = Uno
quando c'è la terza puntata?
-- 
/-\ /\/\ /\/\ /-\ /\/\ /\/\ /-\ T /-\
http://boinc.mundayweb.com/one/stats.php?userID=2762

end
