A few notes.
A lot of Bash.

NAME="TRAW"

echo ${NAME}    # => TRAW :This prints the variable value
echo $NAME      # => TRAW :This prints the variable value
echo "$NAME"    # => TRAW :This prints the variable value
echo '$NAME'    # => $NAME : This will print the Exact string not value.
echo "${NAME}!" # => TRAW! :Concatenation of variable value with !

# Note: When declaring variables there should be no spaces between the variable
# name and equal sign and between the equal sign and the variable value.
# this will throw and error
NAME = "TRAW"   # => Error (about space)

# This is an inline Bash comment.
: '
This is a
Multi-line comment
in bash

If it looks very neat
'

# **Note you can replace the single quoations with**
# **double qoutations**

#!/usr/bin/env bash

get_username() {
    echo "TRAW"
}

# Or using the function keyword
function get_username() {
    echo "TRAW"
}

echo "You are $(get_username)"

#!/usr/bin/env bash

greet="world World"
echo "$greet!, I'm new here."
# => Hello world! I'm new here.

#Execute the script

$ chmod +x helloworld.sh
$ ./helloworld.sh

# or just

$ bash helloworld.sh

#!/usr/bin/env bash

string="test"

if [[ -z "$string" ]]; then
    echo "String is empty"
elif [[ -n "$string" ]]; then
    echo "String is not empty"
fi

# => I'm TRAW
echo "I'm $(whoami)"

# Similar to:
echo "I'm `whoami`"

echo ${food:-Cake}  #=> $food or "Cake"
STR="/path/to/foo.cpp"
echo ${STR%.cpp}    # /path/to/foo
echo ${STR%.cpp}.o  # /path/to/foo.o
echo ${STR%/*}      # /path/to

echo ${STR##*.}     # cpp (extension)
echo ${STR##*/}     # foo.cpp (basepath)

