Bash Script – Parameter Substitution and Expansion

Bash scripting is a powerful tool for automating tasks in the world of Linux and Unix. One of its essential features is “Parameter Substitution and Expansion,” which might sound a bit technical, but it’s actually a handy way to work with variables and manipulate strings in your scripts.

Imagine you have a box of tools, and you need to use them in different ways for various tasks. Parameter substitution and expansion are like magic tools in your Bash script box. They help you make your scripts more flexible, efficient, and capable of handling different situations.

In this article, we’ll take you on a journey to explore the world of parameter substitution and expansion in Bash scripting. We’ll start with the basics, such as how to access variables and use different methods to work with them. Then, we’ll dive into the exciting world of string manipulation, where you can perform actions like trimming, replacing, and extracting parts of strings effortlessly.

Why Parameter Substitution and Expansion Matter in Bash Scripting

In the world of Bash scripting, Parameter Substitution and Expansion are like your trusty sidekicks, always ready to assist you in your coding adventures. But what exactly do they do and why are they so important?


  1. Simplifying Variables: Imagine you have a lot of variables in your script, each containing different kinds of information. Parameter substitution and expansion help you access and manipulate these variables in a much simpler and efficient way. It’s like having a set of magic tools to work with your data.
  2. String Magic: Often, you need to work with text or strings in your scripts. Parameter expansion makes it easy to do things like finding and replacing parts of a string, which can save you a lot of time and effort.

How it Works:

Here’s a sneak peek of what you’ll learn in this blog post:

  1. Basic Parameter Substitution: We’ll start with the basics. You’ll discover different ways to grab and use variables in your scripts. We’ll cover things like ${variable}, $(), $var, and ${var}, making sure you have a solid foundation.
  2. String Manipulation: Ever wanted to trim or change parts of a text in your script? We’ve got you covered. We’ll show you how to use parameter expansion to perform these cool tricks, like removing text from the beginning or end of a string, and replacing specific parts of a string.
  3. Default Values and Conditions: Sometimes, you want to set default values for your variables or make decisions based on whether they exist or not. We’ll teach you how to do just that using ${var:-default} and ${var:+alternative}. It’s like having a script that can adapt to different situations.
  4. Indirect Variable References: Finally, we’ll introduce you to the concept of indirect variable references. This is where things get really interesting! You’ll learn how to access variables whose names are stored in other variables, making your scripts dynamic and powerful.

Basic Parameter Substitution in Bash

In Bash scripting, mastering basic parameter substitution is like learning the ABCs of coding. These techniques are simple yet incredibly powerful. Let’s break them down into bite-sized pieces, using plain English and real script examples.

Accessing Variable Values (${variable}):

This is like opening a treasure chest to reveal the value stored in a variable. Just wrap the variable name in ${} to access its content. Here’s how it works:

echo "I love ${fruit}s"  # Output: I love apples

Command Substitution ($()):

Sometimes, you need to execute a command and use its result as a variable. That’s where command substitution comes in. Put your command inside $(), and Bash will run it and provide the result.

echo "I am here: $current_directory"  # Output: I am here: /your/current/directory

Direct Variable Reference ($var):

For a straightforward variable reference, just use $ followed by the variable name. Bash will replace it with the variable’s value.

echo "I am $age years old"  # Output: I am 30 years old

Using Curly Braces for Variable Reference (${var}):

Sometimes, you may want to make sure Bash knows where your variable name ends, especially when it’s followed by text or other characters. In such cases, enclose your variable name in ${}.

echo "${person}'s cat"  # Output: Alice's cat

String Manipulation using Parameter Expansion in Bash

Now that you’ve got the basics of Bash parameter substitution, it’s time to dive into the exciting world of string manipulation using parameter expansion. These techniques are like magic spells for transforming and modifying text in your scripts. Let’s explore them using plain English and practical examples:

