Wie greife ich nach Zeilen, die eines von zwei Wörtern enthalten, aber nicht beide?

Ich versuche, grepnur Zeilen anzuzeigen, die eines der beiden Wörter enthalten, wenn nur eines in der Zeile erscheint, aber nicht, wenn sie sich in derselben Zeile befinden.

Bisher habe ich es versucht grep pattern1 | grep pattern2 | ..., aber nicht das erwartete Ergebnis erzielt.

Ein anderes Werkzeug als grepder richtige Weg.

Unter Verwendung von Perl wäre der Befehl beispielsweise:

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

perl -neFührt den Befehl aus, der über jede Zeile von stdin ausgegeben wird. In diesem Fall wird die Zeile gedruckt, wenn sie übereinstimmt /pattern1/ xor /pattern2/, oder mit anderen Worten , wenn sie mit einem Muster übereinstimmt, jedoch nicht mit dem anderen (exklusiv oder).

Dies funktioniert für das Muster in jeder Reihenfolge und sollte eine bessere Leistung aufweisen als mehrere Aufrufe von grepund ist auch weniger tippend.

Oder noch kürzer mit awk:

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

oder für Versionen von awk, die nicht haben xor:

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

Mit GNU grepkönnen Sie beide Wörter übergeben grepund dann die Zeilen entfernen, die beide Muster enthalten.

$ 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

Versuche es mit egrep

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

Mit grepImplementierungen, die perlähnliche reguläre Ausdrücke (wie pcregrepoder GNU oder ast-open grep -P) unterstützen, können Sie dies in einem grepAufruf tun :

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

Das heißt die Zeilen finden, die pat1aber nicht passen pat2, oder pat2doch nicht pat1.

(?=...)und (?!...)sind jeweils vorausschauende und negative vorausschauende Betreiber. Technisch betrachtet, sucht das Obige nach dem Anfang des Themas ( ^), vorausgesetzt, es wird gefolgt .*pat1und nicht gefolgt .*pat2, oder dasselbe mit pat1und pat2umgekehrt.

Das ist suboptimal für Linien, die beide Muster enthalten, da sie dann zweimal gesucht würden. Sie könnten stattdessen fortgeschrittenere Perl-Operatoren verwenden, wie:

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

(?(1)yespattern|nopattern)Übereinstimmungen mit, yespatternwenn die 1^st- Erfassungsgruppe ( ()oben leer ) übereinstimmt, nopatternandernfalls. Wenn dies ()zutrifft, bedeutet pat1dies , dass es nicht zutrifft, und wir suchen nach pat2(positiver Blick nach vorn) und wir suchen nach nichts anderem pat2 (negativer Blick nach vorn).

Mit sedkönnte man es schreiben:

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

In Booleschen Begriffen suchen Sie nach A xor B, das als geschrieben werden kann

(A und nicht B)

oder

(B und nicht A)

Da in Ihrer Frage nicht erwähnt wird, dass Sie sich mit der Reihenfolge der Ausgabe befassen, solange die übereinstimmenden Zeilen angezeigt werden, ist die Boolesche Erweiterung von A xor B in grep ziemlich einfach:

$ 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

Für das folgende Beispiel:

# Patterns:
#    apple
#    pear

# Example line
line="a_apple_apple_pear_a"

Dies kann rein mit getan werden grep -E, uniqund wc.

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

Wenn grepes mit regulären Perl-Ausdrücken kompiliert wurde, können Sie beim letzten Vorkommen eine Übereinstimmung finden, anstatt eine Pipe an uniqfolgende Stellen ausführen zu müssen :

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

Ergebnis ausgeben:

# 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

Ein Einzeiler:

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

Wenn Sie das Muster nicht hart codieren möchten, können Sie es mit einer Funktion automatisieren, indem Sie es mit einem variablen Satz von Elementen zusammensetzen.

Dies kann auch nativ in Bash als Funktion ohne Pipes oder zusätzliche Prozesse erfolgen, ist jedoch aufwändiger und liegt wahrscheinlich außerhalb des Rahmens Ihrer Frage.