Introduction to Shell Scripting

The Linux operating system's command-line interface, the shell, is a tool that allows users to create scripts or programs. Shell scripts are essentially text files containing a sequence of commands that the shell can execute.

By writing shell scripts, you can automate repetitive tasks such as file backups, system updates, or directory cleaning, significantly reducing the risk of human error and saving time. Scripts enable the chaining of multiple commands into a single workflow, simplifying complex tasks. They are integral to scheduling regular tasks using cron jobs, a feature that allows for tasks to be automated without direct human intervention. System administrators find shell scripting indispensable for monitoring system performance, automating routine maintenance, and managing user accounts. For individual users, shell scripts offer a way to personalize their computing environment, including setting up system variables and customizing terminal startup processes. Shell scripting stands out for its ease of use and rapid prototyping capabilities, making it ideal for quickly developing complex programs. Its portability is another key advantage, as scripts can typically run across various Unix-like systems without modification. Shell scripting is also incredibly powerful for file manipulation, enabling efficient searching, editing, and moving of files. It allows for the seamless integration and extension of different command-line tools, enhancing their functionality. Moreover, when combined with tools like sed, awk, and grep, shell scripting becomes a robust solution for complex text processing tasks, making it an essential skill for those beginning their journey in Linux and programming.

In Linux, several different shells are available, each with unique features and capabilities. Some of the most commonly used shells include:

  1. Bash (Bourne-Again SHell): This is the most popular shell in Linux. It's an enhanced, backwards-compatible version of the Bourne Shell (sh). Bash is the default shell on most Linux distributions and macOS, renowned for its ease of use, efficiency, and powerful scripting capabilities.

  2. Tcsh/Csh (TENEX C Shell): An enhanced version of the original C shell (csh). It's user-friendly with a syntax akin to the C programming language, making it appealing to C programmers.

  3. Zsh (Z Shell): Known for its interactive use and as an extended Bourne shell with many improvements, including features from Bash, ksh, and tcsh.

  4. Ksh (Korn Shell): An enhanced version of the original Bourne Shell, incorporating features of both Csh and Bash. It's known for its efficiency in both scripting and interactive use.

  5. Fish (Friendly Interactive Shell): A user-friendly, interactive shell with features like syntax highlighting, autosuggestions, and a web-based configuration interface.

The reasons why Bash is the most widely used shell in Linux are:

  1. Default Shell on Many Systems: Bash is the default shell on most Linux distributions, as well as macOS, which contributes significantly to its widespread use.

  2. Compatibility with Bourne Shell: Bash is compatible with the Bourne Shell (sh), which means it can run scripts written for sh without modification.

  3. Rich Feature Set: It offers a wide range of features, including command-line editing, job control, functions, aliases, and arrays, making it a powerful tool for both interactive use and scripting.

  4. Extensive Scripting Capabilities: Bash's scripting capabilities are robust, offering features like loops, conditionals, and case statements that enable writing complex scripts.

  5. Wide Community Support: Being the most popular shell, Bash has a large community, which means extensive documentation, tutorials, and forums are available for learning and troubleshooting.

  6. Portability: Bash scripts are portable across different Unix-like systems, making them convenient for users with multiple platforms.

  7. History and Continuity: Bash has been around since the late 1980s, and its enduring presence in the Unix/Linux world has led to a deep familiarity and preference among system administrators and programmers.

Writing a basic shell script in Linux using the nano text editor is a straightforward process. Here's a step-by-step guide:

Step 1: Open Nano Editor

  • Open your terminal.

  • Type nano and press Enter. This command opens the nano editor and creates a new file named

