Linux shell script: Run a program only if it exists, ignore it if it does not exist

Question

I am programming a Linux shell script that will print status banners during its execution only if the proper tool, say figlet, is installed (this is: reachable on system path).

Example:

#!/usr/bin/env bash
echo "foo"
figlet "Starting"
echo "moo"
figlet "Working"
echo "foo moo"
figlet "Finished"

I would like for my script to work without errors even when figlet is not installed.

What could be a practical method?

Answer 1

My interpretation would use a wrapper function named the same as the tool; in that function, execute the real tool if it exists:

figlet() {
  if command -p figlet  >/dev/null 2>&1
    then 
      command figlet "$@"
    else
      :
    fi
}

Then you can have figlet arg1 arg2... unchanged in your script.

@Olorin came up with a simpler method: define a wrapper function only if we need to (if the tool doesn't exist):

if ! command -v figlet > /dev/null; then figlet() { :; }; fi

If you'd like the arguments to figlet to be printed even if figlet isn't installed, adjust Olorin's suggestion as follows:

if ! command -v figlet > /dev/null; then figlet() { printf '%s\n' "$*"; }; fi

Answer 2

You can test to see if figlet exists

if type figlet >/dev/null 2>&1
then
    echo Figlet is installed
fi

Answer 3

At the start of your script, check if figlet exists, and if it does not, define a shell function that does nothing:

type figlet >/dev/null 2>&1 || figlet() { :; }

type checks if figlet exists as a shell built-in, function, alias, or keyword, >/dev/null 2>&1 discards stdin and stdout so you don't get any output, and if it does not exist, figlet() { :; } defines figlet as a function that does nothing.

This way you don't have to edit every line of your script that uses figlet, or check if it exists every time figlet is called.

You can add a diagnostic message, if you like:

type figlet >/dev/null 2>&1 || { echo 'figlet not installed.' ; figlet() { :; } ; }

As a bonus, since you didn't mention which shell you are using, I believe this is POSIX compliant, so it should work on most any shell.

Answer 4

A common way to do this is with test -x aka [ -x. Here is an example taken from /etc/init.d/ntp on a Linux system:

if [ -x /usr/bin/lockfile-create ]; then
    lockfile-create $LOCKFILE
    lockfile-touch $LOCKFILE &
    LOCKTOUCHPID="$!"
fi

This variant relies on knowing the full path of the executable. In /bin/lesspipe I found an example which works around that by combining -x and the which command:

if [ -x "`which bunzip`" ]; then bunzip -c "$1"
else echo "No bunzip available"; fi ;;

That way this will work without knowing in advance where in the PATH the bunzip executable is.

Answer 5

Another alternative -- a pattern I've seen in project auto configure scripts:

if [ -x /usr/bin/figlet ]
then
    FIGLET=/usr/bin/figlet
else
    FIGLET=:
fi

$FIGLET "Hello, world!"

In your specific case you could even do,

if [ -x /usr/bin/figlet ]
then
   SAY=/usr/bin/figlet
elif [ -x /usr/local/bin/figlet ]
then
   SAY=/usr/local/bin/figlet
elif [ -x /usr/bin/banner ]
then
   SAY=/usr/bin/banner
else
   SAY=/usr/bin/echo
fi

$SAY "Hello, world!"

If you don't know the specific path, you can try multiple elif (see above) to try known locations, or just use the PATH to always resolve the command:

if command -v figlet >/dev/null
then
    SAY=figlet
elif command -v banner >/dev/null
then
    SAY=banner
else
    SAY=echo
fi

In general, when writing scripts, I prefer to only call commands in specific locations specified by me. I don't like the uncertainty/risk of what the end user might have put into their PATH, perhaps in their own ~/bin.

If, for example, I was writing a complicated script for others that might remove files based on the output of a particular command I'm calling, I wouldn't want to accidentally pick up something in their ~/bin that might or might not be the command I expected.

Answer 6

type -p figlet > /dev/null && figlet "foo"

The bash type command finds a command, function, alias, keyword, or builtin (see help type) and prints out the location or definition. It also returns a return code representing the result of the search; true (0) if found. So what we're doing here is trying to find figlet in the path (-p means only look for files, not built-ins or functions, and also suppresses error messages), discarding output (that's what > /dev/null does), and if it returns true (&&), it will execute figlet.

This is simpler if figlet is in a fixed location:

[ -x /usr/bin/figlet ] && /usr/bin/figlet "foo"

Here we're using the test command (a.k.a. [) to see if /usr/bin/figlet is executable (-x) and if so (&&) execute it. This solution I think is more portable than using type which is a bashism I believe.

You could make a function that does this for you:

function x() {
    if type -p "$1" >/dev/null; then
        cmd="$1"
        shift
        "$cmd" "$@"
    fi
}

(The quotes are necessary owing to potential spaces)

Then you'd just do:

x figlet "foo"

Answer 7

o/, I would say something like

#!/usr/bin/env bash
# if figlet is installed :
if [ "$(which figlet 2>/dev/null)" ]; then
       # do what you wanted to do
       echo "foo"
       figlet "Starting"
       echo "moo"
       figlet "Working"
       echo "foo moo"
       figlet "Finished"
# if not
else
       # exit program with an error
       echo "please install figlet"
       exit 1
fi

Answer 8

You can do a test execution, suppressing any output, and test success/failure code. Choose arguments to figlet to make this test inexpensive. -? or --help or --version are obvious possibilities.

if figlet --help >/dev/null 2>&1 ; then
    # figlet is available
    echo "foo"
    figlet "starting"
    #etc
else
    rc=$?
    echo "figlet is not installed or not working correctly (return code ${rc})"
fi

Added in response to comment below: if you really want to test that figlet exists, not that it's usable, then you would do

figlet --help >/dev/null 2>&1 
rc=$?
if [ $rc -eq 127 ] ; then # 127 is "command not found" on linux bash 4.4.23(1)
    echo "command figlet not found"
else
    figlet "whatever" # use figlet
fi