Shebang Line:
The Shebang line is the very first line of a script file. It begins with #! followed by the absolute path to the interpreter that should be used to execute the script.

• Syntax: #!/bin/bash or #!/bin/sh
• Function: It tells the kernel which interpreter (e.g., Bash, Python, Perl) to use to parse the rest of the file. If omitted, the current shell assumes the script is written in its own language, which may cause errors if the syntax differs.

Making a File Executable:
By default, created files are not executable for security reasons. To execute a script, the execute permission (x) must be added using the chmod command.

• Symbolic Mode: chmod +x scriptname.sh (Adds execute permission for all users).
• Absolute (Octal) Mode: chmod 755 scriptname.sh (Read/Write/Execute for owner, Read/Execute for group and others).

Difference between Environment and User-Defined Variables:

Converting User-Defined to Environment Variable:
A user-defined variable is local by default. To make it an environment variable (accessible to child scripts), use the export command.

bash
my_var="Hello"
export my_var

Or in one line:

export my_var="Hello"

The expr command is a legacy command-line utility used to evaluate expressions, primarily arithmetic and string comparisons.

Usage:
It prints the result of the expression to standard output.

• Addition: expr 5 + 2
• Subtraction: expr 5 - 2
• Division: expr 10 / 2

Syntax and Limitations:

1. Spaces: Spaces are mandatory between operators and operands. expr 5+2 will fail; expr 5 + 2 works.
2. Integer Only: expr typically supports only integer arithmetic. It cannot handle floating-point numbers.
3. Multiplication Issue: The asterisk * is a wildcard character in shell. Therefore, when performing multiplication, it must be escaped using a backslash \.
   • Incorrect: expr 5 * 2 (Shell tries to expand * to filenames).
   • Correct: expr 5 \* 2.

Comparison of expr and bc:

1. Data Types: expr handles only integers, whereas bc (Basic Calculator) is an arbitrary-precision calculator language that supports floating-point numbers.
2. Complexity: expr is good for simple counters. bc includes math libraries (sine, cosine, log) and can handle complex logical statements.
3. Syntax: expr requires strict spacing and escaping of wildcards. bc usually takes input via pipes or redirection.

Calculating using bc:
To calculate floating-point results, we use the -l flag (math library) and set the scale.

bash

Formula: 4 * arctan(1) = pi

echo "scale=4; 4*a(1)" | bc -l

Output: 3.1412

Redirection is the process of changing the standard input/output sources. By default, standard input (stdin) is the keyboard, and standard output (stdout) is the screen.

Operators:

1. Output Redirection (>):

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

2. Append Output Redirection (>>):

   • Redirects standard output to a file but appends the data to the end of the file instead of overwriting it.
   • Example: date >> logfile.txt (Adds current date to the end of existing logs).

3. Input Redirection (<):

   • Feeds the content of a file into the standard input of a command.
   • Example: wc -l < filelist.txt (Counts lines in filelist.txt).

Definition:
A Pipe (|) is a mechanism that connects the Standard Output (stdout) of one command directly to the Standard Input (stdin) of another command. It allows for the chaining of utilities to perform complex tasks.

Difference from Redirection:

• Redirection: Connects a command to a file (Command File or File Command).
• Pipe: Connects a command to another command (Command Command).

Example Combining Both:
Scenario: List all files, sort them in reverse order, and save the result to a file.

bash
ls -l | sort -r > sorted_files.txt

1. ls -l generates the list.
2. | passes that list to sort -r.
3. > redirects the final sorted output to sorted_files.txt.

bash

!/bin/bash

echo "Enter Two numbers : "
read a
read b

echo "Enter Choice :"
echo "1. Addition"
echo "2. Subtraction"
echo "3. Multiplication"
echo "4. Division"
read ch

case $ch in
1)res=expr b
echo "Result: $res";;
2)res=expr b
echo "Result: $res";;
3)res=expr b
echo "Result: $res";;
4)res=echo "scale=2; b" | bc
echo "Result: $res";;
*)echo "Invalid Choice";;
esac

Explanation:

• The script reads two numbers and a choice.
• The case statement matches variable $ch against patterns (1, 2, 3, 4).
• expr handles integer math, and bc is used for division to handle floating points.

Syntax:
bash
if [ condition1 ]; then

commands if condition1 is true

elif [ condition2 ]; then

commands if condition2 is true

else

commands if none are true

fi

Role of test or [ ]:

• The square brackets [ ] are actually a reference to the test command.
• They evaluate the expression inside them and return a status code (0 for True, 1 for False).
• Important: Spaces are mandatory after the opening bracket [ and before the closing bracket ]. Without spaces, the shell treats it as a syntax error.
• Example: if [ b ] checks if variable a is greater than b.

The for loop iterates over a list of items or a sequence of numbers.

1. Iterate over a List (Strings/Files):
bash
for var in list_item1 list_item2 ...
do
command $var
done

Example: for file in *.txt; do echo "Found $file"; done

2. Iterate over a Number Range (Brace Expansion):
bash
for i in {1..5}
do
echo "Number $i"
done

3. C-Style Syntax:
Similar to C programming language.
bash
for (( i=1; i<=5; i++ ))
do
echo "Counter: $i"
done

Both loops execute a block of code repeatedly based on a condition, but their logic is inverted.

1. While Loop:

• Logic: Executes the block as long as the condition is True.
• It stops when the condition becomes False.
• Syntax: while [ condition ]
• Example: Keep running while count is less than 5.

