Como faço para grep para linhas contendo uma das duas palavras, mas não as duas?

Estou tentando usar greppara mostrar apenas linhas contendo uma das duas palavras, se apenas uma delas aparecer na linha, mas não se elas estiverem na mesma linha.

Até agora, tentei, grep pattern1 | grep pattern2 | ...mas não obtive o resultado esperado.

Uma ferramenta que não grepé o caminho a percorrer.

Usando perl, por exemplo, o comando seria:

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

perl -neexecuta o comando fornecido sobre cada linha de stdin, que nesse caso imprime a linha se corresponder /pattern1/ xor /pattern2/ou, em outras palavras, corresponde a um padrão, mas não ao outro (exclusivo ou).

Isso funciona para o padrão em qualquer ordem e deve ter um desempenho melhor do que várias invocações grepe também é menos digitado.

Ou, ainda mais curto, com awk:

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

ou para versões do awk que não possuem xor:

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

Com o GNU grep, você pode passar as duas palavras grepe remover as linhas que contêm os dois padrões.

$ 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

Tente com egrep

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

Com grepimplementações que suportam expressões regulares do tipo perl (como pcregrepou GNU ou ast-open grep -P), você pode fazer isso em uma grepchamada com:

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

Ou seja, encontrar as linhas que correspondem, pat1mas não pat2, ou pat2mas não pat1.

(?=...)e, (?!...)respectivamente, são operadores de antecipação e negativo. Portanto, tecnicamente, o item acima procura o início do assunto ( ^), desde que seja seguido .*pat1e não seguido por .*pat2, ou o mesmo com pat1e pat2invertido.

Isso é subótimo para linhas que contêm os dois padrões, pois seriam procurados duas vezes. Você poderia usar operadores perl mais avançados, como:

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

(?(1)yespattern|nopattern)corresponde contra yespatternse o grupo de captura 1^st (vazio ()acima) corresponder, ou nopatternnão. Se esse ()partidas, isso significa que pat1não se encontraram, então olhamos para pat2(olhar positivo à frente), e nós olhamos para não pat2 o contrário (em frente olhar negativo).

Com sed, você pode escrever:

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

Em termos booleanos, você está procurando A xor B, que pode ser escrito como

(A e não B)

ou

(B e não A)

Dado que sua pergunta não menciona que você está preocupado com a ordem da saída, desde que as linhas correspondentes sejam mostradas, a expansão booleana de A xor B é bastante simples no 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

Para o seguinte exemplo:

# Patterns:
#    apple
#    pear

# Example line
line="a_apple_apple_pear_a"

Isso pode ser feito puramente com 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 grepfor compilado com expressões regulares do Perl, você poderá corresponder na última ocorrência, em vez de precisar canalizar para uniq:

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

Saída do resultado:

# 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

Uma linha:

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

Se você não deseja codificar o padrão, montá-lo com um conjunto variável de elementos pode ser automatizado com uma função.

Isso também pode ser feito de forma nativa no Bash como uma função sem canais ou processos adicionais, mas estaria mais envolvido e provavelmente está fora do escopo da sua pergunta.