Removing the Shortest Match from the Beginning (${var#substring}):

This technique helps you trim text from the beginning of a string. It removes the shortest match of ‘substring’ from the start of ‘var’.

full_name="John Doe"
first_name="${full_name#John }"
echo "First Name: $first_name"  # Output: First Name: Doe

Removing the Longest Match from the Beginning (${var##substring}):

Similar to the previous one, but it removes the longest match of ‘substring’ from the beginning of ‘var’.

echo "Base Directory: $base_directory"  # Output: Base Directory: documents

Removing the Shortest Match from the End (${var%substring}):

Want to trim text from the end of a string? This technique removes the shortest match of ‘substring’ from the end of ‘var’.

echo "File Name without Extension: $extension"  # Output: File Name without Extension: script

Removing the Longest Match from the End (${var%%substring}):

Similar to the previous one but removes the longest match of ‘substring’ from the end of ‘var’.

echo "Domain: $domain"  # Output: Domain: https:

Replacing the First Occurrence (${var/old/new}):

When you need to swap the first occurrence of ‘old’ with ‘new’ in ‘var’, this technique comes in handy.

sentence="The quick brown fox jumps over the lazy brown dog."
echo "Replaced: $replaced"  # Output: Replaced: The quick red fox jumps over the lazy brown dog.

Replacing All Occurrences (${var//old/new}):

If you want to replace all instances of ‘old’ with ‘new’ in ‘var’, you can use this method.

text="Apples are red, and apples are tasty."
echo "Replaced: $replaced"  # Output: Replaced: Oranges are red, and oranges are tasty.

Default Values and Conditional Parameter Expansion in Bash

In Bash scripting, setting default values for variables and using conditional parameter expansion can be a lifesaver. These techniques help your scripts adapt to different situations and handle unexpected scenarios. Let’s explore how they work with simple English and practical script examples:

Setting Default Values (${var:-default}):

Imagine you have a variable, but it might not always have a value. You can set a default value to use when the variable is unset or null. Here’s how:

greeting="Hello, ${username:-Guest}!"
echo $greeting  # Output: Hello, Guest!

In this example, we set ‘Guest’ as the default value for ‘username’ since it’s empty.

Setting Default Values and Assigning (${var:=default}):

Not only can you set a default value, but you can also assign it to the variable if it’s unset or null using ${var:=default}:

echo "File Name: $filename"  # Output: File Name: untitled.txt

In this case, we both set ‘untitled.txt’ as the default value and assign it to ‘filename’.

Conditional Parameter Expansion (${var:+alternative}):

Sometimes, you want to use an alternative value only if the variable is set and not null. That’s where ${var:+alternative} comes in:

message="Today's weather is ${weather:+$weather,}nice!"
echo $message  # Output: Today's weather is sunny, nice!

Here, we include ‘sunny,’ only if ‘weather’ has a value.

Real-World Scenarios:

  • Default File Names: When your script expects a filename, but the user doesn’t provide one, you can use default values to avoid errors.
  • Environment Variables: If your script relies on environment variables, conditional parameter expansion ensures it handles missing variables gracefully.
  • Error Messages: Display informative error messages using default values when specific information is missing.
  • Fallback Values: When querying a database or API, use conditional expansion to switch to a fallback source if the primary one fails.

Indirect Variable References in Bash

Indirect variable references might sound a bit mysterious, but they’re incredibly useful in Bash scripting. They enable you to access variables dynamically, which can be a game-changer in certain scripting scenarios. Let’s demystify indirect variable references using straightforward language and practical script examples:

What are Indirect Variable References and Why are They Useful?

Indirect variable references allow you to access the value of a variable whose name is stored in another variable. This might seem like a fancy concept, but it’s like having a magic key to unlock different doors in your script. This flexibility is handy when you need to work with a changing set of variables or dynamically retrieve values based on conditions.

How to Use ${!var} for Indirect Variable References:

The syntax to perform indirect variable references is ${!var}. Here’s how it works:

echo "Hello, ${!current_var} ${last_name}!"  # Output: Hello, Alice Smith!

In this example, we use the value stored in the current_var variable ("first_name") to indirectly access the first_name variable and construct a greeting.

Indirect Variable References in Dynamic Scripting Scenarios:

Now, let’s explore how indirect variable references can be employed in real-world dynamic scripting scenarios:

Scenario 1: Handling User Input

Suppose you have a script that interacts with the user and asks them to choose an option. The chosen option corresponds to a variable you want to access:

read -p "Choose an option (A, B, C): " choice
echo "You chose option ${choice}, which has a value of ${value}."

In this scenario, the user’s choice (A, B, or C) dynamically determines the variable to access.

Scenario 2: Configuration Settings

You’re developing a script that relies on various configuration settings. Instead of hardcoding them, you store their names in an array, and then use indirect variable references to fetch their values:

config_settings=("db_username" "db_password" "api_key")
for setting in "${config_settings[@]}"; do
    echo "Setting: $setting, Value: $value"

This way, your script can adapt to different configurations without modifying the code.


In the world of Bash scripting, Parameter Substitution and Expansion are your trusty allies. They simplify working with variables and strings, making your scripts flexible and powerful.

You’ve learned to access and manipulate variables, perform string magic, set default values, and use conditional expansion. These skills will help you handle real-world scripting challenges with ease.

And don’t forget about indirect variable references—they’re your secret weapon for dynamic scripting. With these tools in your kit, you’re ready to create scripts that adapt to various scenarios, making your Bash scripting journey an exciting and rewarding one!

Frequently Asked Questions (FAQs)

What is Parameter Substitution and Expansion in Bash scripting?

Parameter substitution and expansion are techniques in Bash scripting that allow you to manipulate variables and strings with ease. They simplify tasks like accessing variable values, modifying strings, and handling default values.

Why are these techniques important in Bash scripting?

How do I access variable values using parameter substitution?

What is command substitution, and how do I use it?

How can I remove parts of a string using parameter expansion?

How do I set default values for variables in Bash scripting?

Is there a way to both set a default value and assign it to the variable if it’s unset or null?

What is conditional parameter expansion, and when is it useful?

How can I use indirect variable references in my scripts?


Leave a Reply

Your email address will not be published. Required fields are marked *

4 + 6 =