2. Until Loop:

• Logic: Executes the block as long as the condition is False.
• It stops when the condition becomes True.
• Syntax: until [ condition ]
• Example: Keep running until count is greater than 5.

Summary: until [ condition ] is effectively equivalent to while [ ! condition ].

Declaration:
Indexed arrays use integers as keys (starting from 0).
bash

Method 1: Explicit declaration

declare -a my_array

Method 2: Direct assignment

fruits=("Apple" "Banana" "Cherry")

Method 3: Index assignment

fruits[3]="Date"

Accessing:

• Single Element: ${fruits[1]} (Returns "Banana")
• All Elements: {fruits[*]}

Iteration Snippet:
bash
fruits=("Apple" "Banana" "Cherry")

Iterate using @ to get all elements

for item in "${fruits[@]}"
do
echo "Fruit: $item"
done

Associative Arrays:
Also known as key-value pairs or dictionaries (similar to HashMaps in Java/Python). Unlike indexed arrays, the keys are strings, not integers.

Difference from Indexed Arrays:

• Indexed: Keys are automatically generated integers ($0, 1, 2...$).
• Associative: Keys are user-defined strings (e.g., "name", "age").
• Requirement: Must be explicitly declared using declare -A in Bash v4+.

Snippet:
bash

1. Declaration (Mandatory)

declare -A user_info

2. Assignment

user_info[name]="John"
user_info[role]="Admin"

3. Accessing

echo "User {user_info[role]}"

Creating Functions:
Functions are blocks of code that can be reused. They must be defined before they are called.

Syntax:
bash
function_name () {

commands

}

OR

function function_name {

commands

}

Variable Scope:

1. Global (Default): By default, all variables defined inside a function are global. If you change a variable inside a function, it changes in the main script too.
2. Local: To restrict a variable to the function's scope, use the local keyword.

Example:
bash
func() {
local x=10 # Visible only here
y=20 # Visible globally
}

Passing Parameters:
Parameters are passed to functions exactly like command-line arguments to a script—by listing them after the function name separated by spaces.

Call: my_function arg1 arg2

Accessing Parameters:
Inside the function, positional parameters are used:

• $1: The first argument.
• $2: The second argument.
• $#: The number of arguments passed.
• $@: All arguments as a list.

Note: $0 inside a function still refers to the script's filename, not the function name.

Example:
bash
greet() {
echo "Hello, $1!"
}
greet "Alice" # Outputs: Hello, Alice!

bash

!/bin/bash

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

FILE=$1

if [ -e "$FILE" ]; then
echo "$FILE exists."

if [ -f "$FILE" ]; then
    echo "It is a regular file."
elif [ -d "$FILE" ]; then
    echo "It is a directory."
fi

# Display permissions
echo "Permissions: FILE | awk '{print $1}')"

else
echo "$FILE does not exist."
fi

Key Concepts:

• $1: First argument.
• -e: Check existence.
• -f: Check if file.
• -d: Check if directory.
• ls -l: Used to retrieve permission string.

• $0: The name of the script currently being executed.
• $?: The exit status of the last executed command. 0 usually means success, while non-zero indicates failure.
• $$: The Process ID (PID) of the current shell script. Useful for creating unique temporary filenames.
• $#: The count (number) of arguments passed to the script or function.
• **1" "$2" ...) when quoted, preserving whitespace within arguments.

bash

!/bin/bash

echo "Enter a number:"
read num

fact=1
counter=$num

Check for negative input

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

while [ $counter -gt 1 ]
do
fact=$((fact * counter))
counter=$((counter - 1))
done

echo "The factorial of fact"

Logic:

1. Initialize fact to 1.
2. Loop while the counter (starting at num) is greater than 1.
3. Multiply fact by counter and decrement counter.
4. Print the result.

1. Soft Quoting (Double Quotes " "):

• Preserves the literal value of most characters but allows substitution of variables ($), backticks (command substitution), and escape characters (\).
• Example:
  bash
  name="John"
  echo "Hello $name" # Output: Hello John

2. Hard Quoting (Single Quotes ' '):

• Preserves the literal value of every character within the quotes. No substitution occurs.
• Example:
  bash
  name="John"
  echo 'Hello name

Summary: Use double quotes when you need to interpolate variables; use single quotes when you want the string exactly as written.

Command Substitution:
It allows the output of a command to replace the command itself. The shell executes the command and substitutes the standard output into the command line.

1. Backticks (`command`):

• The legacy syntax.
• Example: DATE=\date``
• Drawback: Hard to nest and confusing to read (often mistaken for single quotes).

2. Dollar Parentheses ($(command)):

• The modern, preferred syntax.
• Example: DATE=$(date)
• Advantage: It allows easy nesting (cmd1 (cmd3))) and is visually distinct.

Conclusion: $( ) is recommended over backticks for readability and nesting capabilities.

bash

!/bin/bash

echo "Enter the number of terms:"
read N

a=0
b=1

echo "The Fibonacci series is:"

for (( i=0; i<N; i++ ))
do
echo -n "$a "

# Calculate next term
fn=$((a + b))
a=$b
b=$fn

done
echo "" # New line at end

Logic:

1. Initialize a=0, b=1.
2. Use a C-style for loop running times.
3. Print a.
4. Calculate sum fn = a + b.
5. Update values: a becomes b, and b becomes fn.