echo ${STR#*/}      # path/to/foo.cpp
echo ${STR##*/}     # foo.cpp

echo ${STR/foo/bar} # /path/to/bar.cpp

SRC="/path/to/foo.cpp"
BASEPATH=${SRC##*/}
echo $BASEPATH  # => "foo.cpp"

DIRPATH=${SRC%$BASEPATH}
echo $DIRPATH   # => "/path/to/"

name="John"
echo ${name}           # => John
echo ${name:0:2}       # => Jo
echo ${name::2}        # => Jo
echo ${name::-1}       # => Joh
echo ${name:(-1)}      # => n
echo ${name:(-2)}      # => hn
echo ${name:(-2):2}    # => hn

length=2
echo ${name:0:length}  # => Jo

STR="HELLO WORLD!"
echo ${STR,}   # => hELLO WORLD!
echo ${STR,,}  # => hello world!

STR="hello world!"
echo ${STR^}   # => Hello world!
echo ${STR^^}  # => HELLO WORLD!

ARR=(hello World)
echo "${ARR[@],}" # => hello world
echo "${ARR[@]^}" # => Hello World

#
:'
Compound array assignment - sets the whole array
NAMES to the given list of elements.
'
# NAMES => Creg Jan Anna
NAMES=('Creg' 'Jan' 'Anna')

# using the declare construct
declare -a Numbers=(1 2 3)

ARRAY1=(foo{1..2}) # => foo1 foo2

ARRAY2=({A..D})    # => A B C D

ARRAY3=({1..5})    # => 1 2 3 4 5

ARRAY4=({A..B}{1..2}) #=> A1 A2 B1 B2

:'
Sets the element N of the indexed array NAMES to
VALUE.
N can be any valid arithmetic expression.
'

NAMES[0]='Creg'
NAMES[1]='Jan'
NAMES[2]='Anna'
# NAMES => Creg Jan Anna

NAMES=('Creg' 'Jan' 'Anna')

NAMES+=('Jay' 'Jimmy' 'Tom')
# NAMES => Creg Jan Anna Jay Jimmy Tom

# This is also the same as
NAMES=(${NAMES[@]} 'Jay' 'Jimmy' 'Tom')
# NAMES => Creg Jan Anna Jay Jimmy Tom

:'
Individual mass-setting for **associative arrays**.
The named indexes (here: name, age....) are strings.
'

declare -A person # this line is required
# quotes can me omitted for the keys, see the **age** key below
person=(["name"]="Jay" [age]=22 ["eye_color"]="blue")

# person => Jay 22 blue

ARRAY1=(foo{1..2}) # => foo1 foo2
ARRAY2=({A..D})    # => A B C D
ARRAY3=({1..5})    # => 1 2 3 4 5

# Merge Arrays => foo1 foo2 A B C D 1 2 3 4 5
ARRAY4=(${ARRAY1[@]} ${ARRAY2[@]} ${ARRAY3[@]})

The **@** can also be replace with a *****

declare -A person

person[name]="Jay"

person[age]=22

person[eye_color]="blue"

# person => Jay 22 blue

names=('Jay' 'Joe' 'Jimmy')
for name in "${names[@]}"; do
    echo $name
done

# using index
for i in "${!names[@]}"; do
  printf "%s\t%s\n" "$i" "${names[$i]}"
done

declare -A person
person=(["name"]="Jay" [age]=22 ["eye_color"]="blue")

echo ${person[name]} #  Get person's name
echo ${sounds[@]}   # Get all person's values
echo ${sounds[*]}  # Get all person's values
echo ${!person[@]}  # All person's  keys (age, name...)
echo ${#person[@]}  # Number of elements

unset -v person[age]   # Delete person's age

# All of the above operations workes with index arrays, just that you only
# replace the keys with indexes

declare -A person
person=(["name"]="Jay" [age]=22 ["eye_color"]="blue")

for value in "${person[@]}"; do
    echo $value
done

# Using keys
for key in "${!person[@]}"; do
    echo "$key  ${person[$key]}"
done

function extract()
{
    # creating a local array from function argument 1 ($1)
    local -n local_names=$1
	  # creating a local index from function argument 2 ($2)
    local index=$2
    echo "${local_names[$index]}"
 }
# defining global array names
names=('Jay' 'Joe' 'Jimmy')

extract names 2     # => Jimmy

for i in /etc/*; do
    echo $i
done

# Same as above(alternate syntax), also works with other loop structs

for i in /etc/*
do
		echo $i
done

# incrementing the value
i=1
while [[ $i -lt 4 ]]; do
    echo "Number: $i"
    ((i++))
done

 # decrementing the value

i=3
while [[ $i -gt 0 ]]; do
    echo "Number: $i"
    ((i--))
done

# seq command can be using to gerate ranges

for number in $(seq 1 3); do
    if [[ $number == 2 ]]; then
        continue;
    fi
    echo "$number"
done

for ((i = 0 ; i < 100 ; i++)); do
    echo $i
done

# Same as above (alternate syntax) also works with other loop structs

for ((i = 0 ; i < 100 ; i++))
do
    echo $i
done

# while true long hand

while true; do
    # TODO
		# TODO
done

# or the shorthand (alternate syntax)

while :; do
    # TODO
		# TODO
done

for number in $(seq 1 3); do
    if [[ $number == 2 ]]; then
        # Skip entire rest of loop or break out of the loop.
        break;
    fi
    # This will only print 1
    echo "$number"
done

for i in {1..10}; do
    echo "Number: $i"
done

# With step size
# => {START..STOP..STEP}

for i in {5..50..5}; do
    echo "Number: $i"
done

# using pipes

cat file.txt | while read line; do
    echo $line
done

# OR using input redirection

while read line; do
		echo $line
done < "/path/to/txt/file"

# incrementing
count=0
until [ $count -gt 10 ]; do
    echo "$count"
    ((count++))
done

# decremetning
count=10
until [ $count -eq 0 ]; do
    echo "$count"
    ((count--))
done

greet() {
    echo "hello $1 $2"
}

# Same as above (alternate syntax)
function greet() {
    echo "hello $1 $2"
}

# Calling the function
greet "John" "Paul"

add_numbers() {

		# perfoming mathematical additions
    local result=$(( $1 + $2)

		# returning the sresult value
    echo $result
}

# storing the returned value
result="$(add_numbers 1 2)"

# using return
myfunc() {
    return 1
}

if myfunc; then
    echo "success"
else
    echo "failure"
fi

#!/bin/bash

# Basic arithmetic using expr
:"
Because expr is a binary rather than a shell builtin, this method may be slow. In a large for-loop,
it will fork a new process, which is undesirable. Furthermore, depending on the implementation, the behavior
of expr may differ between systems.

In contrast to let, you do not need to enclose the expression in quotes. There must also be spaces between
the expression's items. To save the output to a variable, like any other command you can use command
substitution to capture the output of expr into a variable.
"

# expr syntax
expr item1 operator item2

# Note that there must be spaces between the items and no quotes.
expr 7 + 5 #=> 13

expr "6 + 3" #=> 6 + 3

# if you put qoutes the expression will not be evaluated but printed instead.
expr 3+2 #=> 3+2

# The asterisk has special meaning in bash so we must escape it using \ to remove its special meaning.
expr 5 \* 3

# modulus operator demonstration
expr 15 % 2 #=> 1

# using command substitution to save output to a variable
result=$( expr 15 - 2 )
echo $result #=> 13

#!/bin/bash

# Basic arithmetic using let
:"
let is a Bash built-in function that allows us to perform simple arithmetic.

The arithmetic expression can take several forms, which we'll go over below. However, the first part is
always a variable into which the result is saved.
"

# The let has the following syntax:
let <arithmetic expression>

# It is important to note that if we do not use quotes around the expression, it must be written without
# spaces.
let result=6+4
echo $result #=> 10

# This time, we used quotes to space out the expression and make it more readable.
let "result = 4 + 4"
echo $result #=> 8

# incremeting the result same as let result =result+1 or let result+=1
let result++
echo $result #=> 9

# doing some multiplication
let "result = 4 * 5"
echo $result # 20

# We can also use variables in expressions
let "result = $1 + 30"
echo $result # 30 + first command line argument

#!/bin/bash

# Basic arithmetic using double parenthesis

:"
The Arithmetic Expansion capability of the shell is the recommended way for evaluating arithmetic expressions
with integers in Bash. The built-in shell expansion allows you to perform math calculations by using
 parentheses ((...)).
"

# The Bash arithmetic expansion is written in the format:
$((arithmetic expression))

# you can space out without the need for quotaions to improve readabilty
result=$(( 6 + 5 ))
echo $result #=> 11

# this works the same
result=$((3+7))
echo $result #=> 10

# you can include other variables without the need of using $ on them, notice **result** variable below.
result2=$(( result + 3 ))
echo $result2 #=> 11

# you can inlcude variables with $ if you prefer.
result2=$(( $result + 4 ))
echo $result2 #=> 14

# when incrementing the variable you don't include the $ sign
(( result2++ ))
echo $result2 #=> 15

# incrementing the value by 3 this is the shorthand for result2 = result2 + 4.
(( result2 += 4 ))
echo $result2 #=> 19

# Unlike other methods, when we do multiplication we don't need to escape the * sign. This what makes this
# method so powerful and versatile.
result=$(( 4 * 5 ))
echo $result #=> 20

cat <<'EOF'
A line of text.
Another line of text.
EOF

shopt -s nullglob  #Example to enable nullglob option