egrep

GREP(1)                      General Commands Manual                     GREP(1)



NOME
       grep, egrep, fgrep - stampa le righe che corrispondono ad un modello

SINTASSI
       grep [ -[[AB] ]num ] [ -[CEFGVBchilnsvwx] ] [ -e ] modello | -ffile ] [
       file...  ]

DESCRIZIONE
       Grep ricerca nei file d'ingresso indicati (o nello standard input se non
       è specificato alcun file, o è dato il nome di file -) le righe che
       contengono una corrispondenza ("match") al modello ("pattern")
       specificato.  Di default, grep mostra solo le righe in cui è trovata la
       corrispondenza.

       Ci sono tre varianti principali di grep, controllate dalle seguenti
       opzioni.
       -G     Interpreta modello come una espressione regolare base (si veda
              sotto). Questo è il comportamento di default.
       -E     Interpreta modello come una espressione regolare estesa (si veda
              sotto).
       -F     Interpreta modello come un elenco di stringhe prefissate, separate
              da newline, di ognuna delle quali deve essere cercata un'istanza.
       Inoltre, sono disponibili i due programmi alternativi egrep e fgrep.
       Egrep è simile (ma non identico) a grep -E, ed è compatibile con lo
       storico comando Unix egrep.  Fgrep è identico a grep -F.

       Tutte le varianti di grep capiscono le seguenti opzioni:
       -num   Le corrispondenze saranno stampate con le num righe precedenti e
              successive. Comunque, grep non stamperà mai una riga più di una
              volta.
       -A num Stampa anche le num righe successive alle righe in cui sono
              trovate le corrispondenze.
       -B num Stampa anche le num righe precedenti alle righe in cui sono
              trovate le corrispondenze.
       -C     Equivalente a -2.
       -V     Stampa il numero di versione di grep nello standard error. Questo
              numero di versione dovrebbe essere incluso in tutti i rapporti sui
              bachi (si veda sotto).
       -b     Stampa lo spiazzamento in byte all'interno del file d'ingresso
              prima di ognuna delle righe dell'output.
       -c     Sopprime l'output normale; stampa invece, per ognuno dei file
              d'ingresso, il numero di righe in cui è trovata la corrispondenza.
              Con l'opzione -v (si veda sotto), conta le righe che non
              corrispondono.
       -e modello
              Usa modello come modello; utile per proteggere i modelli che
              iniziano con -.
       -f file
              Ottiene il modello da file.
       -h     Sopprime la stampa dei nomi dei file in output quando la ricerca è
              fatta su più file.
       -i     Ignora le differenze tra i caratteri maiuscoli e minuscoli sia in
              modello che nei file d'ingresso.
       -L     Sopprime il normale output; stampa invece il nome di ognuno dei
              file d'ingresso dai quali normalmente non sarebbe stato stampato
              niente.
       -l     Sopprime il normale output; stampa invece il nome di ognuno dei
              file d'ingresso dai quali normalmente sarebbe stato stampato
              qualcosa.
       -n     Prefissa ogni riga dell'output con il numero di riga all'interno
              del suo file d'ingresso.
       -q     Quiet; sopprime l'output normale.
       -s     Sopprime i messaggi d'errore sui file non esistenti o non
              leggibili.
       -v     Inverte il senso della corrispondenza, per selezionare le righe
              che non corrispondono.
       -w     Seleziona solo quelle righe contenenti corrispondenze che formano
              parole intere. Il test è siffatto: la sottostringa corrispondente
              deve o essere all'inizio di una riga, o preceduta da un carattere
              che non costituisce una parola. Similmente, deve essere o alla
              fine di una riga o seguita da un carattere che non costituisce una
              parola. I caratteri che costituiscono parole sono le lettere, i
              numeri e l'underscore (`_').
       -x     Seleziona solo le corrispondenze in cui la corrispondenza è tutta
              la riga.

