Introduction

Various shell

• Bourne Shell (sh): The original Bourne shell, developed by Stephen Bourne. It is a simple and efficient shell, but it lacks some of the features found in more modern shells. The Bourne shell is a command-line interpreter or shell that was the original Unix shell.
• Bash (Bourne Again SHell): Bash is one of the most popular and widely used shells. It is an enhanced version of the original Bourne shell, providing additional features like command history, job control, and improved scripting capabilities. Bash is the default shell for many Unix-like operating systems.
• Zsh (Z Shell): Zsh is an extended Bourne shell with features from Bash, Korn shell, and others. It includes advanced tab completion, spelling correction, and improved scripting capabilities. Zsh is highly customizable and user-friendly.
• PowerShell: Developed by Microsoft, PowerShell is a task automation framework and shell. It is especially prevalent in Windows environments but is also available for Linux and macOS.
• Korn Shell (ksh): The Korn shell was developed by David Korn as a superset of the Bourne shell with additional features. It includes features like command-line editing, history, and associative arrays. There are two main versions: ksh88 and ksh93.
• Dash: Dash is a minimalistic POSIX-compliant shell, designed to be lightweight and fast. It is often used as the default system shell on some Unix-like systems for scripts and system utilities.
• Ash (Almquist Shell): Ash is a lightweight shell that aims to be POSIX-compliant. It is often used in embedded systems and is known for its small memory footprint.
• Fish (Friendly Interactive SHell): Fish is designed to be user-friendly and interactive. It provides features like syntax highlighting, autosuggestions, and a consistent command syntax. While not POSIX-compliant, it offers a unique and intuitive user experience.

Some common terminologies

