How regular expressions work in Bash: a simple explanation for beginners

In this article, you’ll learn how to use regular expressions in Bash, a simple and powerful way to validate, find, and manipulate text in scripts. The material explains how the [[ string =~ regex ]] command works, what character classes, anchor characters, and quantifiers are, and shows practical examples of searching and selecting data in strings. You’ll learn how to use BASH_REMATCH to save matches, work with sed to replace text, and avoid common mistakes when working with strings.

Understanding basic regular expressions and matching

Let’s start with the fundamental concepts of regular expressions. A regular expression is a sequence of characters that defines a search pattern. Think of it as a very powerful way to search for text.

Here are the basic building blocks:

Literal characters: Most characters simply match themselves. For example, the regular expression abc will match the string “abc” exactly.

Metacharacters: These are special characters that have a specific meaning in regular expressions.

Let’s look at a few key ones:

• .(period): Matches any single character (except the newline character). So, a.c will match “abc”, “axc”, “a1c”, etc.

• *(asterisk): Matches the previous character zero or more times. ab*c will match “ac”, “abc”, “abbc”, “abbbc”, etc.

• ^(cartridge): Matches the beginning of a string. ^hello will match a string that starts with “hello”.

• $(dollar sign): Matches the end of a string. world$ will match a string that ends with “world”.

• [](square brackets): Defines a character class. It matches any one of the characters in the brackets. [abc] will match “a”, “b” or “c”. [0-9] will match any single digit.

Now let’s create a Bash script to test our understanding. Create a file called regex_test.sh using the touch command:

cd ~/project
touch regex_test.sh

Next, open regex_test.sh using a text editor (such as nano or vim) and add the following code:

#!/bin/bash

string="Hello World"
if [[ "$string" =~ ^Hello ]]; then
  echo "The string starts with Hello"
else
  echo "The string does not start with Hello"
fi

Save the file and make it executable:

chmod +x regex_test.sh

Finally, run the script:

./regex_test.sh

The output should show that the string starts with “Hello”.

Working with character sets in a script

Character sets, defined using square brackets [], allow you to match a single character from a specific group. This is very useful for creating more flexible patterns.

• Character ranges: Inside [], you can use a hyphen (-) to specify a range. [a-z] matches any lowercase letter, [A-Z] matches any uppercase letter, and [0-9] matches any digit. You can combine them: [a-zA-Z0-9] matches any alphanumeric character.

• Negation: If you put a ^ as the first character inside [], it will negate the class. [^0-9] matches any character that is not a digit.

Let’s modify our regex_test.sh script to use character sets. Open regex_test.sh with a text editor and replace its contents with the following:

#!/bin/bash

string="cat"
if [[ "$string" =~ c[a-z]t ]]; then
  echo "Match found!"
else
  echo "No match."
fi

Save the file and run it:

./regex_test.sh

#!/bin/bash

string="abbbc"
if [[ "$string" =~ ab+c ]]; then
  echo "Match found!"
else
  echo "No match."
fi

./regex_test.sh

#!/bin/bash

string="apple123"
if [[ "$string" =~ ^([a-z]+)([0-9]+)$ ]]; then
  fruit="${BASH_REMATCH[1]}"
  number="${BASH_REMATCH[2]}"
  echo "Fruit: $fruit"
else
  echo "No match."
fi

./regex_test.sh

cd ~/project
touch sed_test.sh
chmod +x sed_test.sh

#!/bin/bash

string="apple123"
echo "$string" | sed 's/[0-9]/X/g'

./sed_test.sh