How to Write a Bash Script: A Complete Bash Scripting Tutorial

Prerequisites

Before following this tutorial, I recommend having:

• A Unix-based operating system (Linux or macOS), or Windows with Git Bash or Windows Subsystem for Linux (WSL) installed
• Basic familiarity with navigating the terminal (opening a terminal, listing files with ls, changing directories with cd)
• A text editor such as nano, vim, or VS Code to write script content

How to Write a Bash Script

We are going to build a simple “Hello World” bash script example to get you started with bash scripting. If you wish to delve deeper into bash scripting, check out Introduction to Bash Scripting course. 

Step 1: Create a new plain text file 

The first step is to create a new plain text file with a .sh extension. On Linux or macOS, run the following from your terminal:

touch hello_world.sh

On Windows, you can use Git Bash or Windows Subsystem for Linux (WSL) — both support the same touch command. Alternatively, create the file in any text editor (VS Code, Notepad, nano) and save it with the .sh extension.

Step 2: Specifying the interpreter

On the first line of our script, we must specify which interpreter we would like to use to parse our script. In this scenario, it is Bash. Thus, we must put the shebang in the first line of our script. 

#!/bin/bash

Step 3: Implement commands

The purpose of our bash script is to print “Hello World!” To perform this task, move to a new line and use the echo command followed by the string we would like to print.

echo "Hello World!" 

Once complete, save the file and open up your Git Bash.  

Note: You can download Git Bash from Git downloads. Simply select the version of Git that corresponds with your operating system. 

Next, run the following command: 

bash hello_world.sh

This should output “Hello World!” as seen in Figure 1. 

Figure 1: The output of our Bash script

Step 4: Make the script executable

Rather than always prefixing scripts with the bash command, you can make a script directly executable using chmod:

chmod +x hello_world.sh
./hello_world.sh

The chmod +x command grants execute permission to the file. The ./ prefix tells the shell to run the script from the current directory. This is the standard way to distribute and run bash scripts in production — most scripts you encounter will be run this way.

How to Capture User Input in Bash Scripts

Now you know how to write a simple “Hello World!” script. Let’s take a look at how we could use bash to write scripts that require input from the user. In this example, we will create an activity generator, which will ask the user for their name and then choose a random activity to invite the user to participate in from an array of activities. 

The steps to create the file are the same as in How to Write a Bash Script – the difference are the commands we enter into our bash script. 

1. Create a new plain text file from the terminal.

touch generate-activity.sh

2. Specify the bash interpreter by entering the shebang in the first line of the script.

#!/bin/bash

3. Write the commands to run the script and then save the file.

Now when we call our bash script from the terminal, we should expect to see the same output as in Figure 2. 

#!/bin/bash

# Greet user and request their name
echo "The activity generator"
read -p "What is your name? " name

# Create an array of activities
activity[0]="Football"
activity[1]="Table Tennis"
activity[2]="8 Ball Pool"
activity[3]="PS5"
activity[4]="Blackjack"

