Provided by: manpages-it_0.3.4-1_all bug

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.