Newsgroup: it.comp.lang.perl
Titolo: espressioni regolari

la domanda e' semplice... e spero anche la risposta:
se volessi comparare il valore stringa di una variabile scalare con una
stringa nota farei:
$Stringa = /nota/;
se volessi pero' compararlo con il valore che asssume un altra variabile
scalare farei:
$Stringa = /$non_nota/;
Il punto e' questo: sul primo esempio riuscirei ad utilizzare le ancore ($ e
^) ma sul secondo no.
Sapete come fare?? forse un carattere di escape???
grazie mille,
asast

 le ancore ($ e ^) ma sul secondo no.
  Perche`? Ti sei mai chiesto perche` l'ancora /$/ deve essere l'ultimo
carattere in una RE? ;)
	Alla prossima,
		Marco

 Marco
Marco,
mettiamo che stessi tentando di "mappare" un array alla ricerca della
stringa corrispondente al valore che assume $stringa, faccio (e funziona):
$risultato=map /$stringa/, @array;
ma se volessi dire che il valore di $stringa deve corrispondere
*strettamente* al valore del corrispodente scalare in @array, e uso le
ancore ^ e $ non mi funge.
sto leggendo la doc ma non trovo nulla a riguardo,
se hai una soluzione fammi sapere
grazie,
asast

 ancore ^ e $ non mi funge.
Corrisponde strettamente => uso eq
Perche' usare il cannone spuntato delle RE per confrontare stringhe
costanti, quando index ed eq sono piu' efficienti?
Sul 'non funziona', sono sempre gradite dimostrazioni a base di codice vero
compilante e dati di esempio.
Maurizio
-- 
Maurizio M. Munafo' / 
mmmu...@netscape.net
"Consider Phlebas, who was once handsome and tall as you" (T.S.Eliot)

 Maurizio
Maurizio,
non e' una stringa costante.
Poi io sicuramnte non sono esperto ma stavo parlando dell'uso di map, e non
riesco a capire cosa c'entra cio' che tu mi dici...pur avendo letto tanta
doc ho sempre trovato che map si usa con =, non ho mai visto eq, ma forse
sono novellino e non ho capito cosa mi vuoi dire.
CMq, ogni aiuto sulla mia questione precedente e' gradito,
ciao,
asast


 ancore ^ e $ non mi funge. 
Ora, la definizione di map e'
      map BLOCK LIST
 
       map EXPR,LIST
               Evaluates the BLOCK or EXPR for each element of
               LIST (locally setting $_ to each element) and
               returns the list value composed of the results of
               each such evaluation.  Evaluates BLOCK or EXPR in
               a list context, so each element of LIST may
               produce zero, one, or more elements in the
               returned value.
 
               In scalar context, returns the total number of
               elements so generated. 
Quindi e' logico che $risultato contenga il numero di match ottenuti. E'
questo che vuoi?
Ora io mi invento un esempio a caso, con la tua riga di codice
@array = ('aaa','bbb','abc');
while (<DATA>)
 {
   chomp;
   $stringa = $_;
   $risultato = map /$stringa/, @array;
   print $stringa,"->",$risultato,"\n";
 }
__END__
a
aaa
^aa
b$
^abc$
e ottengo un programma che compila, esegue e mi risponde correttamente:
a->2
aaa->1
^aa->1
b$->1
^abc$->1 
La riga di codice e' quella che hai scritto tu e l'output e' quello che mi
aspetto dal codice.
Dove e' allora il problema? Non c'e', in quella tua riga di codice e nei
dati che ci hai fornito.
Se invece il tuo problema non e' quello mostrato da questo codice, devi
farci il favore di scrivere un programma di 5 righe simile al mio in cui non
ottieni il risultato che vorresti ottenere, cosi' se ne puo' discutere.
Ah, ovviamente se il risultato non e' quello che vorresti, devi anche
fornire un esempio del risultato che vorresti.
Maurizio


 questo che vuoi?
Diciamo che era una soluzione alternativa che avevo adottato, ma che si e'
rivelata fallimentare. Piuttosto stamattina (la notte porta consiglio, si
sa), ho capito (forse) che avrei dovuto utilizzarela seguente istruzione:
@risultato = grep /$stringa/, @lista;
sembra fatta al caso mio, in quanto "filtra" l'array @lista alla ricerca
della stringa contenuta in $stringa.
A questo punto assegno ad un nuovo scalare il contenuto dell' array
@risultato:
$nuova_stringa= "@risultato";
E ora vorrei controllare il flusso in base ad una *stretta corrispondenza*
tra le due stringhe contenute rispettivamente da $stringa (la prima) e
$risultato, quella ottenuta il "filtraggio" dell'array. Per questo utilizzo
le RE, ma ho dei problemi. Sperando di essere stato chiaro passo all'esempio
(da novello gradisco consigli sul codice):
il programma e' un CGI, che raccoglie da un form HTML dei dati che assegna a
variabili scalari:
use CGI;
$query = CGI::new();
$nome = $query->param("Nome");
$cognome = $query->param("Cognome");
poi, interroga un Database e popola un array con i risultati ottenuti
tramite l'istruzione:
push @lista, "$tabella[$i][$j]";                        #so che questa
variabile somiglia piu' al C che al perl, ma per
                                                                   #favore
adesso lasciamola perdere, tanto non c'entra ;-)
Adesso dovrebbe confrontare le stringhe raccolte nel form con quelle
contenute nell'array @lista (per comodita' confrontiamo solo una, tanto il
procedimento e' identico):
@cognomi = grep /$cognome/, @lista;
$verifica_cognome = "@cognomi";
#-------------punto critico: confronto
if ($verifica_cognome =~ /$cognome/)    {
                                <code>
                                   ......
                                </code>
            } else {
                <code>
                .........
                </code>
            };
Bene, mi chiederete, dove e' il problema??? Ovviamente il programma dovrebbe
continuare solo se il contenuto di $cognome corrisponde *strettamente* ad
una delle stringhe all'interno dell'array @lista.
Ad esempio, se nell'array ho:
@lista = ("rossi", "gialli", "bianchi")
Il programma dovrebbe continuare se e solo se $cognome= "rossi" (o "gialli"
o "bianchi"), mentre invece cosi' come e' scritto sopra continua anche se,
per es., $cognome="ss". E cio' non deve succedere.
Come rimediare??? mi sono detto che grep poteva essere usato con le ancore
@cognomi = grep /^$cognome$/, @lista;
ci ho provato, risultato: sintassi ok ma non si passa neanche se la stringa
e' giusta (N:B: la faccio stampare per controllare)
Oppure inserire il controllo con le ancore nel passaggio critico di if:
if ($verifica_cognome =~ /$cognome/);
stesso risultato, non si passa neanche se la stringa e' giusta.
Probabilmente sbagliero' qualcosa nella sintassi, ma non riesco a capire
cosa. Sto controllando le RE....
Spero di essere stato chiaro e ringrazio anticipatamente.
ciao,
asast

 Spero di essere stato chiaro e ringrazio anticipatamente.
Devo essere io che non sono in sintonia con te. Mi sembra che usare un array
e fare 'sti casini con grep (che e' inutile) quando potresti usare almeno un
hash e' uno spreco di energie.
Fatti un hash con i cognomi come chiave e usa quello per la ricerca.
