Variable Assignment must have no space before and after. a=123 not a = 123. The latter (an equal sign surrounded by spaces) in isolation means run the command a with the arguments = and 123, though it is also seen in the string comparison operator (which syntactically is an argument to [ or [[ or whichever test you are using).

To get the number of command line arguments or positional parameters - type:

#!/bin/bash
echo "$#"

When run with three arguments the example above will result with the output:

~> $ ./testscript.sh firstarg secondarg thirdarg
3

To get the name of the current function - type:

my_function()
{
    echo "This function is $FUNCNAME"    # This will output "This function is my_function"
}

This instruction will return nothing if you type it outside the function:

my_function

echo "This function is $FUNCNAME"    # This will output "This function is"

The home directory of the user

~> $ echo $HOME
/home/user

Contains the Internal Field Separator string that bash uses to split strings when looping etc. The default is the white space characters: \n (newline), \t (tab) and space. Changing this to something else allows you to split strings using different characters:

IFS=","
INPUTSTR="a,b,c,d"
for field in ${INPUTSTR}; do
    echo $field
done

The output of the above is:

a
b
c
d

Notes:

• This is responsible for the phenomenon known as word splitting (opens new window).

OLDPWD (OLDPrintWorkingDirectory) contains directory before the last cd command:

~> $ cd directory
directory> $ echo $OLDPWD
/home/user

OLDPWD (OLDPrintWorkingDirectory) contains directory before the last cd command:

~> $ cd directory
directory> $ echo $OLDPWD
/home/user

Positional parameters passed to the script from either the command line or a function:

#!/bin/bash
# $n is the n'th positional parameter
echo "$1"
echo "$2"
echo "$3"

The output of the above is:

~> $ ./testscript.sh firstarg secondarg thirdarg
firstarg
secondarg
thirdarg

If number of positional argument is greater than nine, curly braces must be used.

#  "set -- " sets positional parameters
set -- 1 2 3 4 5 6 7 8 nine ten eleven twelve
# the following line will output 10 not 1 as the value of $1 the digit 1
# will be concatenated with the following 0
echo $10   # outputs 1
echo ${10} # outputs ten
# to show this clearly:
set -- arg{1..12}
echo $10
echo ${10}

Will return all of the positional parameters in a single string.

testscript.sh:

#!/bin/bash
echo "$*"

Run the script with several arguments:

./testscript.sh firstarg secondarg thirdarg

Output:

firstarg secondarg thirdarg

The Process ID (pid) of the last job run in the background:

~> $ ls &
testfile1 testfile2
[1]+  Done                    ls
~> $ echo $!
21715

The exit status of the last executed function or command. Usually 0 will mean OK anything else will indicate a failure:

~> $ ls *.blah;echo $?
ls: cannot access *.blah: No such file or directory
2
~> $ ls;echo $?
testfile1 testfile2
0

The Process ID (pid) of the current process:

~> $ echo $$
13246

The maximum number of remembered commands:

~> $ echo $HISTSIZE
1000

Process ID (pid) of the current instance of Bash. This is not the same as the $$ variable, but it often gives the same result. This is new in Bash 4 and doesn't work in Bash 3.

~> $ echo "\$\$ pid = $$  BASHPID = $BASHPID"
$$ pid = 9265  BASHPID = 9265

An environment variable pointing to the Bash startup file which is read when a script is invoked.

An array containing the full version information split into elements, much more convenient than $BASH_VERSION if you're just looking for the major version:

~> $ for ((i=0; i<=5; i++)); do echo "BASH_VERSINFO[$i] = ${BASH_VERSINFO[$i]}"; done
BASH_VERSINFO[0] = 3
BASH_VERSINFO[1] = 2
BASH_VERSINFO[2] = 25
BASH_VERSINFO[3] = 1
BASH_VERSINFO[4] = release
BASH_VERSINFO[5] = x86_64-redhat-linux-gnu

Shows the version of bash that is running, this allows you to decide whether you can use any advanced features:

~> $ echo $BASH_VERSION
4.1.2(1)-release

The default editor that will be involked by any scripts or programs, usually vi or emacs.

~> $ echo $EDITOR
vi

The hostname assigned to the system during startup.

~> $ echo $HOSTNAME
mybox.mydomain.com

This variable identifies the hardware, it can be useful in determining which binaries to execute:

~> $ echo $HOSTTYPE
x86_64

Similar to $HOSTTYPE above, this also includes information about the OS as well as hardware

~> $ echo $MACHTYPE
x86_64-redhat-linux-gnu

Returns information about the type of OS running on the machine, eg.

~> $ echo $OSTYPE
linux-gnu

The search path for finding binaries for commands. Common examples include /usr/bin and /usr/local/bin.

When a user or script attempts to run a command, the paths in $PATH are searched in order to find a matching file with execute permission.

The directories in $PATH are separated by a : character.

~> $ echo "$PATH"
/usr/kerberos/bin:/usr/local/bin:/bin:/usr/bin

So, for example, given the above $PATH, if you type lss at the prompt, the shell will look for /usr/kerberos/bin/lss, then /usr/local/bin/lss, then /bin/lss, then /usr/bin/lss, in this order, before concluding that there is no such command.

The Process ID (pid) of the script or shell's parent, meaning the process than invoked the current script or shell.

~> $ echo $$
13016
~> $ echo $PPID
13015

The number of seconds a script has been running. This can get quite large if shown in the shell:

~> $ echo $SECONDS
98834

A readonly list of the options bash is supplied on startup to control its behaviour:

~> $ echo $SHELLOPTS
braceexpand:emacs:hashall:histexpand:history:interactive-comments:monitor

Outputs the last field from the last command executed, useful to get something to pass onwards to another command:

~> $ ls *.sh;echo $_
testscript1.sh  testscript2.sh
testscript2.sh

test.sh:

#!/bin/bash
echo "$_"

Output:

~> $ ./test.sh # running test.sh
./test.sh

Note: This is not a foolproof way to get the script path

Each time this parameter is referenced, a random integer between 0 and 32767 is generated. Assigning a value to this variable seeds the random number generator (source (opens new window)).

~> $ echo $RANDOM
27119
~> $ echo $RANDOM
1349

An array containing the numbers of groups the user is in:

#!/usr/bin/env bash
echo You are assigned to the following groups:
for group in ${GROUPS[@]}; do
   IFS=: read -r name dummy number members < <(getent group $group )
   printf "name: %-10s number: %-15s members: %s\n" "$name" "$number" "$members"
done

Outputs the line number in the current script. Mostly useful when debugging scripts.

#!/bin/bash
# this is line 2
echo something  # this is line 3
echo $LINENO # Will output 4

When the bash command is executed a new shell is opened. The $SHLVL environment variable holds the number of shell levels the current shell is running on top of.

In a new terminal window, executing the following command will produce different results based on the Linux distribution in use.

echo $SHLVL

Using Fedora 25, the output is "3". This indicates, that when opening a new shell, an initial bash command executes and performs a task. The initial bash command executes a child process (another bash command) which, in turn, executes a final bash command to open the new shell. When the new shell opens, it is running as a child process of 2 other shell processes, hence the output of "3".

In the following example (given the user is running Fedora 25), the output of $SHLVL in a new shell will be set to "3". As each bash command is executed, $SHLVL increments by one.

~> $ echo $SHLVL
3
~> $ bash
~> $ echo $SHLVL
4
~> $ bash
~> $ echo $SHLVL
5

One can see that executing the 'bash' command (or executing a bash script) opens a new shell. In comparison, sourcing a script runs the code in the current shell.

test1.sh

#!/usr/bin/env bash
echo "Hello from test1.sh. My shell level is $SHLVL"
source "test2.sh"

test2.sh

#!/usr/bin/env bash
echo "Hello from test2.sh. My shell level is $SHLVL"

run.sh

#!/usr/bin/env bash
echo "Hello from run.sh. My shell level is $SHLVL"
./test1.sh

Execute:

chmod +x test1.sh && chmod +x run.sh
./run.sh

Output:

Hello from run.sh. My shell level is 4
Hello from test1.sh. My shell level is 5
Hello from test2.sh. My shell level is 5

A read only variable that stores the users' ID number:

~> $ echo $UID
12345