Step 2: Write the Script

  • Start the script with a shebang (#!/bin/bash). This line tells the system that this file should be run in the Bash shell, regardless of which shell the user is currently in. It's essential because it ensures that the correct interpreter is used to execute your script. Without it, the system might use a different shell that doesn't understand your script's syntax.

  • Write your script below the shebang. For a simple example, let's just echo a message:

      echo "Hello, world!"

Step 3: Save the Script in Nano

  • Press Ctrl + O (Write Out) to save the file. The bottom of the nano window will prompt you to confirm the file name. If "" is correct, press Enter.

  • Press Ctrl + X to exit nano.

Step 4: Make the Script Executable

  • Back in the terminal, type chmod +x and press Enter. This command changes the file's permissions, making it executable. The +x means "add execute permission."

Step 5: Run the Script

  • Run the script by typing ./ and pressing Enter. You should see "Hello, world!" printed on the screen.


  1. Filename Convention: The .sh extension is a common convention for shell scripts but not mandatory. The system identifies shell scripts by the shebang, not the file extension.

  2. Script Permissions: Making the script executable is crucial; otherwise, the system won't allow you to run it.

  3. Running the Script: The ./ before the script name is necessary when running an executable in the current directory because, by default, the current directory is not in the system's PATH.

By following these steps, you can create, edit, save, and run basic shell scripts in Linux using the nano editor. This process is fundamental for anyone beginning to learn about Linux scripting and system administration.

Explaining #!/bin/bash

  • What It Is: The shebang line (#!/bin/bash) is the first line in a shell script.

  • Purpose: It specifies the interpreter that should be used to execute the script. In this case, /bin/bash indicates that the Bash shell interpreter should be used.

  • Syntax: It starts with #! followed by the path to the interpreter.

Why It's Important

  • Determines the Interpreter: Without the shebang, the system doesn't know which interpreter to use, and it defaults to using the current shell. This can lead to inconsistencies and errors if the script uses features specific to a particular shell (like Bash) but gets executed in a different shell.

  • Portability: The shebang line helps ensure the script runs correctly on different systems, regardless of the user's default shell.

Variables in Bash scripting are an essential concept. They are used to store data that can be referenced and manipulated within the script. Understanding how to create, assign, and use variables is crucial for writing effective Bash scripts.

They are names or identifiers that represent data stored in memory. This data can be a number, text, filename, or any other type of information. Variables allow you to store and manipulate data throughout your script, making your code more flexible and dynamic.

Creating and Assigning Variables

  1. Defining a Variable:

    • To define a variable in Bash, you simply write the variable name followed by an equals sign (=) and the value you want to assign to it.

    • Bash variable names can consist of letters, numbers, and underscores, but they cannot start with a number.

    • There should be no spaces around the equals sign.


    my_variable="Hello, World!"
  1. Variable Naming Conventions:

    • Variable names are typically lowercase by convention, but uppercase is often used for environment variables and constants.

    • Descriptive names are recommended for readability.

  2. Assigning Values:

    • You can assign strings, numbers, or the output of commands to variables.

    • For strings with spaces or special characters, enclose the value in quotes.


  1. Referencing Variables:

    • To use a variable, prefix it with a dollar sign ($).

    • For more complex expressions, enclose the variable name in curly braces ({}).


    echo $my_variable
    echo "The count is ${count}"
  1. Unsetting Variables:

    • You can remove a variable with the unset command.


    unset my_variable

Syntax Simplicity: Unlike many programming languages, Bash doesn't require a specific keyword (like var or let in JavaScript) to declare a variable.

Dynamic Typing: Variables in Bash are not bound to specific data types; the same variable can hold a number, a string, or any other data type.

No Implicit Declaration: In some languages, using a variable automatically declares it. In Bash, using an undeclared variable will typically result in an empty string.

In Bash scripting, the read command is used to take input from the user. This command reads a line from the standard input (like the keyboard) and assigns it to a variable. Here's a simple example of how to use read to get input from a user and then echo it back with a message:

You can prompt the user for input by printing a message before the read command using echo or by using the -p option with read to display a prompt. The input entered by the user is stored in a variable, which is declared as part of the read command.

Here's a basic script that asks for the user's name and then greets them:


# Prompting the user
echo "Please enter your name:"

# Reading the input and storing it in a variable
read user_name

# Echoing back the input with a message
echo "Hello, $user_name! Welcome to Bash scripting!"

Alternatively, you can use the -p option with read to inline the prompt message:


# Reading the input with an inline prompt and storing it in a variable
read -p "Please enter your name: " user_name

# Echoing back the input with a message
echo "Hello, $user_name! Welcome to Bash scripting!"

In both examples, when the script runs, it waits for the user to input their name and press Enter. Whatever the user types is stored in the variable user_name, and then it's used in the echo command to display the greeting.

No Data Type Declaration: In Bash, variables are dynamically typed, so you don't need to declare their type before using them.

Handling Spaces: If the user's input might contain spaces (like a full name), read will handle this correctly, storing the entire line of input in the variable.

Script Interaction: Using read is a simple way to make your scripts interactive.

Command substitution in Bash scripting is a powerful feature that allows you to use the output of a command as an argument in another command or to assign it to a variable. It effectively captures the output of a command and places it in the context of another command or assignment. There are two ways to perform command substitution in Bash:

1. Using Backticks (` )

  • Syntax: command

  • This is the older method for command substitution.

  • The command to be substituted is enclosed in backticks.

Example with echo:

echo "Today's date is `date`"

This command will print the current date as part of the message.

Example of assigning to a variable:

echo "The date is $current_date"

Here, the output of the date command is stored in the current_date variable.

2. Using $()

  • Syntax: $(command)

  • This is the preferred method in modern scripting as it's more readable and can easily be nested.

  • The command to be substituted is enclosed in $().

Example with echo:

echo "Today's date is $(date)"

This does the same as the first example but uses the $() syntax.

Example of assigning to a variable:

echo "The date is $current_date"

Similarly, this stores the output of date in current_date.

Nesting: $() can be nested, which means you can use command substitution within another command substitution. This is trickier with backticks and one of the reasons $() is preferred.

Consider a scenario where you want to create a directory named with the current date:

mkdir "backup_$(date +%F)"

Here, date +%F generates the date in YYYY-MM-DD format, and $(date +%F) substitutes that output to form the directory name like backup_2023-01-21.

Conditional statements in Bash scripting allow you to execute different commands or set of commands based on certain conditions. The primary conditional statements are if, else, and elif (else if). They are used to perform actions based on whether a particular condition is true or false.

Basic Syntax of Conditional Statements

if [ condition ]; then
    # commands to execute if condition is true
elif [ another_condition ]; then
    # commands to execute if another_condition is true
    # commands to execute if none of the above conditions are true

Operators for Condition Tests

In Bash, various operators can be used within [ ] to form conditions:

  • String Comparisons:

    • = or ==: String equality (e.g., [ "$str1" = "$str2" ])

    • !=: String inequality (e.g., [ "$str1" != "$str2" ])

    • -z: String is null, that is, has zero length

  • Numeric Comparisons:

    • -eq: Equal (e.g., [ "$num1" -eq "$num2" ])

    • -ne: Not equal

    • -gt: Greater than

    • -ge: Greater than or equal to

    • -lt: Less than

    • -le: Less than or equal to

  • File Tests:

    • -e: File exists

    • -f: File exists and is a regular file

    • -d: Directory exists

    • -r: File exists and is readable

    • -w: File exists and is writable

    • -x: File exists and is executable

Example: Using if, elif, and else


read -p "Enter a number: " num

if [ "$num" -lt 10 ]; then
    echo "Number is less than 10."
elif [ "$num" -eq 10 ]; then
    echo "Number is equal to 10."
    echo "Number is greater than 10."

In this example, the script prompts the user to enter a number. It then uses if, elif, and else to check if the number is less than, equal to, or greater than 10 and prints an appropriate message.

Key Points

  • Spacing is Important: Note the space after [ and before ] in the condition.

  • Use Double Quotes: It's a good practice to enclose variable references in double quotes within test brackets to handle empty or multi-word strings correctly.

Let's go through examples for each of the categories of tests in Bash scripting: string comparisons, numeric comparisons, and file tests.

1. String Comparisons

  • String Equality: Checks if two strings are equal.

      if [ "$str1" = "$str2" ]; then
          echo "Strings are equal."
          echo "Strings are not equal."
  • String Inequality: Checks if two strings are not equal.

      if [ "$str1" != "$str2" ]; then
          echo "Strings are not equal."
          echo "Strings are equal."
  • String is Null: Checks if a string has zero length.

      if [ -z "$empty_string" ]; then
          echo "String is null."
          echo "String is not null."

2. Numeric Comparisons

  • Equal: Checks if two numbers are equal.

      if [ "$num1" -eq "$num2" ]; then
          echo "Numbers are equal."
          echo "Numbers are not equal."
  • Not Equal: Checks if two numbers are not equal.

      if [ "$num1" -ne "$num2" ]; then
          echo "Numbers are not equal."
          echo "Numbers are equal."
  • Greater Than: Checks if one number is greater than another.

      if [ "$num1" -gt "$num2" ]; then
          echo "$num1 is greater than $num2."
          echo "$num1 is not greater than $num2."
  • Greater Than or Equal To: Checks if one number is greater than or equal to another.

      if [ "$num1" -ge "$num2" ]; then
          echo "$num1 is greater than or equal to $num2."
          echo "$num1 is less than $num2."
  • Less Than: Checks if one number is less than another.

      if [ "$num1" -lt "$num2" ]; then
          echo "$num1 is less than $num2."
          echo "$num1 is not less than $num2."
  • Less Than or Equal To: Checks if one number is less than or equal to another.

      if [ "$num1" -le "$num2" ]; then
          echo "$num1 is less than or equal to $num2."
          echo "$num1 is greater than $num2."

3. File Tests

  • File Exists: Checks if a file exists.

      if [ -e "$file_path" ]; then
          echo "File exists."
          echo "File does not exist."
  • Regular File: Checks if the file exists and is a regular file.

      if [ -f "$file_path" ]; then
          echo "File is a regular file."
          echo "File is not a regular file."
  • Directory Exists: Checks if a directory exists.

      if [ -d "$dir_path" ]; then
          echo "Directory exists."
          echo "Directory does not exist."
  • File Readable: Checks if a file exists and is readable.

      if [ -r "$file_path" ]; then
          echo "File is readable."
          echo "File is not readable."
  • File Writable: Checks if a file exists and is writable.

      if [ -w "$file_path" ]; then
          echo "File is writable."
          echo "File is not writable."
  • File Executable: Checks if a file exists and is executable.

      if [ -x "$file_path" ]; then
          echo "File is executable."
          echo "File is not executable."

These examples illustrate the basic usage of string, numeric, and file test operations in Bash scripting, allowing you to create conditional logic based on various types of comparisons and file states.

In Bash, the (( )) construct allows you to use a C-like syntax for arithmetic evaluations and conditions in if statements. This feature enhances readability and convenience, especially for those familiar with C or similar programming languages.

How (( )) Works in Bash

  • Arithmetic Evaluation: The (( )) construct is used for arithmetic operations and evaluations. Inside (( )), you can use operators like +, -, *, /, >, <, <=, >=, ==, !=, etc., just like in C.

  • Return Value: When used in conditions, if the result of the arithmetic expression inside (( )) is non-zero, it returns a success (true) exit status; if it's zero, it returns a failure (false) exit status.

  • No Need for $ for Variables: Inside (( )), you can reference variables without using the $ prefix.

Examples Using (( )) in if Statements

  1. Basic Arithmetic Comparison:

     if (( num1 < num2 )); then
         echo "$num1 is less than $num2"

    This script compares two numbers using a less-than operator.

  2. Combining Multiple Conditions:

     if (( num1 > 5 && num2 < 25 )); then
         echo "Both conditions are met."

    Here, we're checking if num1 is greater than 5 and num2 is less than 25.

  3. Incrementing a Variable:

     if (( counter++ )); then
         echo "Counter is now $counter"

    In this example, counter is incremented using the C-style ++ operator.

  4. Using Arithmetic Operators:

     if (( num1 + num2 == 30 )); then
         echo "The sum of num1 and num2 is 30"

    This demonstrates using the addition operator and equality check.

    Arithmetic Context: The (( )) construct is specifically for arithmetic operations and evaluations. It's not intended for string comparisons or file tests.

    More Readable for Arithmetic: It makes arithmetic expressions and comparisons more readable and familiar, especially for those with experience in C-like programming languages.

    Shell-Specific: Remember that this syntax is specific to Bash and other modern POSIX-like shells. It may not work in all shell environments.

In Bash scripting, loop constructs are used to repeat a set of commands multiple times. The three primary types of loops are for, while, and until. Each serves a different purpose and is used based on the specific requirements of the task.

1. for Loop

The for loop in Bash iterates over a list of items or a range of values.

for variable in item1 item2 ... itemN
for i in 1 2 3 4 5
   echo "Welcome $i times"

This loop will print the welcome message five times, with $i taking values from 1 to 5.

2. while Loop

The while loop executes a set of commands as long as the given condition is true.

while [ condition ]
while [ $count -le 5 ]
   echo "Welcome $count times"
   count=$((count + 1))

This while loop will continue executing until count exceeds 5.

3. until Loop

The until loop is similar to the while loop, but it runs until the condition becomes true.

until [ condition ]
until [ $count -gt 5 ]
   echo "Welcome $count times"
   count=$((count + 1))

This until loop executes as long as count is not greater than 5.

Loop Control: You can use break to exit a loop prematurely and continue to skip the rest of the loop body for the current iteration.

C-style for Loop: Bash also supports a C-style for loop syntax, which is particularly useful for arithmetic operations.

C-style for Loop Example:

for (( i=0; i<5; i++ ))
   echo "Welcome $i times"

This loop behaves like a traditional C-style for loop, incrementing i from 0 to 4.

String manipulation in Bash scripting is quite versatile and allows you to perform various operations on strings. Here are some of the fundamental string operations you can perform:

1. String Length

  • To find the length of a string: Use ${#string}.

      str="Hello World"
      echo "The length of '$str' is ${#str}"

2. Substring Extraction

  • Extracting a substring: ${string:start:length}.

      str="Hello World"
      # Extract 'World' from str
      echo "${str:6:5}"

3. Substring Replacement

  • Replace first occurrence of a substring: ${string/pattern/replacement}.

  • Replace all occurrences: ${string//pattern/replacement}.

      str="Hello World"
      echo "${str/World/Universe}"  # Replaces 'World' with 'Universe'

4. Extracting a Single Character

  • To extract a single character: Similar to substring extraction, but with length 1.

      # Extract first character 'H'
      echo "${str:0:1}"

5. Checking if String is Empty or Not

  • To check if a string is empty: Use -z in a conditional statement.

      if [ -z "$str" ]; then
          echo "String is empty."
          echo "String is not empty."

6. Concatenating Strings

  • Simply place two string variables together:

      echo "$str1 $str2"

7. String Case Conversion

  • Convert to uppercase: ${string^^}.

  • Convert to lowercase: ${string,,}.

      str="Hello World"
      echo "${str^^}"  # Converts to uppercase
      echo "${str,,}"  # Converts to lowercase

8. Checking if String Contains a Substring

  • Use [[ ]] and * wildcard for pattern matching:

      str="Hello World"
      if [[ $str == *"World"* ]]; then
          echo "String contains 'World'"

9. Comparing Strings

  • For equality and inequality, use = and != inside [ ]:

      if [ "$str1" = "$str2" ]; then
          echo "Strings are equal."
          echo "Strings are not equal."

To iterate through each character of a string in Bash and perform an action on each character, you can use a for loop along with substring extraction. Here's an example script that demonstrates this by going through each character in a string and printing it with a message:



for (( i=0; i<$len; i++ )); do
    echo "Character at position $i is '$char'"

In this script:

  • str holds the string you want to iterate over.

  • len is used to store the length of the string.

  • The for loop iterates from 0 to len-1, which are the indices of the characters in the string.

  • In each iteration, ${str:$i:1} extracts the character at position i.

  • The echo command then prints the character along with its position.

This script will output each character of "Hello" on a new line with its corresponding position in the string.

Performing arithmetic operations in Bash scripting can be done in several ways, each suited for different scenarios. Here are the common methods to perform arithmetic in Bash:

1. The Basic expr Command

Bash uses the expr command for basic arithmetic operations. It's an external program that evaluates expressions.

result=$(expr $operand1 operator $operand2)


result=$(expr 2 + 3)
echo $result  # Outputs 5

Note: When using expr, ensure there are spaces around operators and operands.

2. Arithmetic Expansion $(( ))

Arithmetic expansion allows the evaluation of an arithmetic expression and the substitution of the result. This is the preferred method for arithmetic operations in Bash.

result=$(( expression ))


result=$(( 2 + 3 ))
echo $result  # Outputs 5

3. Using let Command

The let command is used for arithmetic operations; it evaluates each argument as an arithmetic expression.

let result=expression


let result=2+3
echo $result  # Outputs 5

Note: No spaces are allowed around operators and operands when using let.

4. Floating Point Arithmetic

Bash does not natively support floating-point arithmetic. For such operations, bc or awk are commonly used.

Using bc Example:

result=$(echo "scale=2; 3/2" | bc)
echo $result  # Outputs 1.50

Common Arithmetic Operations

  • Addition (+): result=$(( num1 + num2 ))

  • Subtraction (-): result=$(( num1 - num2 ))

  • Multiplication (*): result=$(( num1 * num2 ))

  • Division (/): result=$(( num1 / num2 ))

  • Modulus (%): result=$(( num1 % num2 ))

  • Increment (++): (( num++ ))

  • Decrement (--): (( num-- ))

Integer Arithmetic: By default, Bash performs integer arithmetic. If you divide two integers, it will return an integer result (rounded down).

Quoting: In arithmetic expansion, it's not necessary to quote variables.

Floating-Point Precision: For operations requiring decimal precision, use bc or awk.

The bc command in Bash is a powerful tool for performing precise floating-point arithmetic. It's especially useful because Bash itself only supports integer arithmetic natively. The scale in bc sets the number of decimal places for the result of division operations.

Here's a more detailed example demonstrating various operations using bc, including how scale affects the output:


# Assign numbers to variables

# Addition
addition=$(echo "$num1 + $num2" | bc)
echo "Addition: $num1 + $num2 = $addition"

# Subtraction
subtraction=$(echo "$num1 - $num2" | bc)
echo "Subtraction: $num1 - $num2 = $subtraction"

# Multiplication
multiplication=$(echo "$num1 * $num2" | bc)
echo "Multiplication: $num1 * $num2 = $multiplication"

# Division with default scale (0)
division=$(echo "$num1 / $num2" | bc)
echo "Division with default scale (0): $num1 / $num2 = $division"

# Division with scale set to 2
division_scale_2=$(echo "scale=2; $num1 / $num2" | bc)
echo "Division with scale set to 2: $num1 / $num2 = $division_scale_2"

# Modulus (remainder of division)
# Note: Modulus only works with integers in bc
modulus=$(echo "$num1 % $num2" | bc)
echo "Modulus: $num1 % $num2 = $modulus"

# Power (num1 raised to the num2)
power=$(echo "$num1 ^ $num2" | bc)
echo "Power: $num1 ^ $num2 = $power"
  • addition, subtraction, multiplication: These operations are straightforward in bc.

  • division with default scale: By default, scale is set to 0, so it performs integer division.

  • division with scale=2: Setting scale=2 computes the division up to two decimal places.

  • modulus: The modulus operation in bc only works with integers. If the operands are not integers, they will be truncated to integers before the operation.

  • power: Calculates the power of one number to another.

What is scale in bc?

  • scale specifies the number of decimal digits to be retained to the right of the decimal point in division operations.

  • It only affects the division operation. Other operations like addition, subtraction, and multiplication use the full precision of the operands.

Usage Notes:

  • Remember to enclose the bc commands in $(...) for command substitution.

  • Expressions for bc are passed as strings, hence the use of quotes and piping with echo.

  • For more complex calculations or when working with floating-point numbers, bc is a much-needed tool in Bash scripting.

Arrays in Bash scripting provide a way to store and manipulate a collection of values. Here's a detailed guide on how to use and manipulate arrays in Bash:

Defining and Initializing Arrays

  • Simple Initialization:

      array_name=(value1 value2 value3)
  • With Explicit Indices:

      array_name=([3]=value1 [5]=value2 [10]=value3)

Accessing Array Elements

  • Individual Element:

      echo ${array_name[index]}
  • All Elements:

      echo ${array_name[@]}  # or ${array_name[*]}

Modifying Arrays

  • Setting a Value at a Specific Index:

  • Appending a Value:


Deleting Elements

  • Remove Element at Index:

      unset array_name[index]

    Note: Unsetting an element does not reindex the array.

Array Length

  • Length of the Entire Array:

      echo ${#array_name[@]}
  • Length of a Specific Element:

      echo ${#array_name[index]}

Extracting Sub-Arrays

  • Sub-array from an Index:

      echo ${array_name[@]:start:length}

Looping Over Arrays

  • Loop Over Values:

      for val in "${array_name[@]}"; do
          echo $val
  • Loop Over Indices:

      for i in "${!array_name[@]}"; do
          echo "Index: $i, Value: ${array_name[$i]}"

Associative Arrays (Key-Value Pairs)

  • Declaring an Associative Array:

      declare -A assoc_array
  • Setting Key-Value Pairs:



  1. Initializing an Array and Accessing Elements:

     colors=("red" "green" "blue")
     echo "First color: ${colors[0]}"  # Outputs 'red'
  2. Modifying and Appending:

     colors[1]="yellow"  # Change 'green' to 'yellow'
     colors+=( "orange" )  # Append 'orange'
  3. Looping Over Array Values:

     for color in "${colors[@]}"; do
         echo "Color: $color"
  4. Creating and Using Associative Arrays:

     declare -A fruits
     for fruit in "${!fruits[@]}"; do
         echo "$fruit is ${fruits[$fruit]}"

    Indexing: Bash arrays are zero-indexed by default.

    Sparse Arrays: Bash supports sparse arrays, meaning indexes do not have to be sequential.

    Quoting is Important: Especially when expanding arrays to avoid unexpected word splitting and globbing.

Word splitting occurs when Bash splits a string into multiple words based on the presence of spaces, tabs, or newlines. Globbing refers to the expansion of wildcard characters (like * and ?) into filenames.

Example Without Proper Quoting

Consider an array containing file paths, some of which might contain spaces:

files=("file1.txt" "my document.pdf" "image.png")

# Incorrect: Without proper quoting
for file in ${files[@]}; do
    echo "Processing $file"

In this example, my document.pdf will be treated as two separate words, my and document.pdf, leading to incorrect processing.

Example With Proper Quoting

Using quotes correctly prevents this issue:

files=("file1.txt" "my document.pdf" "image.png")

# Correct: With proper quoting
for file in "${files[@]}"; do
    echo "Processing $file"

Here, each element of the array is treated as a single word, even if it contains spaces. This means my document.pdf will be correctly handled as a single filename.

Always Quote Array Expansions: When expanding an array (${files[@]} or ${files[*]}), always enclose it in double quotes.

Use Double Quotes for Strings with Spaces: To ensure that a string with spaces is treated as a single entity, enclose it in double quotes.

Avoid Unintended Filename Expansion: Quoting also prevents the shell from performing filename expansion on glob characters like * and ?.

Here's a shell script that demonstrates linear search using arrays. It first accepts a number n, then reads n values from the user into an array, then accepts another value x. The script will then check if x exists in the array and output an appropriate message.


# Read the number of elements
read -p "Enter the number of elements (n): " n

# Initialize an empty array
declare -a values

# Read n values from the user
echo "Enter $n values:"
for (( i=0; i<n; i++ )); do
    read value

# Read the value to search for (x)
read -p "Enter the value to search for (x): " x

# Flag to track if x is found

# Loop over the array to check if x exists
for val in "${values[@]}"; do
    if [ "$val" == "$x" ]; then

# Output the result
if [ $found -eq 1 ]; then
    echo "$x does exist in the array."
    echo "$x does not exist in the array."
  1. Reading n:

    • The script starts by reading the number n which represents how many values will be entered.

    • read -p is used to prompt the user.

  2. Initializing and Populating the Array:

    • An array named values is declared and initialized.

    • A for loop runs n times to read values from the user. Each value is added to the values array using values+=("$value").

  3. Reading the Search Value x:

    • Another read -p is used to get the value of x, which will be searched in the array.
  4. Searching for x in the Array:

    • A for loop iterates over each element in the values array.

    • If a value matching x is found, the found flag is set to 1, and the loop is exited using break.

  5. Outputting the Result:

    • An if statement checks the found flag. If found is 1 (true), it means x was found in the array, and the script echoes that x does exist.

    • If found is 0 (false), the script echoes that x does not exist in the array.

Functions in Bash scripting are similar to functions in other programming languages. They are used to encapsulate a group of commands for executing a particular task. Understanding how to define, call, pass arguments, return values, and handle variable scope is essential for writing efficient and modular scripts.

Defining Functions

  • Basic Syntax:

      function_name() {
          # Commands


      function function_name {
          # Commands

Calling Functions

  • To call a function, just use its name:


Passing Arguments

  • Arguments are passed just like command line arguments:

      function_name arg1 arg2
  • Inside the function, arguments are accessed using $1, $2, etc.

Returning Values

  • Use return to exit a function with a status (numeric).

      return 0  # Success
      return 1  # Failure
  • To return a string or a value, use command substitution:


Variable Scope

  • Variables are global by default in Bash.

  • To create a local variable within a function, use the local keyword:

      function my_func {
          local local_var="I am local"

Naming Functions

  • Use descriptive names.

  • Follow conventions similar to variable naming (use underscores to separate words).

Name Hiding

  • A function name can hide a command name. If a function and a command have the same name, the function is executed.

# Function definition
greet() {
    local name=$1
    echo "Hello, $name!"

# Calling the function
greet "Alice"

# Function returning a value
add() {
    local sum=$(( $1 + $2 ))
    echo $sum

# Capturing function output
result=$(add 5 10)
echo "Sum is: $result"
  • greet: This function takes one argument and prints a greeting. The local keyword ensures name is a local variable.

  • Calling greet: The function is called with the argument "Alice".

  • add: This function takes two numbers as arguments, adds them, and echoes the result.

  • Capturing Output from add: The output of add is captured into result.

    Global by Default: Variables in Bash are global unless declared local within a function.

    Argument Passing: Arguments are passed by position ($1, $2, ...).

    Return Status: return sets the exit status of the function, not the output. It's similar to exit status of commands.

    Output vs. Return Status: To return data (like strings or calculated values), echo the output and capture it using command substitution. return is used for exit status (0 for success, non-zero for failure).

In Bash scripting, differentiating between the "output" of a function and its "return status" is crucial. The "output" refers to what the function prints to stdout (standard output), which can be captured by command substitution. The "return status" is a numeric value that indicates the success or failure of the function's execution. Let's clarify this with an example:

Suppose we have a script that calculates the factorial of a number. The factorial result will be the "output," and the "return status" will indicate whether the operation was successful.


# Function to calculate factorial
factorial() {
    local number=$1
    local result=1

    # Error handling: Return status 1 if input is not a positive integer
    if ! [[ "$number" =~ ^[0-9]+$ ]]; then
        echo "Error: Input is not a positive integer."
        return 1  # Failure return status

    # Calculate factorial
    for (( i=2; i<=number; i++ )); do
        result=$((result * i))

    echo $result  # Output the result
    return 0  # Success return status

# Using the factorial function
result=$(factorial "$number")

if [ $status -eq 0 ]; then
    echo "Factorial of $number is: $result"
    echo "Failed to calculate factorial." >&2
  • factorial: This function takes an integer and calculates its factorial.

  • Error Handling:

    • The function checks if the input is a positive integer. If not, it prints an error message indicating failure.
  • Calculating Factorial:

    • If the input is valid, the function calculates the factorial and echoes the result. This echo statement is the "output" of the function.
  • Return Status:

    • The function returns 0 to indicate success.
  • Using factorial:

    • The script calls the factorial function, capturing its output (result) using command substitution.

    • The $? variable captures the "return status" of the last executed command (which is the factorial function here).

  • Output vs. Return Status:

    • The script checks the return status. If it's 0 (success), it prints the factorial result. Otherwise, it prints an error message.

Output: Captured by command substitution and represents the data produced by the function.

Return Status: Numeric value (typically 0 for success, non-zero for failure) indicating the success or failure of the function.

Command Substitution vs. $?: Command substitution $(...) is used to capture the output, while $? captures the return status of the last command/function.

Command line arguments are a way to pass information to a Bash script when you execute it. These arguments are accessible within the script, allowing you to customize its behavior based on the inputs provided at runtime.

Accessing Command Line Arguments

  • $0, $1, $2, ..., $9: These are positional parameters. $0 is the script's name, $1 is the first argument, $2 is the second, and so on.

  • $#: This gives the number of arguments passed to the script.

  • $@ or $*: These represent all the arguments. $@ treats each argument as a separate word, while $* treats all arguments as a single word.

  • For more than 9 arguments, use braces: ${10}, ${11}, etc.


# Display the script name
echo "Script Name: $0"

# Count the arguments
echo "Total number of arguments: $#"

# Loop through all arguments
echo "Arguments:"
for arg in "$@"; do
    echo "  - $arg"

# Handling more than 9 arguments
if [ $# -ge 10 ]; then
    echo "Tenth argument: ${10}"

Running the Script

If you save this script as and run it with bash arg1 arg2 arg3 ... arg10, it will display:

  • The script name.

  • The total number of arguments.

  • Each argument separately.

  • The tenth argument if it exists.


  • Script Name ($0): Displays the name of the script.

  • Number of Arguments ($#): Counts how many arguments were passed.

  • Looping Over Arguments ($@): The for loop iterates over each argument, printing them individually.

  • Accessing the Tenth Argument (${10}): Demonstrates how to access arguments beyond the ninth.

Key Points

  • Positional Parameters: $1, $2, ... are called positional parameters and are used to access individual arguments.

  • Quoting $@: When looping over arguments with $@, always quote it to handle arguments with spaces correctly.

  • Limitations: While there's no hard limit to the number of arguments a script can accept, practical constraints like maximum command line length can impose limits.

In Bash scripting and Unix-like systems, a subprocess is a process that is created and executed by another process (the parent process). A subshell, specifically, is a separate instance of the command interpreter (the shell). It's a child process of the shell that runs a script or a command.

Subshell Creation

  • Using Parentheses ( ): Commands inside parentheses are executed in a subshell.

      (command1; command2)

    Here, command1 and command2 run in a subshell.

Using && and || Operators

  • && (AND Operator): Executes the second command only if the first command succeeds (returns 0).

  • || (OR Operator): Executes the second command only if the first command fails (returns non-zero).

Exit Status Conventions

  • 0 for Success: In Unix-like systems, a command returning an exit status of 0 indicates success.

  • Non-Zero for Failure: Any non-zero status indicates failure. Different non-zero values can represent different types of errors.


  • With &&: If the first command fails, the second command is not executed.

  • With ||: If the first command succeeds, the second command is not executed.

Example 1: Using && for Sequential Commands

mkdir new_directory && cd new_directory
  • Here, cd new_directory is executed only if mkdir new_directory succeeds.

Example 2: Using || for Fallback Commands

gcc program.c -o program || echo "Compilation failed."
  • If the compilation (gcc) fails, the message "Compilation failed." is printed.

Example 3: Combining && and ||

rm old_backup.tar.gz && echo "Old backup removed." || echo "No old backup found."
  • If rm old_backup.tar.gz succeeds, "Old backup removed." is printed.

  • If rm old_backup.tar.gz fails, "No old backup found." is printed.

Example 4: Using Subshell for Isolated Execution

(cd /tmp && tar -xzvf package.tar.gz)
  • Here, changing the directory and extracting a file occurs in a subshell. The parent shell's current directory is not changed.

&& and ||: These operators allow for conditional execution of commands based on the success or failure of previous commands. This mechanism is crucial for scripting where the flow depends on the outcomes of various steps.

Short-Circuiting: It's a performance feature; if the outcome is already determined, subsequent operations are skipped.

Subshells: They are useful for isolating operations and changes (like directory changes, variable assignments) from the current shell environment.

A real-world scenario in Bash scripting where subshells, &&, and || operators are used together to involve a script that performs a series of operations where each subsequent step depends on the success of the previous one. Here's an example involving database backup and notification:

  1. Creates a text file.

  2. Writes a message into the file.

  3. If the file creation and writing succeed, it displays a success message.

  4. If any of the steps fail, it displays a failure message.


# Function to display a notification message
display_notification() {
    local message=$1
    echo "$message"

# File operation in a subshell
    touch /path/to/example.txt && echo "Hello, World!" > /path/to/example.txt
) && display_notification "File creation and write successful." ||
  display_notification "File creation or write failed."
  1. Subshell for Grouped Operations:

    • The touch command creates a new empty file named example.txt.

    • The echo command writes "Hello, World!" into the file.

    • Both commands are executed in a subshell.

  2. Using && for Sequential Execution:

    • The echo command is executed only if the touch command succeeds.
  3. Using || for Error Handling:

    • If either touch or echo fails, the script executes the command after ||.
  4. Displaying Notifications:

    • The display_notification function simply echoes the passed message.

    • It shows either a success or a failure message based on the execution outcome.


Script to Check if a Number is Prime


# Function to check if a number is prime
is_prime() {
    local number=$1

    # Handling special cases
    if (( number < 2 )); then
        echo "The number $number is not prime."

    # Check divisibility from 2 to the square root of the number
    for (( i=2; i*i<=number; i++ )); do
        if (( number % i == 0 )); then
            echo "The number $number is not prime."

    echo "The number $number is prime."

# Read a number from the user
read -p "Enter a number: " num

# Checking if the input is a valid number
if ! (( num == num )); then
    echo "Error: Please enter a valid number."
    exit 1

# Calling the function
is_prime "$num"
  1. Function is_prime:

    • Takes a number as an argument.

    • Checks if the number is less than 2. Numbers less than 2 are not prime.

    • Loops from 2 to the square root of the number. If any number divides evenly into the given number, it's not prime.

  2. Reading User Input:

    • Prompts the user to enter a number.

    • Uses an arithmetic comparison num == num to check if the input is a valid number. This is a simple way to check for numeric input in Bash. If num is not a number, the expression will evaluate to false.

  3. Calling is_prime:

    • Passes the user input to the is_prime function.

Running the Script

  • Save this script as

  • Run it in the terminal: bash

  • Enter a number when prompted.

Bubble Sort


# Function to perform bubble sort
bubble_sort() {
    local -n arr=$1
    local n=${#arr[@]}
    local temp
    for ((i = 0; i<n-1; i++)); do
        for ((j = 0; j<n-i-1; j++)); do
            if ((arr[j] > arr[j+1])); then
                # Swap arr[j] and arr[j+1]

# Read the number of elements
read -p "Enter the number of elements: " n

# Read n numbers into an array
echo "Enter $n numbers:"
for ((i = 0; i < n; i++)); do
    read num

# Perform Bubble Sort
bubble_sort numbers

# Print the sorted array
echo "Sorted array:"
for num in "${numbers[@]}"; do
    echo $num
  1. Bubble Sort Function:

    • bubble_sort takes a nameref (-n) to the array as its argument. This allows us to modify the original array.

    • It performs the bubble sort algorithm by repeatedly swapping adjacent elements if they are in the wrong order.

  2. Reading the Number of Elements:

    • The user is prompted to enter the number of elements they wish to sort.
  3. Reading the Numbers:

    • A for loop is used to read n numbers from the user, storing them in the numbers array.
  4. Sorting the Array:

    • The bubble_sort function is called with the numbers array.
  5. Printing the Sorted Array:

    • Another for loop is used to print the sorted elements of the array.

Running the Script:

  • Save this script as

  • Make it executable: chmod +x

  • Run the script: ./

  • Enter the number of elements and the elements when prompted.

In Bash scripting, a nameref, or name reference, is a type of variable that creates a reference to another variable. This feature, introduced in Bash version 4.3, allows you to indirectly reference the value of another variable.

Understanding Namerefs

  • Declaration: You create a nameref using the -n attribute with the declare or local command.

      declare -n nameref=original_variable
  • Behavior: When you access or modify nameref, you're actually accessing or modifying original_variable.

Namerefs vs. Default Behavior (Copy by Value)

  • Default Behavior: By default, when you assign a variable's value to another variable in Bash, it's a copy by value. That means the new variable gets a copy of the data, and subsequent changes to one variable do not affect the other.

      b=$a  # b gets a copy of the value of a
      b=20  # Changing b doesn't affect a
  • Namerefs: With namerefs, instead of copying the value, you create a reference to the original variable. Any changes made to the nameref are actually made to the original variable it references.

      declare -n b=a  # b is a reference to a
      b=20  # Changing b also changes a
      echo $a  # Outputs 20

Namerefs are particularly useful in functions when you want to modify an array or a variable in the caller's scope:

my_function() {
    local -n my_ref=$1
    my_ref="Modified value"

my_var="Original value"
my_function my_var
echo $my_var  # Outputs "Modified value"

Here, my_function modifies my_var directly through the nameref my_ref.

Avoiding Copies: Namerefs are useful when you want to avoid copying large amounts of data, such as with large arrays.

Direct Manipulation: They allow functions to directly modify variables in the caller's scope.

Dynamic References: Namerefs can be used to create dynamic references to variables, where the exact variable being referenced can change based on program logic.

Reverse Each Word and Reverse Order of Each Word too

Example: "I am fine" should become "enif ma I"


# Function to reverse a word
reverse_word() {
    local word=$1
    local reversed=""
    for (( i=${#word}-1; i>=0; i-- )); do
    echo "$reversed"

# Read a sentence from the user
read -p "Enter a sentence: " sentence

# Split the sentence into words and store in an array
IFS=' ' read -ra words <<< "$sentence"

# Reverse each word and store in a new array
for word in "${words[@]}"; do
    reversed_words+=("$(reverse_word "$word")")

# Reverse the order of words and print
for (( i=${#reversed_words[@]}-1; i>=0; i-- )); do
    echo -n "${reversed_words[i]} "
  1. reverse_word Function:

    • This function takes a word and reverses it.

    • It iterates over the characters of the word from the end to the beginning, constructing the reversed word.

  2. Reading the User Input:

    • The user is prompted to enter a sentence.
  3. Splitting the Sentence into Words:

    • The sentence is split into words based on spaces and stored in an array words.
  4. Reversing Each Word:

    • Each word in the words array is reversed using the reverse_word function and stored in a new array reversed_words.
  5. Printing the Reversed Sentence:

    • The script iterates over reversed_words in reverse order to print the sentence in reverse with each word reversed.

    • echo -n is used to print each word without a newline, and a space is added between words.

Running the Script

The following line of the script is a key part of processing the input sentence. Let's break it down for clarity:

IFS=' ' read -ra words <<< "$sentence"
  1. IFS=' ':

    • IFS stands for the Internal Field Separator. It's a special shell variable used to define a delimiter that separates words during the read operation.

    • By setting IFS=' ', we specify that words in the input string should be split based on spaces. This means that spaces will be used to identify separate words in the sentence.

  2. read -ra words:

    • read is a Bash builtin command used to read input.

    • The -r option to read prevents backslash escapes from being interpreted, which ensures that backslashes are read literally. Without -r, any backslashes in the input would be interpreted as escape characters.

    • The -a option specifies that the input should be read into an array. In this case, the array is named words.

    • Each word in the input string (separated by spaces, as defined by IFS) is assigned to an element of the array. For example, if the input is "I am fine", words[0] will be "I", words[1] will be "am", and words[2] will be "fine".

  3. <<< "$sentence":

    • <<< is known as a "here string" in Bash. It's a type of redirection that feeds a string into a command's standard input.

    • In this case, the string contained in the variable $sentence is fed into the read command.

    • This means that the read command doesn't wait for input from the keyboard; instead, it directly processes the content of the $sentence variable.

Putting it all together, IFS=' ' read -ra words <<< "$sentence" splits the input sentence into words based on spaces and stores each word as an element in the words array. This is a common and efficient way to parse a sentence into words in Bash scripting.