Test if multiple variables are set

Question

I'd like to make sure that at a certain point of a script, after sourceing a configuration file, several variables are set and, if they are not, to stop execution, telling the user about the missing variable. I have tried

for var in $one $two $three ; do
    ...

but if for example $two is not set, the loop is never executed for $two. The next thing I tried was

for var in one two three ; do
    if [ -n ${!var} ] ; then
        echo "$var is set to ${!var}"
    else
        echo "$var is not set"
    fi
done

But if two is not set, I still get "two is set to" instead of "two is not set".

How can I make sure that all required variables are set?

Update/Solution: I know that there is a difference between "set" and "set, but empty". I now use (thanks to https://stackoverflow.com/a/16753536/3456281 and the answers to this question) the following:

if [ -n "${!var:-}" ] ; then

so, if var is set but empty, it is still considered invalid.

Answer 1

Quoting error.

if [ -n "${!var}" ] ; then

For the future: Setting

set -x

before running the code would have shown you the problem. Instead of adding that to the code you can call your script with

bash -vx ./my/script.sh

Answer 2

If you want the program stopped:

N= 
${one?var 1 is unset} 
${two:?var 2 is unset or null}
${three:+${N:?var 3 is set and not null}}

That'll do the trick. Each of the messages following the question mark is printed to stderr and the parent shell dies. Well, OK, so not each message - only one - just the first one that fails prints a message cause the shell dies. I like to use these tests like this:

( for v in "$one" "$two" "$three" ; do
    i=$((i+1)) ; : ${v:?var $i is unset or null...} 
done ) || _handle_it

I had a lot more to say about this here.

Answer 3

Only thing you need are quotes in your test:

for var in one two three ; do
    if [ -n "${!var}" ] ; then
        echo "$var is set to ${!var}"
    else
        echo "$var is not set"
    fi
done

Works for me.

Answer 4

A solution that is maximally friendly tests all the requirements, and reports them together, rather than failing at the first one and requiring back-and-forth to get things right:

#!/bin/bash

required_vars=(one two three)

missing_vars=()
for i in "${required_vars[@]}"
do
    test -n "${!i:+y}" || missing_vars+=("$i")
done
if [ ${#missing_vars[@]} -ne 0 ]
then
    echo "The following variables are not set, but should be:" >&2
    printf ' %q\n' "${missing_vars[@]}" >&2
    exit 1
fi

I use an array variable to track which variables haven't been set, and use the result to compose a user-facing message.

Notes:

• I quoted ${required_vars[@]} in the for loop mainly out of habit - I wouldn't advise including any shell metacharacters in your variable names!
• I didn't quote ${#missing_vars[@]}, because that's always an integer, even if you are perverse enough to disregard the preceding advice.
• I used %q when printing; %s would normally be sufficient.
• Error output always goes to the error stream with >&2, so it doesn't get piped to downstream commands
• Silence is golden - don't print progress information or debugging info unless specifically asked. That makes errors more obvious.

Answer 5

You can add

set -u

to the beginning of your script to make it terminate when it tries to use an unset variable.

A script like

#!/bin/sh
set -u
echo $foo

will result in

script.sh: 3: script.sh: foo: parameter not set

If you're using bash instead, the error will look like this:

script.sh: line 3: foo: unbound variable

Answer 6

I think if you mean not set, so the variable must never be initialized. If you use [ -n "${!var}" ], so the empty variable like two="" will be failed, while it is set. You can try this:

one=1
three=3

for var in one two three; do
  declare -p $var > /dev/null 2>&1 \
  && printf '%s is set to %s\n' "$var" "${!var}" \
  || printf '%s is not set\n' "$var"
done

Answer 7

bash 4.2 lets you test if a variable is set with the -v operator; an unset variable and a variable set to the empty string are two different conditions:

$ unset foo
$ [[ -v foo ]] && echo foo is set
$ [[ -z "$foo" ]] && echo foo is empty
foo is empty
$ foo=
$ [[ -v foo ]] && echo foo is set
foo is set
$ [[ -z "$foo" ]] && echo foo is empty
foo is empty

Answer 8

A concise (though slightly hacky) solution, to handle the case where it's OK for the sourced script to set the variables to a null value, is to initialise the variables to some special value before sourcing the script, and then check for that value afterwards, e.g.

one=#UNSET#
two=#UNSET#
three=#UNSET#

. set_vars_script

if [[ $one$two$three == *#UNSET#* ]] ; then
  echo "One or more essential variables are unset" >&2
  exit 1
fi

Answer 9

I've extended the @mikeserv's answer.

This version takes a list of variables to check the presence of, printing the name of the missing variable and triggering a call to usage() on error.

REQD_VALUES=("VARIABLE" "FOO" "BAR" "OTHER_VARIABLE")
( i=0; for var_name in ${REQD_VALUES[@]}; do
    VALUE=${!var_name} ;
    i=$((i+1)) ; : ${VALUE:?$var_name is missing}
done ) || usage

Example output when a value is missing:

./myscript.sh: line 42: VALUE: OTHER_VARIABLE is missing

Note that you can change the variable called VALUE to an alternative name that suits your desired output better.