Bash Scripting

Learn Bash scripting with our in-depth course, or jump in to a topic of your choosing!

Bash Scripting Tutorials

Introduction to Bash Scripting
Variables in Bash
— Special Variables
Numbers in Bash
Math in Bash

Bash Operators
— Operator Reference
Working With Input

Bash Functions

Bash Script Examples

Bash Script to Generate a List of Numbers

What is Bash Scripting?

In the world of Linux and Unix-like operating systems, ‘bash scripting‘ refers to creating a text file or a ‘one-liner’ containing a series of commands that Bash (bourne-again shell) can execute.

Bash scripting is a powerful tool for automating tasks, simplifying complex operations, and improving productivity.

Whether you’re a system or network administrator, developer, or just a curious enthusiast, learning Bash scripting can open up a world of possibilities.

Our guide is designed for beginners who are new to Bash scripting. In this article, we’ll cover the Bourne-again shell (Bash) and bash scripting at a high level. We’ll also see a practical example to help you get familiar with bash scripts.

Looking ahead: After this topic, we’ll be ready to cover the essentials to bash scripting: variables, loops, conditionals, and functions. As we progress, we’ll explore more advanced topics like command-line arguments, input/output redirection, and error handling. By the end of this guide, you’ll have a solid understanding of Bash scripting fundamentals and the confidence to start writing your own scripts. So, grab your favorite text editor, fire up your terminal, and let’s dive into the world of Bash scripting!

What is a Bash Script?

A Bash script is a file containing a series of commands that the bourne-again shell, commonly known as Bash, can execute.

The bourne-again shell (Bash) is not just a command interpreter, but is also a full-fledged programming environment. This means that we can use things like conditional expressions and loops. Critically, Bash also makes it easy to work with user input and display output to the console.

At its’ core, a bash script is just a text file. Bash scripts commonly use the .sh file extension, but this isn’t mandatory. However, it does need to be executable, which we can do using ‘chmod +x <script name>‘.

Remember: Bash isn’t just a command-line interpreter. It’s a complete programming language.

Introducing the Bourne-Again Shell (Bash)

The Bourne-Again Shell, abbreviated as Bash, is a Unix shell and command language written by Brian Fox for the GNU Project as a free software replacement for the Bourne shell (sh).

Bash has become the default shell for most Linux distributions and macOS. As a result, it’s widely used on Unix-like operating systems.

Bash offers features such as command-line editing, history substitution, customizable prompts, job control, and shell scripting capabilities. It’s highly versatile and powerful, making it a popular choice for both interactive use by users and for scripting purposes.

Writing and Executing a Bash Script

Let’s take a look at a simple Bash script, which can teach us a lot.


# This is a comment in Bash! 

echo "Hello, World!"

The first line of the script typically starts with `#!` – called a shebang, followed by the path to the Bash interpreter. For example, `#!/bin/bash`. The shebang line line tells the system which interpreter to use to execute the script.

The second line is a comment. It is ignored by the compiler and does not get executed. Comments are useful for adding documentation to code.

Finally, the third line executes the echo command, which prints the string “Hello World!” to the console.

Saving and File Permissions

The script above can be saved into a file using a text editor of your choice. On Linux, vim and nano are fine options but GUI editors are great as well.

Before you can execute the script, you need to ensure it has the ‘execute’ permission set. You can do this with the `chmod` command in a terminal:

chmod +x

In this example, the ‘+x’ flag gives execute permissions over the file.

When we run a Bash script in Linux, the operating system interprets the script using the Bash shell. The Bash interpreter reads the script line by line, executing each command as it goes. It starts at the top of the file and proceeds sequentially unless directed otherwise by control flow statements like loops or conditionals.

After the script finishes executing, it returns an exit status to the shell. This status indicates whether the script ran successfully (`0` for success) or encountered an error (`non-zero` for failure).

Overall, Bash scripts provide a way to automate tasks and combine commands in a convenient and efficient manner, making them a fundamental tool for Linux system administrators and power users.

A Practical Example of Bash Scripting

Here’s a slightly more complex example of a Bash script that takes user input and performs some basic operations:


# This script calculates the area of a rectangle

# Prompt the user for the length and width of the rectangle
echo "Enter the length of the rectangle:"
read length

echo "Enter the width of the rectangle:"
read width

# Calculate the area
area=$((length * width))

# Display the result
echo "The area of the rectangle with length $length and width $width is: $area"

Save this script in a file (e.g., ``), make it executable with `chmod +x`, and then run it with `./`.

It will prompt you to enter the length and width of a rectangle, calculate the area, and then display the result.

This script demonstrates a few additional concepts:

  • The `read` command is used to read user input.
  • Variables (`length`, `width`, `area`) are used to store and manipulate data. – The `echo` command is used to display the result to the user.
  • Arithmetic operations in Bash are performed using the `$( … )` syntax.

We’ll cover each of these in greater detail during this course. If the above example seems confusing to you, don’t fret. Read it a few times and give yourself time to learn a new language. You’ll be a pro at Bash before you know it!