Bash, or the Bourne Again Shell, is a popular command-line interpreter for Unix-based systems. It is often used to write scripts, which are essentially just a series of commands that are executed in order. However, there are two types of scripts in Bash: interactive and non-interactive. In this article, we’ll take a look at the differences between the two and provide examples of each.

Interactive Scripts

Interactive scripts are designed to be run by a user and require input from the user in order to complete their tasks. An example of an interactive script might be a script that prompts the user for their name and then greets them with a personalized message. Here’s an example of a simple interactive script:

!/bin/bash
echo "What is your name?"
read name
echo "Hello, $name. Nice to meet you!"

When this script is run, the user will be prompted to enter their name, and the script will then print out a personalized greeting using the name they entered.

Another example of interactive script is a script that prompts user to enter the name of a file and then reads the content of the file.

!/bin/bash 
echo "Enter the file name:"
read file
cat $file

When this script is run, the user will be prompted to enter the name of a file. The script will then reads the contents of the file and prints it to the screen.

Interactive scripts are useful when you need user input in order to complete a task. They are also useful for creating simple command-line interfaces for programs.

Non-Interactive Scripts

Non-interactive scripts, on the other hand, do not require input from the user in order to complete their tasks. They are designed to run automatically, without any interaction from the user. An example of a non-interactive script might be a script that backs up all of the files in a certain directory. Here’s an example of a simple non-interactive script:

!/bin/bash 
tar -cvf /path/to/backup.tar /path/to/directory

This script creates a tar archive of the specified directory and saves it to the specified location. It does not require any input from the user and will run automatically.

Another example of non-interactive script is a script that runs a set of commands on startup.

!/bin/bash 
echo "Starting service…"
systemctl start myservice
echo "Service started successfully"

This script runs a systemctl command to start a service and then prints a message indicating that the service has started successfully. It does not require any input from the user and will run automatically.

Non-interactive scripts are useful when you need to automate a task or perform a task without any user interaction. They are also useful for creating scripts that can be run as part of a larger system or process.

Conclusion

Both interactive and non-interactive scripts have their own use cases. Interactive scripts are great for when you need user input in order to complete a task, while non-interactive scripts are great for automating tasks or performing tasks without any user interaction. By understanding the differences between the two, you can choose the right type of script for your needs and write more efficient and effective Bash scripts.

It’s important to note that a script can be both interactive and non-interactive, depending on how it is used. A script that prompts for user input could perform task without any further interaction. Similarly, a script that is designed to run automatically can also include prompts for user input if needed. The key is to understand the purpose of the script and how it will be used in order to determine whether it should be interactive or non-interactive.