Newsgroup: it.comp.lang.perl
Titolo: gruppi nelle regex

Ciao
ho la seguente stringa: CN=AAAA,CN=BBBB e gli sto applicando
la seguente espressione regolare:
([a-zA-Z]+=[a-zA-Z]+\W*){2}
Quello che vorrei ottenere sono 2 gruppi CN=AAAA ed CN=BBBB
in realta' ottengo sempre:
   gruppo(0) = CN=AAAA,CN=BBBB
   gruppo(1) = CN=BBBB
 come faccio ad ottenere 3 gruppi:
    gruppo(0) = CN=AAAA,CN=BBBB
    gruppo(1) = CN=AAAA
    gruppo(2) = CN=BBBB
 se aggiungo un altro pezzo alla mia stringa di partenza
       es  (CN=AAAA,CN=BBBB,CN=CCCC):
 ottengo:
     gruppo(0) = CN=AAAA,CN=BBBB,CN=CCCC
     gruppo(1) = CN=CCCC
 so che il primo gruppo (0) comprende tutta la stringa ma mi aspetto
 vi sia un modo per ottenere la separazione secondo quanto definito
 nella espressione regolare.
Spero di essermi spiegato in modo corretto.
bye

 nella espressione regolare.
Veramente no, "gruppo (0)" non si capisce che cosa sia (potrebbe essere una
chiamata di funzione, che evidentemente non è); un array si scriverebbe
$gruppo[0], e conterrebbe presumibilmente il primo gruppo ($1); $0 contiene
il nome del programma, non tutta la stringa, che è in $&...
Infine, ovviamente, OTTIENI la separazione definita nell'espressione
regolare, è l'espressione regolare che non definisce la separazione che
vorresti tu. Il moltiplicatore impone una restrizione sul match
complessivo, e viene raccolto il secondo gruppo che soddisfa il match di
gruppo.
Puoi fare:
     $stringa = "CN=AAAA,CN=BBBB"; 
     @gruppi = ($stringa =~ /([a-z]+=[a-z]+)\W*/ig);
ma in realtà, se le stringhe hanno le specifiche che hai detto, non si
capisce perché tu non faccia:
     @gruppi = split($stringa, ',');
Ciao.

     @gruppi = split($stringa, ',');
      @gruppi = split(/,/, $stringa);
 
Ciao.

Ciao e grazie per la tua risposta.
Avevo iniziato ad utilizzare la mia regex in java, dove ho trovato il
concetto di gruppo:
 ([a-zA-Z]+=[a-zA-Z]+\W*){2}
La mia regex, sembrava essere  indicata con la stringa in input:
CN=AAAA,CN=BBBB"
Inoltre avevo trovato metodi che ritornanavano esattamente i gruppi che
avevano avuto un match con la stringa in input:
gruppo(0) = CN=AAAA,CN=BBBB
gruppo(1) = CN=AAAA
gruppo(2) = CN=BBBB
Pensavo che il concetto di gruppo valesse anche in Perl, ma se dici
cos'e' gruppo(0)  credo proprio non sia cosi'.
Grazie ancora per i tuoi preziosi suggerimenti, che condivido.
Ciao

cos'e' gruppo(0)  credo proprio non sia cosi'.
Il CONCETTO di gruppo vale sì eccome anche in Perl, è proprio "gruppo(0)"
che non è Perl (sintatticamente, in Perl potrebbe essere solo una chiamata
di funzione, ed è evidente che non intendevi questo).
I gruppi vengono memorizzati nelle variabili di default $1, $2,... ${n}, o
nelle variabili definite dall'utente; e non esiste il "gruppo zero", come
quello che contiene tutto il match (come in Awk e, da quello che dici, in
Java), l'intero match è contenuto nella variabile $&.
I CONCETTI delle espressioni regolari, quindi, sono identicamente gli
stessi (del resto, hanno un'origine storica comune in entrambi i
linguaggi), e io posso anche tentare di intuire a che cosa ti riferisci, ma
se parliamo lingue diverse la comprensione non è certo facilitata, e non
avrò mai la certezza di aver intuito giusto.
L'interpretazione di questa particolare espressione regolare da parte di
Perl, poi, è a quanto sembra diversa da quella di Java e, se devo dirti la
verità, io non so spiegarti in dettaglio perché.
Entrambe le interpretazioni mi sembrano legittime, e posso solo pensare che
i due linguaggi abbiano preso arbitrariamente decisioni diverse.
Per ottenere quello che ti aspetti, si può usare questa espressione:
    /([a-z]+=[a-z]+)\W?([a-z]+=[a-z]+)\W?/i;
I due valori ricercati saranno nella variabili di gruppo $1 e $2.
Non so se sia possibile scrivere un'espressione regolare con moltiplicatori
che ottenga i medesimi risultati.
Il modo più naturale per fare il lavoro in Perl, comunque, è per fortuna
più semplice, come detto:
   @gruppo = (/([a-z]+=[a-z]+)\W*/ig);
le stringhe intercettate vengono memorizzate nelle variabili $gruppo[0],
$gruppo[1],... $gruppo[n], e l'espressione funziona per qualsiasi numero di
stringhe.
Ciao.

che contiene tutta la stringa matchata.
Sě, ci siamo chiariti da tempo.
Ciao.