mjhjmtu

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

figlet() 
 command -v figlet >/dev/null && command figlet "$@"

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 '%sn' "$*"; ; fi

You can test to see if figlet exists

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

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.

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.

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.

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"

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

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