Argthtjtr

A tool other than grep is the way to go.

Using perl, for instance, the command would be:

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

perl -ne runs the command given over each line of stdin, which in this case prints the line if it matches /pattern1/ xor /pattern2/, or in other words matches one pattern but not the other (exclusive or).

This works for the pattern in either order, and should have better performance than multiple invocations of grep, and is less typing as well.

Or, even shorter, with awk:

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

or for versions of awk that don't have xor:

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

With GNU grep, you could pass both words to grep and then remove the lines containing both the patterns.

$ 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

Try with egrep

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

In Boolean terms, you're looking for A xor B, which can be written as

(A and not B)

or

(B and not A)

Given that your question doesn't mention that you are concerned with the order of the output so long as the matching lines are shown, the Boolean expansion of A xor B is pretty darn simple 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

With grep implementations that support perl-like regular expressions (like pcregrep or GNU grep -P), you can do it in one grep invocation with:

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

That is find the lines that match pat1 but not pat2, or pat2 but not pat1.

(?=...) and (?!...) are respectively look ahead and negative look ahead operators. So technically, the above looks for the beginning of the subject (^) provided it's followed by .*pat1 and not followed by .*pat2, or the same with pat1 and pat2 reversed.

That's suboptimal for lines that contain both patterns as they would then be looked for twice. You could instead use more advanced perl operators like:

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

(?(1)yespattern|nopattern) matches against yespattern if the 1^st capture group (empty () above) matched, and nopattern otherwise. If that () matches, that means pat1 didn't match, so we look for pat2 (positive look ahead), and we look for not pat2 otherwise (negative look ahead).

With sed, you could write it:

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

For the following example:

# Patterns:

#    apple

#    pear



# Example line

line="a_apple_apple_pear_a"

This can be done purely with grep -E, uniq, and wc.

# Grep for regex pattern, sort as unique, and count the number of lines

result=$(grep -oE 'apple|pear' <<< $line | sort -u | wc -l)

If grep is compiled with Perl regular expressions then you can match on the last occurrence instead of needing to pipe to uniq:

# Grep for regex pattern and count the number of lines

result=$(grep -oP '(apple(?!.*apple)|pear(?!.*pear))' <<< $line | wc -l)

Output the result:

# 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

A one-liner:

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

If you don't want to hard-code the pattern, assembling it with a variable set of elements can be automated with a function.

This can also be done natively in Bash as a function without pipes or additional processes but would be more involved and is probably outside the scope of your question.

Without knowing Perl or Awk or other tools, grep can also do it:

grep -e pattern1 -e pattern2 | grep -v pattern1.*pattern2

This will first select lines with either (using -e to specify each pattern), then pipe it to another grep command which filters out (-v is inverse matching) any lines containing pattern2 after pattern1.

If you want, you can add another pipe with | grep -v pattern2.*pattern1 to also filter lines that contain pattern1 after pattern2.