In all Bourne Shell derivatives, a shell variable is created or modified using the same simple syntax:

varname=value
            

bash-4.2$ name = Fred
bash: name: command not found
bash-4.2$ name=Fred
bash-4.2$ printf "$name\n"
Fred
            

When assigning a string that contains white space, it must be enclosed in quotes or all white space characters must be escaped:

#!/bin/sh -e

name=Joe Sixpack    # Error
name="Joe Sixpack"  # OK
name=Joe\ Sixpack   # OK
            

C shell and T shell use the internal set command for assigning variables. Since a variable assignment is a command in C shell, we can have white space around the '=' if we wish:

#!/bin/csh -ef

set name = "Joe Sixpack"
            

In many languages such as C, Fortran, or Java, we must define variables before we can use (reference) them:

    int     c;
    double  x;
    
    c = 5;
    x = 1.4;
            

Unix shell variables need not be defined before they are assigned a value. Defining variables is unnecessary, since there is only one data type in shell scripts. All shell variables are character strings. There are no integers, Booleans, enumerated types, or floating point variables, although there are some facilities for interpreting shell variables as integers, assuming they contain only digits.

In Bourne shell, we can perform basic integer arithmetic by enclosing an expression in $(( )):

c=$(($c + 1))
            

In C shell, we use the @ command, which is a special form of set that enables basic arithmetic:

@ c = $c + 1
            

Most shells are not capable of handling real numbers. Only integers are supported, mainly for the sake of loop counters and a few other purposes. If you must manipulate real numbers in a shell script, you could accomplish it by piping an expression through bc, the Unix arbitrary-precision calculator:

printf "243.9 * $variable\n" | bc -l
            

Such facilities are very inefficient compared to other languages, however, partly because shell languages are interpreted, not compiled, and partly because they must convert each string to a number, perform arithmetic, and convert the results back to a string. Shell scripts are meant to automate sequences of Unix commands and other programs, not perform numerical computations.

In Bourne shell family shells, environment variables are set by first setting a shell variable of the same name and then exporting it to the environment:

TERM=xterm
export TERM
            

Modern Bourne shell derivatives such as bash (Bourne Again Shell) can do this in one command:

export TERM=xterm
            

C shell derivatives use the setenv command to set environment variables:

setenv TERM xterm
            

C shell variables are not linked to environment variables, except for some special variables, like path which is automatically exported to the environment variable PATH each time is it updated.

To reference a shell variable or an environment variable in a shell script, we must precede its name with a '$'. The '$' tells the shell that the following text is to be interpreted as a variable name rather than a string constant. The variable reference is then expanded, i.e. replaced by the value of the variable. This occurs anywhere in a command except inside a string bounded by single quotes or following an escape character (\), as explained in the section called “String Constants and Terminal Output”. These rules are basically the same for all Unix shells.

#!/bin/sh -e

name="Joe Sixpack"
printf "Hello, name!\n"     # Not a variable reference
printf "Hello, $name!\n"    # References variable "name"
printf 'Hello, $name!\n'    # Not a variable reference
printf "Hello, \$name!\n"   # Not a variable reference
            

Output:

Hello, name!
Hello, Joe Sixpack!
Hello, $name!
Hello, $name!
            

#!/bin/sh -e

first_name="Bob"
last_name="Newhart"
printf "%s %s is a superhero.\n" $first_name $last_name
                

#!/bin/csh -ef

set first_name = "Bob"
set last_name = "Newhart"
printf "%s %s is a superhero.\n" $first_name $last_name
                

Darwin heron bacon ~ 319: set name=Sue
Darwin heron bacon ~ 320: setenv name Bob
Darwin heron bacon ~ 321: echo $name
Sue
Darwin heron bacon ~ 322: printenv name
Bob
            

If a variable reference is immediately followed by a character that could be part of a variable name, we could have a problem:

#!/bin/sh -e

name="Joe Sixpack"
printf "Hello to all the $names of the world!\n"
            

Instead of printing "Hello to all the Joe Sixpacks of the world", the printf will fail because there is no variable called "names". In Bourne Shell derivatives, non-existent variables are treated as empty strings, so this script will print "Hello to all the of the world!". C shell will print an error message stating that the variable "names" does not exist.

We can correct this by delimiting the variable name in curly braces:

#!/bin/sh -e

name="Joe Sixpack"
printf "Hello to all the ${name}s of the world!\n"
            

This syntax works for all shells. Some shell programmers might insist that all variable references should use {}. My philosophy is that if something is not necessary or at least helpful, then typing it is a waste of time and added clutter.

Another very good use for shell variables is in eliminating redundant string constants from a script. Suppose we have a path name referenced multiple times in a script:

#!/bin/sh -e

output_value=`myprog`

printf "$output_value\n" >> Run2/Output/results.txt
more Run2/Output/results.txt
cp Run2/Output/results.txt latest-results.txt
            

If for any reason the relative path Run2/Output/results.txt should change, then you'll have to search through the script and make sure that all instances are updated. This is a tedious and error-prone process, which can be avoided by using a variable:

#!/bin/sh -e

output_file="Run2/Output/results.txt"

output_value=`myprog`
printf "$output_value\n" >> $output_file
more $output_file
cp $output_file latest-results.txt
            

In the second version of the script, if the path name of results.txt changes, then only one change must be made to the script. Avoiding redundancy is one of the primary goals of any good programmer.

In a more general programming language such as C or Fortran, this role would be served by a constant, not a variable. However, shells do not support constants, so we use a variable for this.

In most shells, a variable can be marked read-only in an assignment to prevent accidental subsequent changes. Bourne family shells use the readonly command for this, while C shell family shells use set -r.

#!/bin/sh -e

readonly output_file="Run2/Output/results.txt"

output_value=`myprog`
printf "$output_value\n" >> $output_file
more $output_file
cp $output_file latest-results.txt
            

#!/bin/csh -ef

set -r output_file = "Run2/Output/results.txt"

set output_value=`myprog`
printf "$output_value\n" >> $output_file
more $output_file
cp $output_file latest-results.txt
            

Output from a command can be captured and used as a string in the shell environment by enclosing the command in back-quotes (``). In Bourne-compatible shells, we can also use $() in place of back-quotes.

            #!/bin/sh -e
            
            # Using output capture in a command
            printf "Today is %s.\n" `date`
            printf "Today is %s.\n" $(date)
            
            # Using a variable.  If using the output more than once, this will
            # avoid running the command multiple times.
            today=`date`
            printf "Today is %s\n" $today