Come posso grep per le righe che contengono una delle due parole, ma non entrambe?

Sto cercando di usare grepper mostrare solo le righe contenenti una delle due parole, se solo una di esse appare nella riga, ma non se si trovano nella stessa riga.

Finora ci ho provato grep pattern1 | grep pattern2 | ...ma non ho ottenuto il risultato che mi aspettavo.

Uno strumento diverso da quello grepè la strada da percorrere.

Usando perl, ad esempio, il comando sarebbe:

perl -ne 'print if /pattern1/ xor /pattern2/'

perl -neesegue il comando dato su ciascuna riga di stdin, che in questo caso stampa la riga se corrisponde /pattern1/ xor /pattern2/, o in altre parole corrisponde a un modello ma non all'altro (esclusivo o).

Questo funziona per il modello in entrambi gli ordini e dovrebbe avere prestazioni migliori rispetto a più invocazioni di grep, ed è anche meno digitante.

O, ancora più breve, con awk:

awk 'xor(/pattern1/,/pattern2/)'

o per le versioni di awk che non hanno xor:

awk '/pattern1/+/pattern2/==1`

Con GNU grep, è possibile passare entrambe le parole a, grepquindi rimuovere le righe contenenti entrambi i motivi.

$ cat testfile.txt
abc
def
abc def
abc 123 def
1234
5678
1234 def abc
def abc

$ grep -w -e 'abc' -e 'def' testfile.txt | grep -v -e 'abc.*def' -e 'def.*abc'
abc
def

Prova con egrep

egrep  'pattern1|pattern2' file | grep -v -e 'pattern1.*pattern2' -e 'pattern2.*pattern1'

Con grepimplementazioni che supportano espressioni regolari simili a perl (like pcregrepo GNU o ast-open grep -P), puoi farlo in unagrep chiamata con:

grep -P '^(?=.*pat1)(?!.*pat2)|^(?=.*pat2)(?!.*pat1)'

Cioè trova le linee che corrispondono pat1ma non pat2, o pat2nopat1 .

(?=...)e (?!...)sono rispettivamente operatori del futuro e del futuro. Quindi tecnicamente, quanto sopra cerca l'inizio del soggetto ( ^) a condizione che sia seguito da .*pat1e non seguito da .*pat2, o lo stesso conpat1 e pat2invertito.

Questo non è ottimale per le linee che contengono entrambi i modelli come verrebbero ricercate due volte. È possibile invece utilizzare operatori perl più avanzati come:

grep -P '^(?=.*pat1|())(?(1)(?=.*pat2)|(?!.*pat2))'

(?(1)yespattern|nopattern)corrisponde a yespatternse il gruppo di acquisizione della 1^st (vuoto ()sopra) corrisponde e in caso nopatterncontrario. Se ()corrisponde, significa pat1che non corrisponde, quindi cerchiamo pat2(sguardo positivo in avanti) e cerchiamo non pat2 altrimenti (negativo sguardo al futuro).

Con sed, potresti scriverlo:

sed -ne '/pat1/{/pat2/!p;d;}' -e '/pat2/p'

In termini booleani, stai cercando A xor B, che può essere scritto come

(A e non B)

o

(B e non A)

Dato che la tua domanda non menziona il fatto che sei interessato all'ordine dell'output fintanto che vengono mostrate le linee corrispondenti, l'espansione booleana di A xor B è dannatamente semplice in grep:

$ cat << EOF > foo
> a b
> a
> b
> c a
> c b
> b a
> b c
> EOF
$ grep -w 'a' foo | grep -vw 'b'; grep -w 'b' foo | grep -vw 'a';
a
c a
b
c b
b c

Per il seguente esempio:

# Patterns:
#    apple
#    pear

# Example line
line="a_apple_apple_pear_a"

Questo può essere fatto esclusivamente con grep -E, uniqe wc.

# Grep for regex pattern, sort as unique, and count the number of lines
result=$(grep -oE 'apple|pear' <<< $line | sort -u | wc -l)

Se grepviene compilato con le espressioni regolari Perl, puoi abbinare l'ultima occorrenza invece di dover reindirizzare a uniq:

# Grep for regex pattern and count the number of lines
result=$(grep -oP '(apple(?!.*apple)|pear(?!.*pear))' <<< $line | wc -l)

Emetti il ​​risultato:

# Only one of the words exists if the result is < 2
((result > 0)) &&
   if (($result < 2)); then
      echo Only one word matched
   else
      echo Both words matched
   fi

Una fodera:

(($(grep -oP '(apple(?!.*apple)|pear(?!.*pear))' <<< $line | wc -l) == 1)) && echo Only one word matched

Se non si desidera codificare il modello, è possibile automatizzare con una funzione il montaggio con un set variabile di elementi.

Questo può anche essere fatto in modo nativo in Bash come una funzione senza pipe o processi aggiuntivi, ma sarebbe più coinvolto ed è probabilmente al di fuori dell'ambito della tua domanda.