array_length=${#activity[@]} # Store the length of the array
index=$(($RANDOM % $array_length)) # Randomly select an index from 0 to array_length

# Invite the user to join you participate in an activity
echo "Hi" $name, "would you like to play" ${activity[$index]}"?"
read -p "Answer: " answer

Figure 2: Demonstrating the generate-activity.sh script.

Working With Variables in Bash Scripts

Variables store data that can be referenced and reused throughout a script. To define a variable, assign a value with no spaces around the = sign. Access its value by prefixing the name with $:

#!/bin/bash

# Define variables
greeting="Hello"
user_name="Alice"
current_year=$(date +%Y)  # Command substitution

# Use variables
echo "$greeting, $user_name!"
echo "The current year is $current_year."

Key rules for bash variables:

• Variable names are case-sensitive: name and NAME are different variables
• No spaces are allowed around the = sign when assigning a value
• Use $(command) for command substitution to capture the output of a command into a variable
• Wrap variables in double quotes ("$var") to safely handle values that contain spaces

How to Create a Function in a Bash Script

In programming, functions are used to bundle a set of repeated instructions together – learn more about Functions in Python. The purpose of writing functions is to avoid writing the same code constantly, and it also makes your code more readable. 

A bash function may be considered a typical function: a set of commands that can be called several times. However, bash functions are slightly more limited when compared to the majority of programming languages (i.e., bash functions do not allow you to return a value when called). 

Before we create a bash script using a function, let’s take a look at the syntax for declaring a bash function. We can define a function by writing a function name, followed by parentheses and curly braces for the function's body – this is the most common way to write a bash function. Here is it looks in code: 

# Most common way to write a bash function.
example_function () {
  commands
}

The other way to format a bash function is to begin the line with the reserved bash keyword function, then the function name and curly braces for the function body – we do not need the parentheses. 

# Another way to write a bash function.
function example_function {
  commands
}

Defining the function will not execute the commands. To invoke a bash function, you must call the function name, as follows: 

#!/bin/bash

# A hello world bash function
hello_world () {
  echo "Hello World!"
}

# Invoking the hello_world function
hello_world

Above, we created a  hello_world function that prints “Hello World!” when the bash script is run.

Passing arguments to bash functions

Arguments are variables used in a specific function. In bash, we can not pass arguments to functions like you would in high-level programming languages such as Python, Julia, etc. Instead, bash functions have their own command line argument and we can pass parameters to a function by placing them after a call to the function name – separated by a space if there are multiple arguments.

In essence, function arguments are treated as positional parameters and shell variables ($1, $2, ..., $n) are used to access arguments passed to the function. 

#!/bin/bash
greet () {
  echo "Hello $1 $2"
}

greet "John" "Doe" 

In the bash script above, we passed two arguments, John and Doe,  to our greet function. When the bash script is run now, we should see the following output:

Hello John Doe

Using Loops in Bash Scripts

Loops allow you to repeat a block of commands multiple times. Bash supports for loops and while loops.

For loops

A for loop iterates over a list of items or a numeric range:

#!/bin/bash

# Loop over a list
for fruit in apple banana cherry; do
  echo "I like $fruit"
done

# Loop over a numeric range
for number in {1..5}; do
  echo "Number: $number"
done

While loops

A while loop runs as long as its condition evaluates to true:

#!/bin/bash

count=1
while [ $count -le 5 ]; do
  echo "Count: $count"
  count=$((count + 1))
done

Writing “If” Statements in Bash

“If” statements are conditional statements used in programming languages. If a statement is proven to be true, then a condition would run. This functionality enables us to determine the circumstances under which a certain piece of code shall be executed. 

In bash, we start the conditional with an if statement and end it with fi (if spelled backward). Here is an example bash script with if conditionals: 

#!/bin/bash

read -p "Give me a number: " number
if [ $number -gt 10 ];
then
  echo "Your number is greater than 10."
fi

In the bash script above, the user is asked to provide a number. If the number provided by the user is greater than 10, then “Your number is greater than 10” will be outputted to the terminal, but if it is not, the program will end. Figure 3 is an example of us passing a number larger than 10. 

Figure 3: Using “if” statements in Bash scripts

Conclusion

Bash scripting is a powerful skill for automating tasks, managing systems, and building data pipelines. In this tutorial, I covered the core building blocks: the shebang line, creating and running scripts, capturing user input, working with variables, loops, functions, and conditionals.

To continue your bash scripting journey, explore these next steps:

• Take the Introduction to Bash Scripting course to deepen your skills with hands-on exercises
• Learn how to schedule scripts to run automatically using cron
• Explore string manipulation, file I/O, and error handling with exit codes
• Practice with real-world automation scripts: backups, log rotation, and system health checks
• To take your skills to the next level, I recommend taking our Data Processing in Shell course