• Variables can be created and assigned text using an equals sign. Surround the text with double quotes (although it is not necessary unless there is space in the name):
  $ FILENAME="info.txt"
$ printf “%s\n” “$FILENAME”
info.txt
  
• The declare command, in addition to creation of variable and assigning values, can add attributes to variables as well (using + instead of - turns of the attribute).
  declare -r x=5
  (-r option makes the variable read-only)
  
  The declare command without any options list all pre-defined variables of system.
  
• The results of a command can be assigned to a variable using backquotes.
  $ Date=`date`
$ printf "%s\n" "$Date"
Thu Apr 13 08:02:19 UTC 2017
  
• Double quotes do not prevent Bash from interpreting the special characters $, ‘, and \, but single quotes leave all characters unchanged.
• Variable names can be enclosed in curly braces to make it clear where the variable’s name begins and ends.
  $ TAX_MESSAGE="The tax is ${TAX}%"
• Shell variables exist in the script or interactive sessions only, where they were declared. In order to make shell variables available outside of their place of origin, they have to be declared as exportable with -x option.
  Although Linux has provisions for exporting environment variables, there is no way to assign any attributes to them.
  The variables shared with a new program are copies of the original. If a script declares an exported variable and runs a second script, any changes made to the variable by the second script are invisible to the first.There is no way for a second script to assign a new value to a variable that the first script will see. Unlike other programming languages, exporting shell variables is a one-way street.
  The only way to return a value to the calling program is to write it to a file (or standard output) and have the calling program read (or assign) the value back into a variable.
• Before a command is executed, Bash searches the command for all dollar signs and inserts the value of variables before the command is carried out. Bash performs this substitution once. eval command do this another time:
  #!/bin/bash
VAR1=25
VAR2='$VAR1'
VAR3='$VAR2'
echo "$VAR3"
eval echo "$VAR3"
eval eval echo "$VAR3"
  Output of the script above:
  $VAR2
$VAR1
25

$RANDOM

Generates a random integer number (0 - 32767)

read -p "Please enter your name: " USER_NAME

With -p option we can provide a message before the user input.
read -t 5 FILENAME # wait up to 5 seconds to read a filename
-n 10 FILENAME # read no more than 10 characters
The -r (raw input) option disables the backslash escaping of special characters.

printf is very similar to the C standard I/O printf() function, but they are not identical. In particular, single- and double-quoted strings are treated differently in shell scripts than in C programs.
The first parameter is a format string describing how the items being printed will be represented. For example, the special formatting code “%d” represents an integer number, and the code “%f” represents a floating-point number:

$ printf "%d and %f\n" 5 5
		5 and 5.000000

if test Condition; then
  Expression1
else
  Expression2
fi

We can use square brackets instead of test:
if [ Condition ]; then
  ...
fi

We can use carriage return instead of semi-colon (;) :
if [ Condition ]
then
  Expression1
else
  Expression2
fi

Make richer Conditions by using -a (and), -o (or), ! (not).
Unlike most programming languages, in BASH the "not" operator doesn't take precedence over "and" and "or". So use parenthesis if needed.
if [ \( ! -f "$TMP1" \) -a -f "$TMP2" ]

Alternatively we can use &&, || for 'and', 'or'.
if [ \( ! -f "$TMP1" \) ] && [ -f "$TMP2" ]

* help test gives useful options.
Writing if commands in terminal:
if [ condition ]; then <rest of code> ; fi
Alternatively,
$ if [ condition ]; then
> <rest of code>
> fi


• Array is like a variable. So it is created using declare, with -a option or just direct assignment:
  $ declare -a ARRAY0$
  $ ARRAY1=(0 1 2)
  $ ARRAY2=([3]='cat' [5]='dog' [12]='cow') #indicating indeces
• Bash arrays differ from arrays in other computer languages in that they are open-ended. Arrays can be any length and are initially filled with empty strings for items.
• Use curly braces to supercede the shell's pathname matching process:
  $ echo "${ MYARRAY [2] }"
• If no index is given, index zero is assumed:
  $ echo "$ARRAY1"
  2
  $ ARRAY1 = "a"
  ['a', 1, 2]
• Accessing all elements of an array can be done using index * or @. The difference (for printf not echo) is that * puts an space (actually the first character of IFS variable) in between elements but @ doesn't:
  $ echo "${ARRAY1[*]}"
  a 1 2
• Individual array values can be removed with the command. Erasing a value by unset assigning the array position an empty string doesn’t destroy it:The empty string is still treated as an array item whenever the items are counted.
• The read command can read a list into an array using an -a switch. When this switch is used, each item on the line of input is read into a separate array position.

The easiest way to browse the command history is with the Up and Down arrow keys. The history can also be searched with an exclamation mark (!). This denotes the start of a command name to be completed by Bash. Bash executes the most recent command that matches. For example,
$ !d
date
Thu Apr 13 08:24:51 UTC 2017
!!repeats the last command. A negative number indicates the relative line number. That is, it indicates the number of commands to move back in the history to find the one to execute. !! is the same as !-1.

The !# repeats the content of the current command line. (Don’t confuse this with #!) Use this to run a set of commands twice.

history n lists the last n commands.

• Running stty shows the common command keys as well as other information about your session. (has -a option)
• Use \ for using the next line in long commands
• Two commands separated by a semicolon (;), are executed consecutively, one after another. Two commands separated by &&, are executed until one of them fails or until all the commands are executed. Similarly for ||.
• sleep n makes a n second delay.
• Using the minus sign (–) with cd, you can switch between the current directory and the last directory. (~ and - are features of Bash and only work with Bash and Bash scripts.)

for i in list
do
	something
done

sum=0
for i in 1 2 3 4
do
	sum=$(($sum+$i))
done
echo "The sum of $i numbers is: $sum"

while condition is true
do
  something
done
until condition is false
do
  something
done

Create random and unpredictable filenames for temporary storage with the mktemp utility:
TEMP=$(mktemp /tmp/tempfile.XXXXXXXX) # To create a temporary file
TEMPDIR=$(mktemp -d /tmp/tempdir.XXXXXXXX) # To create a temporary directory
The XXXXXXXX is replaced with random characters by the mktemp utility.

Debugging

We can run a script in debug mode by bash –x ./script_file.
Inside a sccript we can do it by
set -x # turns on debugging
...
set +x # turns off debugging


Quick Refference Table

${#str}	Length of the string str
${str:i:j}	String Slicing. i: start, j: length
${str#*i}	String Slicing. The part of str after character i.
$n	Referring to the nth argument that is given alongside the command