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)