Assigning default values to shell variables with a single command in bash

For command line arguments:

VARIABLE="${1:-$DEFAULTVALUE}"

which assigns to VARIABLE the value of the 1st argument passed to the script or the value of DEFAULTVALUE if no such argument was passed. Quoting prevents globbing and word splitting.

If the variable is same, then

: "${VARIABLE:=DEFAULT_VALUE}"

assigns DEFAULT_VALUE to VARIABLE if not defined.

• The colon builtin (:) ensures the variable result is not executed
• The double quotes (") prevent globbing and word splitting.

Also see Section 3.5.3, Shell Parameter Expansion, in the Bash manual.

To answer your question and on all variable substitutions

echo "${var}"
echo "Substitute the value of var."
    

echo "${var:-word}"
echo "If var is null or unset, word is substituted for var. The value of var does not change."
    

echo "${var:=word}"
echo "If var is null or unset, var is set to the value of word."
    

echo "${var:?message}"
echo "If var is null or unset, message is printed to standard error. This checks that variables are set correctly."
    

echo "${var:+word}"
echo "If var is set, word is substituted for var. The value of var does not change."

You can escape the whole expression by putting a \ between the dollar sign and the rest of the expression.

echo "$\{var}"

Even you can use like default value the value of another variable

having a file defvalue.sh

#!/bin/bash
variable1=$1
variable2=${2:-$variable1}

echo $variable1
echo $variable2

run ./defvalue.sh first-value second-value output

first-value
second-value

and run ./defvalue.sh first-value output

first-value
first-value

FWIW, you can provide an error message like so:

USERNAME=${1:?"Specify a username"}

This displays a message like this and exits with code 1:

./myscript.sh
./myscript.sh: line 2: 1: Specify a username

A more complete example of everything:

#!/bin/bash
ACTION=${1:?"Specify 'action' as argv[1]"}
DIRNAME=${2:-$PWD}
OUTPUT_DIR=${3:-${HOMEDIR:-"/tmp"}}

echo "$ACTION"
echo "$DIRNAME"
echo "$OUTPUT_DIR"

Output:

$ ./script.sh foo
foo
/path/to/pwd
/tmp

$ export HOMEDIR=/home/myuser
$ ./script.sh foo
foo
/path/to/pwd
/home/myuser

• $ACTION takes the value of the first argument, and exits if empty
• $DIRNAME is the 2nd argument, and defaults to the current directory
• $OUTPUT_DIR is the 3rd argument, or $HOMEDIR (if defined), else, /tmp. This works on OS X, but I'm not positive that it's portable.

see here under 3.5.3(shell parameter expansion)

so in your case

${VARIABLE:-default}

It is possible to chain default values like so:

DOCKER_LABEL=${GIT_TAG:-${GIT_COMMIT_AND_DATE:-latest}}

i.e. if $GIT_TAG doesnt exist, take $GIT_COMMIT_AND_DATE - if this doesnt exist, take "latest"

Then there's the way of expressing your 'if' construct more tersely:

FOO='default'
[ -n "${VARIABLE}" ] && FOO=${VARIABLE}

Here is an example

#!/bin/bash

default='default_value'
value=${1:-$default}

echo "value: [$value]"

save this as script.sh and make it executable. run it without params

./script.sh
> value: [default_value]

run it with param

./script.sh my_value
> value: [my_value]

The provided answers are great but i wanted to share the following table and the bash one-liners as a summary of all what was written (feel free to enhance this summary 🤗):

summary table

the variables in shell scripting can be in 3 states:

1. assigned value (var=value)
2. null string (var='')
3. unset (unset var)

source of the first 4 lines in this table = baeldung article

Bash one-liners

To test these in the terminal i will leave bellow some bash one-liners:

# bash one liner                                # output 
# --------------                                  ------

x="foo" && echo "${x:-bar} (x = $x)"            # foo (x = foo)
x=""    && echo "${x:-bar} (x = $x)"            # bar (x = )
unset x && echo "${x:-bar} (x = $x)"            # bar (x = )

x="foo" && echo "${x-bar} (x = $x)"             # foo (x = foo)
x=""    && echo "${x-bar} (x = $x)"             #  (x = )
unset x && echo "${x-bar} (x = $x)"             # bar (x = )

x="foo" && echo "${x:=bar} (x = $x)"            # foo (x = foo)
x=""    && echo "${x:=bar} (x = $x)"            # bar (x = bar)
unset x && echo "${x:=bar} (x = $x)"            # bar (x = bar)

x="foo" && echo "${x=bar} (x = $x)"             # foo (x = foo)
x=""    && echo "${x=bar} (x = $x)"             #  (x = )
unset x && echo "${x=bar} (x = $x)"             # bar (x = bar)

x="foo" && echo "(x = $x)" && echo "${x:?error message}"  # (x = foo) foo
x=""    && echo "(x = $x)" && echo "${x:?error message}"  # (x = ) bash: x: error message
unset x && echo "(x = $x)" && echo "${x:?error message}"  # (x = ) bash: x: error message

x="foo" && echo "${x:+bar} (x = $x)"            # bar (x = foo)
x=""    && echo "${x:+bar} (x = $x)"            #  (x = )
unset x && echo "${x:+bar} (x = $x)"            #  (x = )

articles used

• https://www.gnu.org/software/bash/manual/html_node/Shell-Parameter-Expansion.html
• https://www.baeldung.com/linux/bash-variable-assign-default

Parameter Substitution, is NOT always the answer ${parameter:-default}

foo="$1"

o="${foo:-def}" # $foo, or def if unset (or null)
o="${foo:+def}" # def if $foo is set (and not null)
: "${foo:=def}" # Set $foo to def if unset (or null)
: "${foo:?msg}" # Show error message and exit if $foo is unset (or null)

While the default value (right side) can be an expression

The parameter (left side) can NOT be an expression

So if you want to assign based on an expression; You'll end up doing some form of bellow

For example

Set o to UPPER if x is bigger than 50 or LOWER if it's not

# function get_o { ... }
echo "$(get_o 33)"; # LOWER
echo "$(get_o 77)"; # UPPER

Set in Integer arithmetic condition

(( x > 50 )) && o="UPPER" || o="LOWER"
# or ..
[[ $x -ge 50 ]] && o="UPPER" || o="LOWER"

Set with Command substitution

o="$( (( x > 50 )) && echo "UPPER" || echo "LOWER" )"

Set default later with parameter substitution

(( x > 50 )) && o="UPPER"
: "${o:=LOWER}"

Set default first then update

o="LOWER"
(( x > 50 )) && o="UPPER"

Or with full if syntax ...

If you want 1 liner for your if-then-else, then we can consider rewriting:

if [ -z "${VARIABLE}" ]; then 
    FOO='default'
else 
    FOO=${VARIABLE}
fi

with semicolons:

if [ -z ${VARIABLE} ]; then FOO=`default`; else FOO=${VARIABLE}; fi

Alternatively, you can drop the if-then-else-fi keywords if you use boolean operators such as:

[ -z "${VARIABLE}" ] && FOO='default' || FOO=${VARIABLE}

Generalizing, the boolean operator pattern is:

conditional && then_command || else_command

I just wanted to chime in here since no one mentioned info or pinfo. You can find all of this info and much, much more, without even leaving the shell, by typing:

info -f "bash" -n "Shell Parameter Expansion"

Or use pinfo to add a little color. pinfo -f "bash" -n "Shell Parameter Expansion"

A good read: pinfo bash (navigate to Basic Shell Features)

To produce this cheat sheet:

info -f "bash" -n "Shell Parameter Expansion" -o "Parameter Expansion Cheat Sheet"

In each of the cases below, WORD is subject to tilde expansion, parameter expansion, command substitution, and arithmetic expansion.

When not performing substring expansion, using the form described below (e.g., ‘:-’), Bash tests for a parameter that is unset or null. Omitting the colon results in a test only for a parameter that is unset. Put another way, if the colon is included, the operator tests for both PARAMETER's existence and that its value is not null; if the colon is omitted, the operator tests only for existence.

‘${PARAMETER:−WORD}’ If PARAMETER is unset or null, the expansion of WORD is substituted. Otherwise, the value of PARAMETER is substituted.

      $ v=123
      $ echo ${v-unset}
      123

‘${PARAMETER:=WORD}’ If PARAMETER is unset or null, the expansion of WORD is assigned to PARAMETER. The value of PARAMETER is then substituted. Positional parameters and special parameters may not be assigned to in this way.

      $ var=
      $ : ${var:=DEFAULT}
      $ echo $var
      DEFAULT

‘${PARAMETER:=WORD}’ If PARAMETER is unset or null, the expansion of WORD is assigned to PARAMETER. The value of PARAMETER is then substituted. Positional parameters and special parameters may not be assigned to in this way.

      $ var=
      $ : ${var:=DEFAULT}
      $ echo $var
      DEFAULT

‘${PARAMETER:?WORD}’ If PARAMETER is null or unset, the expansion of WORD (or a message to that effect if WORD is not present) is written to the standard error and the shell, if it is not interactive, exits. Otherwise, the value of PARAMETER is substituted.

      $ var=
      $ : ${var:?var is unset or null}
      bash: var: var is unset or null

‘${PARAMETER:+WORD}’ If PARAMETER is null or unset, nothing is substituted, otherwise the expansion of WORD is substituted.

      $ var=123
      $ echo ${var:+var is set and not null}
      var is set and not null

Substring expansion and more is covered. Just a sample. Not going to copy it all here. It's a whole chapter!

 The following examples illustrate substring expansion using
 positional parameters:

 $ set -- 1 2 3 4 5 6 7 8 9 0 a b c d e f g h
 $ echo ${@:7}
 7 8 9 0 a b c d e f g h
 $ echo ${@:7:0}

 $ echo ${@:7:2}
 7 8
 $ echo ${@:7:-2}
 bash: -2: substring expression < 0
 $ echo ${@: -7:2}
 b c
 $ echo ${@:0}
 ./bash 1 2 3 4 5 6 7 8 9 0 a b c d e f g h
 $ echo ${@:0:2}
 ./bash 1
 $ echo ${@: -7:0}