If ... Iif ... Select Case ... Like
Il problema
Molto spesso chi è dedito alla programmazione si imbatte in un problema legato alla comparazione di dati. Che si usi un metodo classico legato semplicemente all'ambiente VB o VBA o legato a processi che si affrontano in ambiente DAO, ADO o altro, questo è un problema che tutti, prima o poi, debbono affrontare perchè spesso i risultati ottenuti non sono quelli attesi.
Sequenza di comparazione
Se ci limitiamo a confrontare solo valori numerici o valori temporali tutto procede nel migliore dei modi. Ma se dobbiamo eseguire dei confronti tra valori alfanumerici dobbiamo fare alcune riflessioni.
Normalmente sui nostri PC la sequenza di comparazione usata è quella della codifica ASCII. La sequenza che ci aspettiamo, o che dobbiamo imparare ad aspettarci, è quindi la seguente:
"0123456789 ...... A B ... Y Z ......a b ... y z"
o, se abbiamo attivato l'opzione "CaseInsensitive" (Option Compare Text), la seguente:
"0123456789 ...... [A a] [B b] ... [Y y] [Z z]"
dove le lettere racchiuse tra parentesi quadra hanno la stessa valenza quindi sono considerate uguali e l'ordine di visualizzazione rispetta l'ordine con cui le stringhe hanno nell'elenco o tabella in esame.
In alcune macchine o in certi ambienti, tuttavia, potremmo trovare una sequenza di comparazione diversa basata su una codifica EBCDIC (Extended Binary Coded Decimal Interchange Code) che è uno schema di codificazione sviluppato da IBM sui suoi computer e di alcuni prodotti, per lo più ambienti di sviluppo per la gestione di DataBase. In questi casi, a seconda dell'ambiente in cui lavoriamo, la sequenza di comparazione usata potrebbe essere la seguente:
"a b ... y z ...... A B ... Y Z ......0123456789"
Questo è un test da eseguire per verificare la sequenza di comparazione in uso nel nostro ambiente di lavoro.
Esempio 1: Stabilire quale, tra due valori, è il maggiore
|
' Option Compare Text |
Possiamo utilizzare la routine attivando o disattivando l'istruzione Option Compare Text per lavorare sia in ambiente CaseInsensitive sia in ambiente CaseSensitive. In entrambi i casi, per utilizzare questo test, scriviamo nella celle "A1" e "B1" quel che ci pare: un carattere (maiuscolo o minuscolo), un nome (maiuscolo o minuscolo), un carattere o un numero, o qualsiasi cosa ci viene in mente.
Se nelle celle "A1" e "B1" scriviamo rispettivamente: A a avremo questo messaggio:
Per B1 = "A" e B2 = "a" avremo:
(B1 = B2) Falso - "A" non è uguale a "a"
(B1 > B2) Falso - "A" non è maggiore di "a"
(B1 < B2) Vero - "A" è minore di "a"
Se invece scriveremo: ancona Zurigo avremo:
Per B1 = "ancona" e B2 = "Zurigo" avremo:
(B1 = B2) Falso - "ancona" non è uguale a "Zurigo"
(B1 > B2) Vero - "ancona" è maggiore di "Zurigo"
(B1 < B2) Falso - "ancona" non è minore di "Zurigo"
|
Eseguire confronti |
Fatta questa premessa passiamo ora all'argomento del giorno.
Vediamo come usare e costruire delle istruzioni di comparazione usando metodi diversi per risolvere alcuni problemi che potrebbero presentarsi durante un qualsiasi nostro lavoro.
Soluzione
Sicuramente il costrutto If ... End If è il più usato. La sua sintassi è:
If Condizione Then
Istruzioni
ElseIf Condizione Then
Istruzioni
ElseIf Condizione Then
Istruzioni
Else
Istruzioni
End If
Tutte le istruzioni ElseIf - Else sono facoltative e si usano solo se si debbono verificare altre condizioni che non vengono soddisfatte dalla prima espressione. La condizione da valutare restituisce un valore Booleano: Vero o Falso.
E' anche possibile concatenare più espressioni di confronto usando gli operatori logici And, Or, ecc.
|
Ma attenzione: Occorre usare attenzione nel costruire le condizioni basate su più operatori logici in quanto è facile incorrere in errori logici (scusate il gioco di parole). Una istruzione che segue la condizione: If A = 5 And A = 9 Then ... non verrà mai eseguita in quanto non succederà mai che A possa essere contemporaneamente uguale a 5 ed a 9. In questo caso occorrerebbe usare l'operatore Or per indicare al codice di eseguire le istruzioni se A ha un valore uguale a 5 o un valore uguale a 9: If A = 5 Or A = 9 Then ... Così pure potremmo venire incontro a spiacevoli risultati in una costruzione Or. Se noi vogliamo eseguire alcune istruzioni se un dato valore è compreso entro certi limiti non possiamo scrivere: If A > 4 Or A < 11 Then ... per specificare che un dato evento si verifichi se il nostro valore è compreso tra 5 e 10 ma dovremmo scrivere una delle seguenti forme: If A > 4 And A < 11 Then ... oppure If A >= 5 And A <= 10 Then ... perchè nel primo caso, quello sbagliato, verranno eseguite delle istruzioni anche se il valore è 15. |
Trovare il valore minimo e massimo tra i valori esposti in una tabella
I confronti tra diversi valori sono alla base di qualsiasi elaborazione vogliamo compiere. Nell'esempio che mostro voglio cercare in un elenco di nomi qual'è il nome maggiore e quale il minore.
Io ho lavorato con questo elenco posto nella colonna A a partire dalla riga 3 ed ho provato di cambiare anche le lettere dei nomi da maiuscole a minuscole e viceversa
| A | |
| 3 | Michele |
| 4 | carlo |
| 5 | Franco |
| 6 | Francesco |
| 7 | GIUSEPPE |
| 8 | Giovanni |
| 9 | michele |
| 10 | Carlo |
| 11 | Alfonso |
| 12 | Zurigo |
| 13 | Zorro |
| 14 | antonio |
| 15 | zeus |
Non vi nascondo che un elenco così fatto ci rivelerà delle sorprese. Infatti ci aspetteremmo che:
come valore massimo ci venga restituito Zurigo
come valore minimo ci venga restituito antonio
Invece il risultato che ci viene mostrato sarà:
valore massimo: zeus
valore minimo: Alfonso
Questo è dovuto alla sequenza di comparazione usata dal sistema e basato sulla codifica ASCII.
Per trovare il valore massimo o minimo dei valori contenuti in una lista o in una tabella occorre che prepariamo una variabile che dovrà contenere il valore cercato. Perciò, ancor prima di iniziare la nostra ricerca, assegniamo alla variabile il primo valore che troviamo nella lista, quindi iniziamo le nostre ricerche confrontando i valori che andremo ad incontrare col valore contenuto nella nostra variabile. Se incontriamo un valore superiore (o inferiore) a questo lo sostituiamo continuando i nostri confronti coi nuovi valori contenuti nella variabile. Alla fine avremo nella variabile il valore massimo, o minimo, cercato sempre tenendo presente che il risultato ottenuto rispetterà la sequenza di comparazione implementata sulla nostra macchina e sarà influenzato dall'eventuale "CaseInsensitive" impostato con Option Compare Text).
Esempio 2: trovare il valore minimo
|
Sub TrovaMaxValStr() |
Esempio 2a: trovare il valore massimo
|
Sub TrovaMinValStr() |
Controllare se i caratteri di una stringa sono numerici o alfabetici e, se alfabetici, maiuscoli o minuscoli
Nella routine di esempio useremo tutti i componenti che si riscontrano nella sintassi completa di un costrutto If ... End If.
In questa serie di confronti verifichiamo tre situazioni e la quarta ci viene restituita per esclusione:
|
If |
i caratteri della stringa convertiti in minuscolo sono uguali agli stessi caratteri convertiti in maiuscolo LCase(Valore) = UCase(Valore) Then ... (valore numerico) |
ci troviamo di fronte ad una stringa che contiene solo numeri |
|
Else If |
i caratteri della stringa sono uguali agli stessi convertiti in Maiuscolo Valore = UCase(Valore) Then ... (non minuscoli) |
nella stringa non ci sono caratteri minuscoli |
|
Else If |
i caratteri della stringa sono uguali agli stessi convertiti in minuscolo Valore = LCase(Valore) Then ... (non maiuscoli) |
nella stringa non ci sono caratteri Maiuscoli |
|
Else |
se nessuna delle verifiche sopra effettuate è soddisfatta, per esclusione si arriva a questa conclusione |
nella stringa ci sono caratteri Maiuscoli e minuscoli |
Per eseguire questo tipo di comparazione mi appoggio alle funzioni LCase ed UCase. A seconda di come reagisce la stringa trattata con una o entrambi le funzioni possiamo dedurre quale caso ci troviamo di fronte.
Con la prima comparazione che andremo ad eseguire possiamo stabilire (anche se con un piccolo margine di errore) se la stringa è costituita da soli caratteri numerici. Il margine di errore è dato dal fatto che con i semplici controlli effettuati non c'è modo di verificare se tra i caratteri sono presenti altri caratteri come: punteggiatura, parentesi ed altri caratteri speciali. Infatti se incontro la stringa "123#456" questa verrebbe riconosciuta come numero. Per evitare anche questo errore di valutazione occorrerebbe ampliare la routine effettuando anche la seguente verifica subito dopo la prima comparazione:
messTemp = IIf(IsNumeric(Valore), Valore & " è un numero", "In " & Valore & " i caratteri sono misti")
con la quale stabiliamo che se la stringa è di tipo numerico ci troviamo di fronte ad un numero, altrimenti ci troviamo di fronte ad una stringa mista con cifre e simboli.
Esempio 3: Controllare se i caratteri di una stringa sono numerici, maiuscoli, minuscoli o entrambi
|
Sub Maiusc_o_Minusc() |
Questa funzione può essere usata in luogo di If... End If per semplici espressioni condizionali, ed è particolarmente utile quando da una valutazione ci si aspetta in risposta solo due situazioni: Vero o Falso.
Per la verità la funzione è poco conosciuta e, di conseguenza poco usata. Tuttavia in certe situazioni, dove dobbiamo scegliere solo tra due condizioni (Vero o Falso) ci risparmia la digitazione di alcune righe di istruzioni e rende più leggibile e comprensibile l'unica riga di istruzioni che andremo a scrivere.
La sintassi è semplice:
Risultato = IIF(Valutazione, EspressioneVera, EspressioneFalsa)
Se la Valutazione logica restituisce Vero, IIF () restituisce in Risultato la prima Espressione. Se la Valutazione logica restituisce Falso, IIF () restituisce in Risultato la seconda Espressione.
Per questa funzione non propongo altri esempi in quanto sarebbero ripetitivi. L'uso di questa funzione potete studiarlo tornando all' esempio 1 che ho presentato in apertura e all'esempio 3, appena qui sopra.
La variabile subMess del primo esempio dovrà contenere una delle 2 stringhe: quella evidenziata in Fucsia o quella evidenziata in Verde a seconda che la variabile A1, che in questo caso è una variabile di Tipo Boolean, sia: True o False; Vero o Falso; -1 o 0.
Anche la variabile MessTemp del secondo esempio dovrà contenere una delle 2 stringhe a seconda che il valore in esame sia di tipo numerico o meno.
|
Nel primo esempio |
||
|
subMess = IIf(B1 = B2, " è uguale a ", " non è uguale a ") |
vero se B1 è uguale a B2 |
falso se B1 non è uguale a B2 |
|
subMess = IIf(B1 > B2, " è maggiore di ", " non è maggiore di ") |
vero se B1 è maggiore di B2 |
falso se B1 non è maggiore di B2 |
|
subMess = IIf(B1 < B2, " è minore di ", " non è minore di ") |
vero se B1 è minore di B2 |
falso se B1 non è minore di B2 |
|
Nel secondo esempio |
||
|
messTemp = IIf(IsNumeric(Valore), Valore & " è un numero", "In " & Valore & " i caratteri sono misti") |
vero se valore è un dato numerico |
falso se Valore non è un dato numerico |
Invece della familiare If ... End If in certi casi risulta più pratico usare l'istruzione Select Case.
La sintassi di questo costrutto è la seguente:
Select Case espressioneprova
Case X1
[istruzioni X1]
Case X2
[istruzioni X2]
........
Case Else
[istruzionielse]
End Select
In Select Case normalmente, come espressioneprova, viene indicata una Variabile, una Cella o un qualsiasi altro oggetto che possa contenere un qualsiasi tipo di valore (casella di testo, label, ecc) che potrebbero contenere un qualsiasi valore Stringa, numerico, temporale o altro: Select Case Variabile oppure Select Case Range("A1") oppure Select Case TextBox1.
Ogni proposizione Case può contenere una o più espressioni che indicano eventuali valori che possono avere la variabile o l'oggetto esposti in Select Case
Dopo una proposizione Case può essere scritto o no un gruppo di istruzioni. Se dopo una proposizione Case si trovano delle istruzioni, queste vengono eseguite se la proposizione Case viene soddisfatta, altrimenti non succede semplicemente nulla.
La proposizione Case Else può contenere delle istruzioni da eseguire se espressioneprova non soddisfa nessuna delle proposizioni Case.
Mentre è semplice la costruzione della proposizione Case che valuta un solo valore (Case 5 oppure Case "Michele") occorre porre un po' di attenzione quando una proposizione Case deve valutare più valori o un valore restituito da un'espressione.
Nel seguente prospetto vediamo eventuali proposizioni da scrivere dopo la parola chiave Case. Questi rappresentano eventuali valori che ci aspettiamo dall'oggetto preso in esame:
|
Case 5 |
il valore 5 |
|
Case "Giovanni" |
Giovanni |
Case 9, 11, 13 |
uno dei valori descritti nell'elenco |
Case 1 To 4 |
un valore compreso tra 1 e 4 |
|
Case "A" To "Az", "a" To "az" |
un nome compreso tra A e z (maiuscoli e minuscoli) |
Case Is > MaxNumber |
un valore superiore al valore descritto |
Case Is > 20 |
come sopra |
Case 1 To 4, 7 To 9, 11, 13, Is < MaxNumber |
raggruppa tutti i casi appena visti |
Usare le celle di un foglio come pulsanti
Ovviamente questo è il caso più semplice. E' simile a quello che ho già presentato nel mese di aprile in "Le celle del foglio come pulsanti" (l'argomento si trova un po' dopo la metà dell'articolo). Ho scritto queste istruzioni nel modulo relativo al foglio 1 per svolgere altre attività se seleziono determinate celle del foglio di lavoro.
In questa routine:
rilevo l'indirizzo della cella selezionata
pongo la variabile che memorizza il valore dell'indirizzo trovato come EspressioneProva in Select Case
nelle varie proposizioni Case scrivo i valori che mi aspetto
se trovo corrispondenza tra l'indirizzo che mi aspetto e quello attuale vado ad eseguire le routines indicate nelle istruzioni. Se non c'è corrispondenza tra l'indirizzo attuale e quelli valutati non succede nulla.
L'istruzione "ActiveCell.Offset(1, 0).Select" dopo ogni proposizione Case è un opzional. Serve per spostare la selezione dalla cella attiva in una cella neutra per permettere eventualmente di usufruire dell'evento "Worksheet_SelectionChange" se si vuole selezionare nuovamente la cella che manda alla stessa routine.
Esempio 4: compiere un'azione se vengono selezionate delle determinate celle
|
Private Sub
Worksheet_SelectionChange(ByVal Target As Range) |
Cercare i nomi che iniziano con una determinata lettera
Sembra un problema semplice, ma in realtà occorre rifletterci un poco. In questo caso, senza scendere nei particolari che mi hanno spinto a questa scelta, opterei per la proposizione: Case Inizio to Fine, vale a dire controlla se il nome in esame è compreso tra un determinato nome ed un altro. Per esempio tra Bacco e Colombo (Case "Bacco" To "Colombo").
Il problema da risolvere potrebbe essere: cercare in una lista di nomi tutti i nomi che iniziano con "B". Potremmo anche affinare e suddividere il problema in tre sottoproblemi:
Cercare tutti i nomi che iniziano con la "b" minuscola
Cercare tutti i nomi che iniziano con la "B" maiuscola
Cercare tutti i nomi che iniziano con la "b" minuscola e la "B" maiuscola.
Data la perfetta sovrapponibilità dei vari costrutti ne presento solo uno nel quale si può usare di volta in volta una delle tre proposizioni Case:
Case "b" To "bz"
Case "B" To "Bz"
Case "B" To "Bz", "b" To "bz"
Questa soluzione rappresenta senz'altro la soluzione ottimale perchè nell'intervallo di parole che viene compreso nelle proposizioni è senz'altro compresa la parola "B", (babbo, baco, bene, bravo, brontolone, busta, ecc) mentre sarà senz'altro improbabile trovare parole oltre la "BZ" (sigla "BZ" di Bolzano), comunque compresa nell'intervallo "B" To "Bz".
Ci sarebbe una nota per la terza proposizione appena presentata. Per cercare tutti i nomi (maiuscoli e minuscoli) che iniziano con la lettera "B" ci verrebbe in mente una proposizione del tipo: Case "B" To "bz" che ben presto si rivelerà un fallimento. Infatti, seguendo l'ordine dei caratteri della codifica ASCII implementata nella nostra macchina, oltre ad avere un elenco di nomi che iniziano con la "B" maiuscola e la "b" minuscola, avremo anche tutti gli altri nomi che iniziano con C, D, ..., BZ.
Per rendere più versatile l'esempio, compio queste azioni:
reperisco in qualche modo il carattere (non importa se maiuscolo o minuscolo) con cui debbono iniziare i nomi che sto cercando (nell'esempio leggo il carattere da una cella: Carattere = Left(Range("F13"), 1) ). Una volta reperito il carattere:
costruisco la prima proposizione usando il maiuscolo del carattere (UCase(Carattere) ) ed aggiungendo una "z" al secondo elemento della prima proposizione (UCase(Carattere) & "z" ). Allo stesso modo costruisco anche la seconda proposizione usando il minuscolo del carattere (LCase(Carattere) ). Queste sono le tre proposizioni scritte per questa routine
Case UCase(Carattere) To UCase(Carattere) & "z", LCase(Carattere) To LCase(Carattere) & "z"
Case UCase(Carattere) To UCase(Carattere) & "z"
Case LCase(Carattere) To LCase(Carattere) & "z"
Esempio 5: cercare i nomi che iniziano con una determinata lettera
|
Sub Cerca_La_Stringa_M_m() |
Prendere una decisione in base ad un valore contenuto in una cella
Nel seguente esempio mostro come combinare tra loro vari tipi di proposizioni. L'elenco preso in esame per le nostre prove è quello mostrato qui in basso e si trova a partire dalla cella "C3"
Nel prossimo esempio controllo se:
la cella contiene uno dei numeri 9, 15, o 16
la cella contiene un numero superiore a 50 (maxValore = 50)
la cella contiene un numero compreso tra 1 e 4, tra 7 e 9, oppure uguale a 12 o 14
Se si giunge al costrutto Case Else è perchè non abbiamo trovato nessuna corrispondenza nelle valutazioni precedenti.
Esempio 5: prendere una decisione in base al valore contenuto nella cella in esame:
|
Sub Valutazione_Valore() |
|
Attenzione Nelle istruzioni sopra riportate ho volutamente inserito dei valori non congruenti e si tratta del numero 9 ripetuto nelle due proposizioni Case: Case 9, 15, 21 Case 1 To 9, 11 To 14, 16 To 21, 25, 30, 35 Applicate alla tabella qui a fianco, quando incontriamo il numero 9, risultano vere le due proposizioni, ma solo la prima verrà eseguita. Questo perchè quando, tra varie proposizioni Case, si incontra una che soddisfa la ricerca, tutte le altre non vengono più esaminate. |
|
Confronti tra valori usando l'operatore And
In un test basato sull'operatore And restituisce True se tutte le espressioni legate da And siano vere.
Penso sia di facile comprensione una valutazione usando l'operatore And in un costrutto If ... End If:
Esempio 6a: operatore And in un costrutto If ... End If: i valori in esami sono tutti maggiori ad un valore predefinito
|
Sub Costrutto_And() |
Lo stesso codice può essere modificato in un costrutto Select Case.
Si può realizzare un costrutto Select Case usando in EspressioneProva un valore booleano invece di una variabile o di un oggetto:
Select Case False oppure Select Case True.
A questo punto occorre porre attenzione a ciò che avviene nel codice.
Noi vogliamo che le tre condizioni risultino True. Ma un costrutto che si basa su una espressione Case non ce lo dirà mai. Infatti appena una delle sottoespressioni risulta True cessa la valutazione delle altre sottoespressioni e passa al blocco istruzioni. Allora sfruttiamo una caratteristica propria del costrutto Select Case. In una espressione Case le varie sottoespressioni vengono valutate solo finché una non soddisfa l'EspressioneProva di Select Case. Dopodichè ogni altra sottoespressione posta sulla stessa riga viene ignorata.
Perciò possiamo impostare l'intero costrutto Select Case su una condizione opposta a quella desiderata, cioè False. In questo modo, appena una delle sottoespressioni soddisfa l'EspressioneProva di Select Case cessa la valutazione delle altre sottoespressioni e si passa ad eseguire il relativo blocco istruzioni. Se lasciamo il blocco senza istruzioni non succede semplicemente niente (ed è quello che vogliamo). Se nessuna delle sottoespressioni soddisfa l'EspressioneProva di Select Case che è False, facciamo in modo che venga trovata una clausola Case Else ed in questa clausola scriviamo le istruzioni che vogliamo siano eseguite.
Proviamo a seguire le istruzioni passo passo. Sappiamo (o dovremmo sapere) che un test fondato su un costrutto If ... End If e sull'operatore And restituisce True solo se tutte le sottoespressioni legate dall'operatore And risultano True. Se anche una sola è False, tutto il costrutto restituisce False.
Impostiamo EspressioneProva di Select Case a False (non a True!!!): Select Case False
Proponiamo questa situazione:
Assegnamo un valore a maxValore, A1, A2, A3:
maxValore = 20
A1 = 50
A2 = 1
A3 = 25
In questo modo esaminando le varie sottoespressioni dell'espressione Case A1 > maxValore, A2 > maxValore, A3 > maxValore viene incontrata A2 > maxValore che restituisce False per cui l'EspressioneProva risulta soddisfatta e dovrebbero essere eseguite le istruzioni che seguono l'espressione Case. Ma noi vogliamo che qualcosa venga eseguito solo se le tre sottoespressioni risultino True, per cui lasceremo vuoto il blocco dedicato alle istruzioni. In questo caso non vengono eseguite nemmeno le istruzioni che seguono il Case Else.
Proponiamo quest'altra situazione:
Assegnamo un valore a maxValore, A1, A2, A3:
maxValore = 20
A1 = 50
A2 = 30
A3 = 25
In questo modo esaminando le varie sottoespressioni dell'espressione Case A1 > maxValore, A2 > maxValore, A3 > maxValore EspressioneProva non risulta soddisfatta in nessuna delle sue sottoespressioni quindi il risultato dei confronti eseguiti è True per cui si va ad eseguire il blocco di istruzioni Case Else.
Ora che tutto è chiarito (spero) possiamo vedere il seguente esempio al completo:
Esempio 6b: stesso esempio in un costrutto Select Case
|
Sub Costrutto_And() |
Confronti tra valori usando l'operatore Or
Contrariamente a quanto abbiamo appena visto un test fondato sull'operatore Or restituisce True se almeno una delle espressioni legate da Or restituisce vero.
Per l'uso dell'operatore Or abbiamo le seguenti due versioni:
Per il costrutto If ... End If
Esempio 7a: operatore Or: uno dolo dei valori in esami è maggiore ad un valore predefinito
|
Sub Costrutto_Or() |
Anche questo codice può essere trascritto in un costrutto Select Case. Dal momento che, per eseguire un blocco di istruzioni, è sufficiente che tra tutte le sottoespressioni almeno una risulti True, è possibile impostare a True l'EspressioneProva.
Se nell'espressione Case c'è almeno una sottoespressione che restituisce True viene eseguito il conseguente blocco istruzioni.
Questa che segue è la stessa routine appena vista modificata per il costrutto Select Case:
Esempio 7b:
|
Sub Costrutto_Or() |
Interessante può rivelarsi l'uso di Like. Ma vediamone subito la sintassi:
risultato = Stringa Like Pattern
E' casesensitive, cioè influenzato dalla corrente impostazione "Option Compare Text" per cui se vogliamo una corrispondenza non sensibile alle maiuscole e minuscole, dobbiamo farci aiutare dalle funzioni UCase o LCase o usare altre tecniche. Serve per verificare se una stringa contiene una determinata sottostringa (pattern = modello e, in senso lato, struttura, maschera).
In Pattern oltre ai caratteri da cercare sono inclusi alcuni caratteri speciali:
|
* |
un numero qualsiasi di caratteri |
|
? |
un singolo carattere nella posizione contraddistinta dal carattere speciale |
|
# |
una singola cifra nella posizione contraddistinta dal carattere speciale |
|
[...] |
un elenco di caratteri racchiusi tra parentesi quadre da includere nella ricerca |
|
[!...] |
un elenco di caratteri racchiusi tra parentesi quadre e preceduto da un punto esclamativo da escludere nella ricerca |
Ecco alcuni esempi
|
Richiesta: cerca una parola che: |
Pattern |
Risposta |
|
inizia con "mic" |
"mic*" |
michele, miccia, microbo, ecc |
|
finisce con "ante" |
"*ante" |
pesante, importante,dante, ecc |
|
contiene "gare" |
"*gare*" |
sigaretta, garante, navigare, ecc |
|
inizia e termina con caratteri noti, ma include caratteri ignoti |
"mi*le" |
michele, micidiale, ministeriale, ecc |
|
inizia con alcuni caratteri noti, seguito da un qualsiasi carattere e continua con altri caratteri noti |
"pa?la" |
palla, paola, panda, ecc |
Ma veniamo ora ad un esempio pratico. A volte dimentichiamo il nome completo di una persona, di un libro, o di una qualsiasi altra cosa archiviata nel nostro database, oppure vogliamo cercare un dato solo in base ad alcuni caratteri. Niente di meglio che affidarci al nostro Like.
Cerca qualcosa in base a qualche carattere noto
Nella routine è sufficiente modificare solo le istruzioni evidenziate in rosso per adattarla agli schemi di qualsiasi elenco o tabella.
Il codice è distinto in tre blocchi.
Nel primo blocco ci sono i preliminari e la verifica se nella cella G10 è stato inserito il criterio di ricerca.
Nel secondo blocco si crea il pattern inserendo un asterisco alla fine della stringa. Se vogliamo un asterisco in un'altra zona è sufficiente scriverlo nella cella G10. Es: *che*, *le, g*i, ecc.
Il terzo blocco è quello che esegue il lavoro vero e proprio. In questa fase raccolgo tutte le occorrenze che soddisfano il pattern e le memorizzo in una stringa da far visualizzare in un messaggio.
Esempio 8: Cerca qualcosa in base a qualche carattere noto
|
Sub Trova_con_Pattern() |
Cercare qualcosa usando il Pattern come maschera
Con l'aiuto di questi caratteri speciali è possibile costruire dei pattern molto interessanti.
Vista la vasta possibilità di costruire i pattern più disparati, prima di presentare qualche esempio basato su questo operatore, vediamo come costruire alcuni pattern.
|
Richiesta: cerca una parola che: |
Pattern |
Risposta |
|
sia composto da 2 caratteri e 3 cifre |
"??###" |
ab123, mi055, ecc |
|
inizia con 2 caratteri, 3 cifre e altri caratteri |
"??###*" |
ah444mic, ca324casa, ecc |
|
inizia con una delle lettere A, B, o C e termina con tre numeri |
"[a-c###] |
a234, c665, ecc |
|
inizia con una vocale, una cifra e qualsiasi altro carattere |
"[aeiuo][0-9]*" |
a2michele, o0csdf, ecc |
|
non inizia con una cifra, segue una cifra, un carattere e qualsiasi altro |
"[!0-9][0-9][A-Z]*" |
a5G#1jh |
il resto è limitato solo dalla nostra immaginazione. L'uso di questi pattern è identico a quello mostrato nella routine precedente.
Conclusioni
Abbiamo visto quattro metodi per confrontare e cercare dei valori. Con questo ho voluto mostrare come usando uno o l'altro metodo possiamo affrontare molti dei problemi riguardanti il confronto fra valori.
Buon lavoro
prelevato sul sito www.ennius.altervista.org