Preventing grep from causing premature termination of "bash -e" script

Question

This script does not output after:

#!/bin/bash -e
echo "before"
echo "anything" | grep e # it would if I searched for 'y' instead
echo "after"
exit

I could solve this by removing the -e option on the shebang line, but I wish to keep it so my script stops if there is an error. I do not consider grep finding no match as an error. How may I prevent it from exiting so abruptly?

Answer 1

echo "anything" | { grep e || true; }

Explanation:

• This will throw an error

  $ echo "anything" | grep e
  $ echo $?
  1
  

• This will not throw an error

  $ echo "anything" | { grep e || true; }
  $ echo $?
  0
  

• DopeGhoti's "no-op" version (Potentially avoids spawning a process, if true is not a builtin), this will not throw an error

  $ echo "anything" | { grep e || :; }
  $ echo $?
  0
  

The || means "or". If the first part of the command "fails" (meaning grep e returns a non-zero exit code) then the part after the || is executed, succeeds and returns zero as the exit code (true always returns zero).

Answer 2

A robust way to safely and optionally grep messages:

echo something | grep e || [[ $? == 1 ]] ## print 'something', $? is 0
echo something | grep x || [[ $? == 1 ]] ## no output, $? is 0
echo something | grep --wrong-arg e || [[ $? == 1 ]] ## stderr output, $? is 1

According to posix manual, exit code:

• 1 means no lines selected.
• > 1 means an error.

Answer 3

If you're using grep with set -euo pipefail and don't want to exit if no record is found (exit code = 1), but still want it to fail if it's another exit code, you can use this:

#!/bin/bash
set -euo pipefail

echo "anything" | { grep e || test $? = 1; } | { grep e2 || test $? = 1; }

The greps inside the pipes will ONLY ignore exit status = 1. This way you don't need to lose the benefits of using set -euo pipefail.

In this example I purposely included two piped greps that could fail to illustrate the concept.

Refer to myrdd's post there.

Answer 4

Another option is to add another command to the pipeline - one that does not fail:

echo "anything" | grep e | cat

Because cat is now the last command in the pipeline, it's the exit status of cat, not of grep, that will be used to determine if the pipeline failed or not.

Answer 5

Another option:

...
set +e
echo "anything" | grep e
set -e
...

Answer 6

Solution

#!/bin/bash -e

echo "before"

echo "anything" | grep e || : # it would if I searched for 'y' instead

echo "after"
exit

Explanation

set -e or set -o errexit

Exit immediately if a pipeline (which may consist of a single simple command), a list, or a compound command (see SHELL GRAMMAR above), exits with a non-zero status. The shell does not exit if the command that fails is part of the command list immediately following a while or until keyword, part of the test following the if or elif reserved words, part of any command executed in a && or || list except the command following the final && or ||, any command in a pipeline but the last, or if the command's return value is being inverted with !. If a compound command other than a subshell returns a non-zero status because a command failed while -e was being ignored, the shell does not exit. A trap on ERR, if set, is executed before the shell exits. This option applies to the shell environment and each sub‐ shell environment separately (see COMMAND EXECUTION ENVIRONMENT above), and may cause subshells to exit before executing all the commands in the subshell.

Plus, : is the no-effect command in Bash.

Answer 7

The issue I have with most, and perhaps all the answers here, is that they are losing the true exit code ($?) and mostly returning $? as 0. There is no way to differentiate if there was a match (exit code 0) or no match (exit code 1). This solution addresses that concern:

#!/bin/bash -e
echo "before"
exit_code=0
echo "anything" | grep e || exit_code=$?; if [[ $exit_code -ne 1 ]]; then (exit $exit_code); fi
echo "after"
exit

Explained

grep's exit status is either 0, 1 or 2:

• 0 means there was a match
• 1 means there was no match
• 2 means an error occurred

Now, with the above solution:

• If grep returns 0, the test is not run and returns the true $? exit code of 0, and also sets $exit_code=0.
• If grep returns 1, the test is run and returns a fake $? exit code of 0, but we also sets $exit_code=1 which can be used by future code to differentiate a match vs no match.
• If grep returns any other value, the test is run and returns the true greater than 1 error exit code that should correctly halt the script, we also set $exit_code appropriately, but that won't matter because the script will halt.

Answer 8

Alternative: Use sed instead of grep:

echo "anything" | sed -n '/e/p'  # prints nothing
echo "anything" | sed -n '/y/p'  # prints "anything"

Explanation: sed is forced to suppress any input (-n), except to print it (p) when it matches the regex.

The return value is 0 in both cases. Works on a modern Linux and an old Solaris 8.