Creating and Executing a Shell Script:

1. Creation: Open a text editor (like vi, nano, or gedit) and write the script commands. The first line should be the Shebang (#!) line, specifying the interpreter.
   bash

   !/bin/bash

   echo "Hello World"

2. Saving: Save the file with a specific name, conventionally using the .sh extension (e.g., myscript.sh).

3. Permissions: By default, created files may not have execute permissions. Use the chmod command to modify permissions.

   • Syntax: chmod +x filename
   • Example: chmod +x myscript.sh

4. Execution: Run the script using one of the following methods:

   • Relative path: ./myscript.sh
   • Absolute path: /home/user/myscript.sh
   • Using the shell explicitly: sh myscript.sh or bash myscript.sh

Difference between Environment and User-Defined Variables:

Example:

• User Variable: x=10 (Only visible in current shell).
• Env Variable: export PATH=$PATH:/new/path (Modifies system path for child processes).

The expr command evaluates expressions and prints the result to standard output. It handles integer arithmetic.

Syntax:
expr item1 operator item2

Key Rules:

1. Spaces: There must be spaces between the operator and the operands.
   • Correct: expr 5 + 2
   • Incorrect: expr 5+2
2. Meta-characters: Certain characters like multiplication (*) and parentheses must be escaped using a backslash (\) because they have special meaning in the shell.

Examples:

• Addition: sum=a + $b)
• Multiplication: mul=a \* $b)

Limitations:

• It creates a new process for every execution (slower in loops).
• It cannot handle floating-point numbers (decimals). It only supports integers.

Standard shell arithmetic (like expr or $((...))) does not support floating-point numbers. The bc (Basic Calculator) command is used for this purpose. It is an arbitrary precision calculator language.

Using bc:
It is often used with the pipe (|) to pass the expression to the calculator.

Syntax:
variable=$(echo "options; expression" | bc)

The scale variable:
To perform division with decimal points, the scale variable must be defined inside bc to specify the number of decimal places.

Example:
Calculate the area of a circle where .
bash
radius=2.5

3.14 2.5 2.5

area=radius * $radius" | bc)
echo "Area is: $area"

Output: Area is: 19.62

I/O Redirection allows users to change the source of input or the destination of output for commands.

1. Standard Output Redirection (>):

   • Redirects the output of a command to a file.
   • Behavior: It overwrites the file if it exists, or creates a new one.
   • Example: ls -l > filelist.txt (Saves directory listing to filelist.txt).

2. Append Output (>>):

   • Redirects output to a file but preserves existing content.
   • Behavior: It appends the new output to the end of the file.
   • Example: echo "New Log Entry" >> log.txt.

3. Standard Input Redirection (<):

   • Feeds the content of a file as input to a command.
   • Example: wc -l < filelist.txt (Counts lines in filelist.txt without passing the filename as an argument).

Pipes (|):
A pipe creates a communication channel between two processes. It takes the Standard Output (stdout) of the command on the left and passes it as Standard Input (stdin) to the command on the right.

Difference from Redirection:

• Redirection (>) connects a command to a file.
• Pipes (|) connect a command to another command.

Example combining Pipes and Redirection:
Find the number of files containing the word "error" and save the count to a file.

bash
grep "error" application.log | wc -l > error_count.txt

• grep: Searches for "error".
• |: Passes the matching lines to wc.
• wc -l: Counts the lines.
• >: Writes the final number to error_count.txt.

Below is the script demonstrating the if-elif-else conditional structure.

bash

!/bin/bash

echo "Enter a number:"
read num

if [ $num -gt 0 ]
then
echo "$num is a Positive number."
elif [ $num -lt 0 ]
then
echo "$num is a Negative number."
else
echo "The number is Zero."
fi

Explanation:

• read num: Takes input.
• -gt: Greater than operator.
• -lt: Less than operator.
• fi: Closes the if block.

Syntax of case statement:
bash
case $variable in
pattern1) commands ;;
pattern2) commands ;;
*) default_commands ;;
esac

Menu-Driven Calculator Script:
bash

!/bin/bash

echo "Enter two numbers:"
read a
read b

echo "Select Operation:"
echo "1. Add"
echo "2. Subtract"
echo "3. Multiply"
echo "4. Divide"
read choice

case $choice in
1) res=a + $b" | bc)
echo "Result: $res" ;;
2) res=a - $b" | bc)
echo "Result: $res" ;;
3) res=a $b" | bc)
echo "Result: $res" ;;
4) res=a / $b" | bc)
echo "Result: $res" ;;
) echo "Invalid choice" ;;
esac

Comparison:

1. While Loop Example:
Print numbers 1 to 5.
bash
i=1
while [ $i -le 5 ]
do
echo $i
((i++))
done

2. Until Loop Example:
Print numbers 1 to 5 (loop runs until is greater than 5).
bash
i=1
until [ $i -gt 5 ]
do
echo $i
((i++))
done

The for Loop:
Used to iterate over a list of values or a range of numbers.

1. Iterating over a list (Classic Shell style):
Syntax: for var in list; do ... done

Example (Iterating over files):
bash
for file in *.txt
do
echo "Processing $file"
done

2. C-Style For Loop:
Syntax: for (( init; condition; increment )); do ... done

Example (Counting 1 to 5):
bash
for (( i=1; i<=5; i++ ))
do
echo "Number: $i"
done