ESPRESSIONI REGOLARI
       Una espressione regolare ("regular expression") è un modello che descrive
       un insieme di stringhe. Le espressioni regolari sono costruite in modo
       analogo alle espressioni aritmetiche, usando diversi operatori per
       combinare espressioni più piccole.

       Grep comprende due diverse versioni di sintassi delle espressioni
       regolari: «base» e «estesa».  In GNU grep, non c'è alcuna differenza
       nelle funzionalità disponibili usando una o l'altra sintassi. In altre
       implementazioni, le espressioni regolari base sono meno potenti. La
       seguente descrizione si applica alle espressioni regolari estese; le
       differenze per le espressioni regolari base sono riassunte più avanti.

       I blocchi costituenti fondamentali sono le espressioni regolari che
       corrispondono ad un singolo carattere. La maggior parte dei caratteri,
       comprese tutte le lettere e i numeri, sono espressioni regolari che
       corrispondono a loro stessi. Qualsiasi metacarattere con un significato
       speciale può essere protetto prefissandolo con un backslash ('\').

       Una lista di caratteri racchiusi tra [ e ] permette la corrispondenza di
       qualsiasi singolo carattere in quella lista; se il primo carattere della
       lista è il caret ^ allora permette la corrispondenza con qualsiasi
       carattere che non è nella lista.  Per esempio, l'espressione regolare
       [0123456789] corrisponde ad una cifra singola qualsiasi. Un intervallo di
       caratteri ASCII può essere specificato dando il primo e l'ultimo
       carattere, separati da un trattino.  Inoltre, sono predefinite con un
       nome alcune classi di caratteri.  I loro nomi spiegano già tutto (N.d.T:
       se si è madrelingua inglese), e sono [:alnum:] (alfanumerici), [:alpha:]
       (alfabetici), [:cntrl:] (di controllo), [:digit:] (cifre), [:graph:]
       (grafici), [:lower:] (minuscoli), [:print:] (di stampa), [:punct:]
       (punteggiatura), [:space:] (spazio), [:upper:] (maiuscoli), e [:xdigit:]
       (cifre esadecimali).  Per esempio, [[:alnum:]] significa [0-9A-Za-z], ad
       eccezione che quest'ultima dipende dalla codifica ASCII dei caratteri,
       mentre la prima è portabile (si noti che le parentesi quadre nei nomi
       delle classi sono parte del nome simbolico, e devono essere incluse in
       aggiunta alle parentesi che delimitano un elenco).  La maggior parte dei
       metacaratteri perdono il loro significato speciale all'interno di un
       elenco. Per includere il carattere ] lo si posizioni per primo nella
       lista. Similmente, per includere un ^ lo si posizioni ovunque tranne che
       per primo, mentre per includere un - lo si metta per ultimo.

       Il carattere .  corrisponde ad un qualsiasi singolo carattere.  Il
       simbolo \w è un sinonimo per [[:alnum:]] e \W è un sinonimo per
       [^[:alnum]].

       Il caret ^ e il segno di dollaro $ sono metacaratteri che corrispondono
       rispettivamente alla stringa vuota all'inizio e alla fine di una riga.
       Il simboli \< e \> corrispondono rispettivamente alla stringa vuota
       all'inizio e alla fine di una parola.  Il simbolo \b corrisponde alla
       stringa vuota presente ai "bordi" di una parola, e \B corrisponde alla
       stringa vuota assicurandosi che non sia ai "bordi" di una parola.

       Una espressione regolare che corrisponde a un carattere singolo può
       essere seguita da uno dei diversi operatori di ripetizione:
       ?      Ciò che precede è opzionale e la corrispondenza può esserci al più
              una volta.
       *      La corrispondenza a ciò che precede può esserci zero o più volte.
       +      La corrispondenza a ciò che precede può esserci una o più volte.
       {n}    La corrispondenza a ciò che precede deve esserci esattamente n
              volte
       {n,}   La corrispondenza a ciò che precede deve esserci n o più volte.
       {,m}   La corrispondenza a ciò che precede deve esserci al più m volte.
       {n,m}  La corrispondenza a ciò che precede deve esserci almeno n volte,
              ma non più di m volte.

       Due espressioni regolari possono essere concatenate; l'espressione
       regolare risultante corrisponde a qualsiasi stringa formata concatenando
       due sotto stringhe che corrispondono rispettivamente alle due
       sottoespressioni che sono state concatenate.

       Due espressioni regolari possono essere riunite ("join") con l'operatore
       di "infissione" |; l'espressione regolare risultante corrisponde a
       qualsiasi stringa che corrisponde ad una delle sottoespressioni.

       La ripetizione ha precedenza sulla concatenazione, che a sua volta ha
       precedenza sull'alternanza. Un'intera sottoespressione può essere
       racchiusa tra parentesi per modificare queste regole di precedenza.

       Il riferimento all'indietro ("backreference") \n, dove n è una cifra
       singola, corrisponde alla sottostringa che in precedenza ha corrisposto
       alla n-esima sottoespressione parentesizzata dell'espressione regolare.

       Nelle espressioni regolari base i metacaratteri ?, +, {, |, (, e )
       perdono il loro significato speciale; si usino invece le versioni con
       backslash \?, \+, \{, \|, \(, e \).

       In egrep il metacarattere { perde il suo significato speciale; si usi
       invece \{.

DIAGNOSTICA
       Normalmente, lo stato d'uscita è 0 se sono state trovate delle
       corrispondenze, e 1 se non ne sono state trovate (l'opzione -v inverte il
       senso degli stati d'uscita). Lo stato d'uscita è 2 se c'era un errore di
       sintassi nel modello, se i file d'ingresso erano inaccessibili, o in caso
       di altri errori di sistema.

BACHI
       Inviare i rapporti sui bachi ("bug report") a bug-gnu-
       utils@prep.ai.mit.edu.  Assicurarsi di includere la parola «grep» da
       qualche parte nel campo «Subject:».

       Numeri di ripetizioni elevati nel costrutto {m,n} possono far sì che grep
       usi un sacco di memoria.  Inoltre, alcune altre oscure espressioni
       regolari necessitano di tempo e spazio esponenziali, e possono far sì che
       grep vada in out of memory.

       I riferimenti all'indietro sono molto lenti, e possono richiedere tempo
       esponenziale.



GNU Project                     10 settembre 1992                        GREP(1)