Comment puis-je rechercher des lignes contenant l'un des deux mots, mais pas les deux?

J'essaie d'utiliser greppour afficher uniquement les lignes contenant l'un des deux mots, si un seul d'entre eux apparaît dans la ligne, mais pas s'ils sont sur la même ligne.

Jusqu'à présent, j'ai essayé, grep pattern1 | grep pattern2 | ...mais je n'ai pas obtenu le résultat escompté.

Un outil autre que greple chemin à parcourir.

En utilisant perl, par exemple, la commande serait:

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

perl -neexécute la commande donnée sur chaque ligne de stdin, qui dans ce cas imprime la ligne si elle correspond /pattern1/ xor /pattern2/, ou en d'autres termes correspond à un modèle mais pas à l'autre (exclusif ou).

Cela fonctionne pour le modèle dans l'un ou l'autre ordre, et devrait avoir de meilleures performances que les appels multiples de grep, et est également moins typé.

Ou, encore plus court, avec awk:

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

ou pour les versions d'awk qui n'ont pas xor:

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

Avec GNU grep, vous pouvez passer les deux mots à grep, puis supprimer les lignes contenant les deux motifs.

$ 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

Essayez avec egrep

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

Avec des grepimplémentations qui prennent en charge les expressions régulières de type perl (comme pcregrepou GNU ou ast-opengrep -P ), vous pouvez le faire en une seule grepinvocation avec:

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

C'est-à-dire trouver les lignes qui correspondent pat1mais paspat2 ou pat2pas pat1.

(?=...)et (?!...)sont respectivement des opérateurs d'anticipation et d'anticipation négative. Donc, techniquement, ce qui précède cherche le début du sujet ( ^) à condition qu'il soit suivi par.*pat1 et non suivi .*pat2, ou le même avec pat1et pat2inversé.

Ce n'est pas optimal pour les lignes qui contiennent les deux modèles car ils seraient ensuite recherchés deux fois. Vous pouvez utiliser à la place des opérateurs Perl plus avancés comme:

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

(?(1)yespattern|nopattern)correspond à yespatternsi le groupe de capture 1^st (vide ()ci-dessus) correspond, et nopatternsinon. Si cela ()correspond, cela signifie pat1ne correspond pas, alors nous recherchonspat2 (regard positif devant), et nous ne cherchons pas pat2 autrement (regard négatif devant).

Avec sed, vous pourriez l'écrire:

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

En termes booléens, vous recherchez A xor B, qui peut s'écrire

(A et non B)

ou

(B et non A)

Étant donné que votre question ne mentionne pas que vous vous souciez de l'ordre de sortie tant que les lignes correspondantes sont affichées, l'expansion booléenne de A xor B est assez 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

Pour l'exemple suivant:

# Patterns:
#    apple
#    pear

# Example line
line="a_apple_apple_pear_a"

Cela peut être fait uniquement avec grep -E, uniqet 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 grep est compilé avec des expressions régulières Perl, vous pouvez faire correspondre la dernière occurrence au lieu de devoir diriger vers uniq:

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

Sortez le résultat:

# 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

Un one-liner:

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

Si vous ne voulez pas coder en dur le modèle, son assemblage avec un ensemble variable d'éléments peut être automatisé avec une fonction.

Cela peut également être fait nativement dans Bash en tant que fonction sans canaux ni processus supplémentaires, mais serait plus impliqué et est probablement hors de portée de votre question.