Indexed Arrays: Arrays where elements are stored using integer indices (starting from 0).

1. Declaration:

   • Explicit: declare -a my_array
   • Implicit: Just assigning values creates it.

2. Assignment:

   • Individual: my_array[0]="Apple"
   • Compound: my_array=("Apple" "Banana" "Cherry")

3. Accessing Elements:

   • Single Element: ${my_array[1]} (Output: Banana)
   • All Elements: {my_array[*]}
   • Array Length: ${#my_array[@]}

Example:
bash
fruits=("Apple" "Mango" "Grape")
echo "First fruit: ${fruits[0]}"
echo "All fruits: ${fruits[@]}"

Associative Arrays:
Also known as dictionaries or hashmaps, these arrays use strings (keys) as indices instead of integers. They are available in Bash version 4.0+.

Difference:

• Indexed: Keys are Integers (0, 1, 2...).
• Associative: Keys are Strings ("name", "age", "city").

Declaration (Mandatory):
You must declare them using declare -A.

Example:
bash

Declare

declare -A student

Assign

student[name]="Alice"
student[id]="S101"
student[score]="90"

Access

echo "Student Name: ${student[name]}"

Iterate Keys

for key in "${!student[@]}"
do
echo "{student[$key]}"
done

Creating Functions:
Functions are blocks of code that can be reused. They are defined using the function keyword or just the name followed by parentheses.

Syntax:
bash
function_name () {
commands
}

Parameter Passing:
Shell functions do not declare arguments in parentheses. Instead, arguments passed to the function are accessed using positional parameters (2, etc.) inside the function.

Example:
bash

Definition

greet_user () {
echo "Hello, 2."
}

Calling the function

greet_user "John" 101

Output: Hello, John! Your ID is 101.

Note: $0 inside the function is the script name, not the function name.

These are special variables used to access arguments and process status.

• $0: The name of the script or the command currently executing.
• $#: The count of arguments passed to the script or function.
• *`` for looping.
• $?: The exit status of the last executed command (0 usually means success, non-zero means failure).
• $$: The Process ID (PID) of the current shell script instance. Often used for creating unique temporary filenames.

The factorial of a number is defined as .

Script:
bash

!/bin/bash

echo "Enter a number:"
read n

factorial=1
counter=$n

Check if number is negative

if [ $n -lt 0 ]; then
echo "Factorial is not defined for negative numbers."
exit 1
fi

while [ $counter -gt 0 ]
do

factorial = factorial * counter

factorial=$(( factorial * counter ))

# Decrement counter
((counter--))

done

echo "Factorial of factorial"

The Fibonacci series starts with 0 and 1, and the next number is the sum of the previous two ().

Script:
bash

!/bin/bash

echo "Enter the number of terms:"
read N

a=0
b=1

echo "Fibonacci Series:"

for (( i=0; i<N; i++ ))
do
echo -n "$a "
fn=$((a + b))
a=$b
b=$fn
done
echo "" # New line

Explanation:

1. Initialize a=0, b=1.
2. Loop times.
3. Print a.
4. Calculate next term fn = a + b.
5. Update a to b and b to fn.

File test operators are used within if conditions (e.g., if [ -f file ]) to check file properties.

• -f file: True if the file exists and is a regular file (not a directory or device).
• -d file: True if the file exists and is a directory.
• -r file: True if the file exists and is readable by the user.
• -w file: True if the file exists and is writable.
• -x file: True if the file exists and is executable.
• -s file: True if the file exists and has a size greater than zero (not empty).
• -e file: True if the file exists (regardless of type).

Example:
bash
if [ -d "/home/user/data" ]; then
echo "Directory exists"
fi

bash

!/bin/bash

Check if argument is passed

if [ $# -eq 0 ]; then
echo "Usage: $0 filename"
exit 1
fi

filename=$1

if [ -e "$filename" ]; then
echo "File '$filename' exists."

Display permissions using ls -l

ls -l "$filename"

if [ -w "$filename" ]; then
    echo "File is writable."
else
    echo "File is not writable."
fi

else
echo "File does not exist. Creating it now..."
touch "$filename"
echo "File '$filename' created."
fi

These statements alter the normal flow of loops (for, while, until).

1. break: Terminates the loop immediately and transfers control to the statement following the done keyword. It is used to exit a loop early.
2. continue: Skips the remaining commands in the current iteration of the loop and jumps back to the condition check for the next iteration.

Example:
bash
for i in {1..5}
do
if [ $i -eq 2 ]; then
continue # Skip 2
fi

if [ $i -eq 4 ]; then
    break     # Stop at 4 (do not print 4 or 5)
fi

echo "Number: $i"

done

Output:
Number: 1
Number: 3

Debugging helps locate errors in the script logic or syntax.

1. Verbose Mode (-v):

• Function: Prints shell input lines as they are read.
• Usage: bash -v script.sh
• Purpose: Helps to see the code structure before execution.

2. X-trace / Debug Mode (-x):

• Function: Prints commands and their arguments as they are executed.
• Usage: bash -x script.sh
• Output: Lines usually start with + to indicate the trace.
• Purpose: Shows variable expansions and the exact command being run.

Embedding in Script:
You can also add set -x inside the script to start debugging from that point and set +x to stop it.