¿Cómo busco líneas que contengan una de dos palabras, pero no ambas?

Estoy tratando de usar greppara mostrar solo las líneas que contienen cualquiera de las dos palabras, si solo una de ellas aparece en la línea, pero no si están en la misma línea.

Hasta ahora lo he intentado grep pattern1 | grep pattern2 | ...pero no obtuve el resultado que esperaba.

Una herramienta que no grepsea ​​el camino a seguir.

Usando perl, por ejemplo, el comando sería:

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

perl -neejecuta el comando dado sobre cada línea de stdin, que en este caso imprime la línea si coincide /pattern1/ xor /pattern2/o, en otras palabras, coincide con un patrón pero no con el otro (exclusivo o).

Esto funciona para el patrón en cualquier orden, y debería tener un mejor rendimiento que las invocaciones múltiples de grep, y también es menos tipeado.

O, incluso más corto, con awk:

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

o para versiones de awk que no tienen xor:

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

Con GNU grep, puede pasar ambas palabras grepy luego eliminar las líneas que contienen ambos patrones.

$ 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

Probar con egrep

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

Con grepimplementaciones que admiten expresiones regulares tipo perl (like pcregrepo GNU o ast-open grep -P), puede hacerlo en una grepinvocación con:

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

Es decir, encontrar las líneas que coinciden pat1pero no pat2, o pat2no pat1.

(?=...)y (?!...)son respectivamente operadores de anticipación y de anticipación negativos. Entonces, técnicamente, lo anterior busca el comienzo del sujeto ( ^) siempre que sea seguido .*pat1y no seguido .*pat2, o lo mismo con pat1e pat2invertido.

Eso es subóptimo para las líneas que contienen ambos patrones, ya que luego se buscarían dos veces. En su lugar, podría usar operadores perl más avanzados como:

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

(?(1)yespattern|nopattern)coincide con yespatternsi el grupo de captura 1^st (vacío ()arriba) coincide, y de lo nopatterncontrario. Si esa ()partidos, eso significa que pat1no coinciden, por lo que buscamos pat2(aspecto positivo por delante), y buscamos no pat2 de otro modo (por delante aspecto negativo).

Con sed, podrías escribirlo:

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

En términos booleanos, está buscando A xor B, que se puede escribir como

(A y no B)

o

(B y no A)

Dado que su pregunta no menciona que le preocupa el orden de la salida siempre que se muestren las líneas coincidentes, la expansión booleana de A xor B es bastante simple en 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 el siguiente ejemplo:

# Patterns:
#    apple
#    pear

# Example line
line="a_apple_apple_pear_a"

Esto se puede hacer simplemente con grep -E, uniqy wc.

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

Si grepse compila con expresiones regulares de Perl, puede coincidir en la última aparición en lugar de necesitar canalizar a uniq:

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

Salida del 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

Una frase:

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

Si no desea codificar el patrón, ensamblarlo con un conjunto variable de elementos puede automatizarse con una función.

Esto también se puede hacer de forma nativa en Bash como una función sin canalizaciones o procesos adicionales, pero sería más complicado y probablemente esté fuera del alcance de su pregunta.