Come posso grep per più pattern con pattern con un carattere pipe?

Voglio trovare tutte le righe in diversi file che corrispondono a uno dei due modelli. Ho provato a trovare gli schemi che sto cercando digitando

grep (foo|bar) *.txt

ma la shell la interpreta |come una pipe e si lamenta quando barnon è un eseguibile.

Come posso grep per più pattern nello stesso set di file?

Innanzitutto, è necessario proteggere il pattern dall'espansione della shell. Il modo più semplice per farlo è quello di racchiuderlo tra virgolette singole. Le virgolette singole impediscono l'espansione di qualsiasi cosa tra loro (comprese le barre rovesciate); l'unica cosa che non puoi fare allora è avere singole virgolette nel modello.

grep 'foo*' *.txt

Se hai bisogno di una virgoletta singola, puoi scriverla come '\''(letterale stringa finale, virgoletta letterale, letterale stringa aperta).

grep 'foo*'\''bar' *.txt

In secondo luogo, grep supporta due sintassi per i pattern. La vecchia sintassi predefinita ( espressioni regolari di base ) non supporta l' |operatore alternation ( ), anche se alcune versioni lo hanno come estensione, ma scritto con una barra rovesciata.

grep 'foo\|bar' *.txt

Il modo portatile è usare la sintassi più recente, espressioni regolari estese . Devi selezionare l' -Eopzione grepper selezionarla. Su Linux, puoi anche digitare egrepinvece di grep -E(su altri unices, puoi renderlo un alias).

grep -E 'foo|bar' *.txt

Un'altra possibilità quando stai solo cercando uno dei diversi modelli (invece di costruire uno schema complesso usando la disgiunzione) è passare più schemi a grep. Puoi farlo precedendo ogni modello con l' -eopzione.

grep -e foo -e bar *.txt

egrep "foo|bar" *.txt

o

grep "foo\|bar" *.txt
grep -E "foo|bar" *.txt

citando selettivamente la pagina man di gnu-grep:

   -E, --extended-regexp
          Interpret PATTERN as an extended regular expression (ERE, see below).  (-E is specified by POSIX.)

Matching Control
   -e PATTERN, --regexp=PATTERN
          Use PATTERN as the pattern.  This can be used to specify multiple search patterns, or to protect  a  pattern
          beginning with a hyphen (-).  (-e is specified by POSIX.)

(...)

   grep understands two different versions of regular expression syntax: “basic” and “extended.”  In  GNU grep,  there
   is  no  difference  in  available  functionality  using  either  syntax.   In  other implementations, basic regular
   expressions are less powerful.  The following description applies to extended regular expressions; differences  for
   basic regular expressions are summarized afterwards.

All'inizio non ho letto più, quindi non ho riconosciuto le sottili differenze:

Basic vs Extended Regular Expressions
   In basic regular expressions the meta-characters ?, +, {, |, (, and ) lose their special meaning; instead  use  the
   backslashed versions \?, \+, \{, \|, \(, and \).

Ho sempre usato egrep e inutilmente le parentesi, perché ho imparato dagli esempi. Ora ho imparato qualcosa di nuovo. :)

Come detto TC1, -Fsembra essere un'opzione utilizzabile:

$> cat text
some text
foo
another text
bar
end of file

$> patterns="foo
bar" 

$> grep -F "${patterns}" text
foo
bar

Innanzitutto, è necessario utilizzare le virgolette per caratteri speciali. In secondo luogo, anche così, grepnon capiranno direttamente l'alternanza; dovresti usare egrep, o ( grepsolo con GNU ) grep -E.

egrep 'foo|bar' *.txt

(Le parentesi non sono necessarie a meno che l'alternanza non faccia parte di una regex più grande.)

Se non hai bisogno di espressioni regolari, è molto più veloce da usare fgrepo grep -Fcon più parametri -e, come questo:

fgrep -efoo -ebar *.txt

fgrep(in alternativa grep -F) è molto più veloce del grep normale perché cerca stringhe fisse anziché espressioni regolari.

Puoi provare il comando seguente per ottenere il risultato:

egrep 'rose.*lotus|lotus.*rose' some_file

Un modo economico e allegro per sostenere più schemi:

$ echo "foo" > ewq ; echo "bar" >> ewq ; grep -H -f ewq *.txt ; rm ewq

Pipe ( |) è un carattere shell speciale, quindi deve essere escape ( \|) o quotato come da manual ( man bash):

La citazione viene utilizzata per rimuovere il significato speciale di determinati caratteri o parole dalla shell. Può essere utilizzato per disabilitare il trattamento speciale per caratteri speciali, per impedire che le parole riservate vengano riconosciute come tali e per impedire l'espansione dei parametri.

Racchiudere i caratteri tra virgolette doppie conserva il valore letterale di tutti i caratteri tra virgolette

Una barra rovesciata non quotata ( \) è il carattere di escape.

Vedi: Quali personaggi devono essere evasi in Bash?

Ecco alcuni esempi (utilizzando strumenti non ancora menzionati):

• Utilizzando ripgrep:

  • rg "foo|bar" *.txt
  • rg -e foo -e bar *.txt

• Utilizzando git grep:

  • git grep --no-index -e foo --or -e bar

    ^{Nota: supporta anche espressioni booleane come --and, --ore --not.}

Per l'operazione AND per riga, vedere: Come eseguire grep con più pattern AND?

Per l'operazione AND per file, vedere: Come verificare l'esistenza di più stringhe o regex in un file?

Avevo registri di accesso in cui le date erano stupidamente formattate: [30 / giu / 2013: 08: 00: 45 +0200]

Ma dovevo visualizzarlo come: 30 / Jun / 2013 08:00:45

Il problema è che usando "OR" nella mia dichiarazione grep, stavo ricevendo le due espressioni di corrispondenza su due righe separate.

Ecco la soluzione:

grep -in myURL_of_interest  *access.log  | \
grep -Eo '(\b[[:digit:]]{2}/[[:upper:]][[:lower:]]{2}/[[:digit:]]{4}|[[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2}\b)'   \
| paste - - -d" " > MyAccess.log

TL; DR: se vuoi fare più cose dopo aver abbinato uno dei molteplici pattern, racchiudili come in \(pattern1\|pattern2\)

esempio: voglio trovare tutti i luoghi in cui una variabile che contiene il nome 'data' è definita come una stringa o int. (ad es. "int cronDate =" o "String textFormattedDateStamp ="):

cat myfile | grep '\(int\|String\) [a-zA-Z_]*date[a-zA-Z_]* =' 

Con grep -E, non è necessario sfuggire alle parentesi o al tubo, ovverogrep -E '(int|String) [a-zA-Z_]*date[a-zA-Z_]* ='

Questo funziona per me

root@gateway:/home/sshuser# aws ec2 describe-instances --instance-ids i-2db0459d |grep 'STATE\|TAG'

**STATE**   80      stopped

**STATE**REASON     Client.UserInitiatedShutdown    Client.UserInitiatedShutdown: User initiated shutdown

**TAGS**    Name    Magento-Testing root@gateway:/home/sshuser#

Esistono diversi modi per farlo.

1. grep 'foo\|bar' *.txt
2. egrep 'foo|bar' *.txt
3. find . -maxdepth 1 -type f -name "*.txt" | xargs grep 'foo\|bar'
4. find . -maxdepth 1 -type f -name "*.txt" | xargs egrep 'foo|bar'

La terza e la quarta opzione verranno visualizzate solo nei file ed eviteranno che le directory abbiano i .txtloro nomi.
Quindi, come per il tuo caso d'uso, puoi utilizzare una delle opzioni sopra menzionate.
Grazie!!

da aggiungere alla risposta di @ geekosaur , se si hanno più motivi che contengono anche schede e spazio, utilizzare il comando seguente

grep -E "foo[[:blank:]]|bar[[:blank:]]"

dove [[:blank:]]è la classe di caratteri RE che rappresenta uno spazio o un carattere di tabulazione