• Script: A script is a series of commands or instructions written in a scripting language to be executed by a runtime environment.
• Interpreter: An interpreter is a program that reads and executes scripts line by line. It interprets the script's instructions without the need for compilation.
• Syntax: Syntax refers to the rules governing the structure of statements in a script. Correct syntax is essential for the script to be properly interpreted and executed.
• Variable: A variable is a named storage location in which data can be stored and retrieved. Variables are used to store information that may change during the script's execution.
• Data Types: Data types define the type of data that a variable can hold, such as integers, strings, or booleans.
• Conditional Statements: Conditional statements (e.g., if, else, elif) allow the script to make decisions based on certain conditions.
• Loop: A loop is a control structure that allows a set of instructions to be repeated multiple times. Common loop types include for and while loops.
• Function: A function is a reusable block of code that performs a specific task. Functions help in organizing and modularizing code.
• Arguments/Parameters: Arguments or parameters are values that can be passed to a function or a script. They provide input to the code.
• Comments: Comments are non-executable lines in a script used to provide explanations, notes, or documentation for the code. They are ignored during execution.
• Debugging: Debugging is the process of identifying and fixing errors (bugs) in a script. This often involves using tools to trace and analyze the script's execution.
• Shebag (#!)The shebang is a special character sequence (e.g., `#!/bin/bash` ) at the beginning of a script that specifies the interpreter to be used for executing the script.
• Scripting Languages: Scripting languages are programming languages designed for scripting, often with a focus on ease of use and rapid development. Examples include Bash, Python, Perl, and Ruby.
• Environment Variables: Environment variables are variables outside the script that store configuration settings, paths, or other information relevant to the execution environment.

Execution:

• Create a file using command ===> `vi filename.sh`
• To make the text file executable ===> `chmod 755 filename.sh`
• To run the script ===> `./filename.sh`
• A tab (to create a space) in between the script like: echo "Hello `tab` World" will show a space as Hello `tab` World
• But when there is just space placed, but not tab between `Hello World`, it will not show any space.

• chmod`: Stands for "change mode" and is the command used to change file permissions.
• u+rx: This specifies the changes to be made to the permissions of the file. Here's what each part means:
  • u: Refers to the user (owner) of the file.
  • +rx: Adds read (`r`) and execute (`x`) permissions.
• `myscript.sh`This is the name of the file for which you want to change the permissions. Replace it with the actual name of your script.

• read(r): Allows the owner to read the contents of the file.
• Execute (`x`): Allows the owner to execute the file as a program.

Example scripts:

#!/bin/sh
        echo "Hello, World!"

#!/bin/sh
        read -p "Enter your name: " username

#!/bin/sh
        if [ "$var" -gt 10 ]; then
            echo "Greater than 10"
        fi

#!/bin/sh
        for i in {1..5}; do
            echo $i
        done

#!/bin/sh
        counter=0
        while [ $counter -lt 5 ]; do
            echo $counter
            ((counter++))
        done

#!/bin/sh
        case "$option" in
            "a") echo "Option A";;
            "b") echo "Option B";;
            *)   echo "Default Option";;
        esac

#!/bin/sh
        function greet {
            echo "Hello, $1!"
        }
        
        greet "John"

#!/bin/sh
        ls -l

#!/bin/sh
        cp file1.txt file2.txt

#!/bin/sh
        mv oldfile.txt newfile.txt

#!/bin/sh
        rm file.txt

#!/bin/sh
        touch newfile.txt

#!/bin/sh
        grep "pattern" file.txt

#!/bin/sh
        sed 's/old/new/g' input.txt

#!/bin/sh
        awk '{print $2}' data.txt

• Unix system: `#!/bin/sh`: The first line tells Unix that the file is to be executed by /bin/sh.
• Perl: script may start with the line `#!/usr/bin/perl` to tell your interactive shell that the program which follows should be executed by perl. For Bourne shell programming, we shall stick to `#!/bin/sh`.

Variables

In shell scripting, variables are used to store and manipulate data. The concept of variables - a symbolic name for a chunk of memory to which we can assign values, read and manipulate its contents. Here are the key aspects of variables in shell scripting:

1. Variable Declaration and Assignment:

   Syntax:

   variable_name=value

   Example:

   greeting="Hello, World!"

2. Variable Naming Rules:
   • Variable names are case-sensitive.
   • They can consist of letters, numbers, and underscores.
   • The first character must be a letter or an underscore.
3. Accessing Variable Values:

   #!/bin/sh
       echo $greeting

4. Special Variables:
   • Positional Parameters: $0, $1, $2, ..., represent the script name and its arguments.
   • Number of Arguments: $# gives the number of command-line arguments.
   • All Arguments: $@ or $* represents all command-line arguments.
   • Exit Status: $? holds the exit status of the last executed command.
5. Read Input into a Variable:

   read -p "Enter your name: " username

6. Variable Concatenation:

   fullname="$firstname $lastname"

7. Variable Scope:

   export myvar="some value"

8. Unsetting Variables:

   unset myvar

9. Using Variables in Commands:

   count=5
       echo "There are $count apples."

These are fundamental concepts when working with variables in shell scripting. They provide a way to store, retrieve, and manipulate data within your scripts, making them dynamic and adaptable.

Loop

1. 'for' loop:

• Numeric Range:

  
              #!/bin/bash 
   
      
              for i in {1..5}
  
              do
  
                echo "Iteration $i"
  
              done
  
            

  Output:
  Iteration 1
  Iteration 2
  Iteration 3
  Iteration 4
  Iteration 5
• Iterate Over Items in an Array:

  
              #!/bin/bash
              
              fruits=("Apple" "Banana" "Orange")
              
              for fruit in "${fruits[@]}"
              do
                echo "Fruit: $fruit"
              done
              

  Output:
  Fruit: Apple
  Fruit: Banana
  Fruit: Orange
  

2. `while` Loop:

        #!/bin/bash

        counter=5

        while [ $counter -gt 0 ]
        do
          echo "Countdown: $counter"
          ((counter--))
        done
      

• `-gt`: This is a comparison operator that stands for "greater than."
• `0`: This is the value that $counter is being compared to.

Test

      #!/bin/bash
      if [ ... ]
      then
        # if-code
      else
        # else-code
      fi
    

      #!/bin/bash
      if [ ... ]; then
        # do something
      fi
    

      #!/bin/bash
      if  [ something ]; then
      echo "Something"
      elif [ something_else ]; then
        echo "Something else"
      else
        echo "None of the above"
      fi
    

• String Comparison:

  
            #!/bin/bash
      
            str1="hello"
            str2="world"
            
            if [ "$str1" = "$str2" ]; then
              echo "Strings are equal"
            else
              echo "Strings are not equal"
            fi
          

• Numeric Comparison:

  
            #!/bin/bash
  
            num1=5
            num2=10
            
            if [ "$num1" -eq "$num2" ]; then
              echo "Numbers are equal"
            else
              echo "Numbers are not equal"
            fi
          

• File Existence:

  
            #!/bin/bash
  
            file_path="/path/to/some/file.txt"
            
            if [ -e "$file_path" ]; then
              echo "File exists"
            else
              echo "File does not exist"
            fi
          

• Logical AND:

  
            #!/bin/bash
  
            num1=5
            num2=10
            
            if [ "$num1" -gt 0 ] && [ "$num2" -lt 20 ]; then
              echo "Both conditions are true"
            else
              echo "At least one condition is false"
            fi
          

The case statement

Example:

      #!/bin/bash

      echo "Enter a fruit: "
      read fruit
      
      case "$fruit" in
        "apple")
          echo "Selected fruit: Apple"
          ;;
        "banana" | "plantain")
          echo "Selected fruit: Banana or Plantain"
          ;;
        "orange")
          echo "Selected fruit: Orange"
          ;;
        *)
          echo "Unknown fruit"
          ;;
      esac
    

Bash command references

References

• Please find some Tutorial sessions on my github repository.
• The Shell Scripting Tutorial