We have access to a number of operators in the realm of Using the =~ Operator in Bash that enable us to work with, evaluate, and compare data. Among these is the operator {=~}. This operator, which is very powerful yet sometimes disregarded, gives us a way to match string patterns with regular expressions. This article delves deeply into the use of the {=~} operator in real-world Bash applications.
Understanding the =~ Operator:
The `=~` operator is a Bash-specific feature that is utilized within conditional expressions. Its primary use is to compare a string with a regular expression pattern. If the string matches the pattern, the operator returns a 0 (true), and if it does not, it returns a 1 (false).
Syntax of the =~ Operator:
The syntax is straightforward. The `=~` operator is used within [[ and ]], and the string and the regular expression are the operands, as demonstrated below:
|
1
|
[[ string =~ regular_expression ]]
|
If the string matches the regular expression, the exit status of the operation is 0; otherwise, it’s 1.
Practical Application of the =~ Operator:
Let’s now examine a few real-world examples to demonstrate the use of the {=~} operator.
Example 1: Simple Pattern Matching:
Let’s begin with a simple illustration. We wish to determine whether the string “Welcome to Bash scripting” contains the word “Bash.”
|
1
2
3
4
5
6
7
8
9
|
#!/bin/bash
str=“Welcome to Bash scripting”
if [[ $str =~ Bash ]]; then
echo “The string contains the word Bash.”
else
echo “The string does not contain the word Bash.”
fi
|
When we run this script, it will output “The string contains the word Bash.”
Example 2: Using Regular Expressions
The fact that the {=~} operator supports regular expression pattern matching is one of its key benefits. Let’s say we wish to determine whether a string has any digits in it. This is how we can proceed:
|
1
2
3
4
5
6
7
8
9
|
#!/bin/bash
str=“Order 5 pizzas”
if [[ $str =~ [0–9]+ ]]; then
echo “The string contains a digit.”
else
echo “The string does not contain a digit.”
fi
|
The `[[ $str =~ [0-9]+ ]]` expression will check for one or more occurrences of any digit (0-9) in the string. The script will print “The string contains a digit.”
Example 3: Extracting Matches
To extract matches, you can also use the {=~} operator. The part of the string that matched and any captured group matches are added to the BASH_REMATCH array variable when a match is discovered.
Assume for the moment that we wish to extract the day, month, and year from a date string:
|
1
2
3
4
5
6
7
8
9
10
11
|
#!/bin/bash
date=“23-05-2023”
regex=“([0-9]{2})-([0-9]{2})-([0-9]{4})”
if [[ $date =~ $regex ]]; then
day=${BASH_REMATCH[1]}
month=${BASH_REMATCH[2]}
year=${BASH_REMATCH[3]}
echo “Day: $day, Month: $month, Year: $year”
fi
|
In this script, the regular expression ([0-9]{2})-([0-9]{2})-([0-9]{4}) will match a date format of dd-mm-yyyy, and the BASH_REMATCH array will hold the matched groups. The script will print “Day: 23, Month: 05, Year: 2023”.
The ‘-ne’ Operator:
In Bash scripting, the relational operator “-ne” is used to compare two numerical numbers. Its value is true if the values being compared are not equal. It stands for “not equal.” It is mostly employed in conditional statements like the “if” and “while” clauses.
Syntax and Usage:
The general syntax for using the ‘-ne’ operator in a Bash script is as follows:
|
1
2
3
4
|
if [ VALUE1 –ne VALUE2 ]
then
# Code to be executed if the condition is true
fi
|
Here, `VALUE1` and `VALUE2` represent the numeric values being compared. If VALUE1 is not equal to VALUE2, the code within the ‘then’ block will be executed.
String Operators:
The string operators in the shell are supported by the curly-bracket syntax. String operators let you work with variable values in a variety of practical ways without requiring you to use third-party UNIX utilities or develop complex programs. Even if you aren’t yet proficient in the programming elements we’ll cover in later chapters, string-handling operators are still quite useful.
Specifically, string operators enable the following functions:
Ensure that variables exist (i.e., are defined and have non-null values)
- Set default values for variables
- Catch errors that result from variables not being set
- Remove portions of variables’ values that match patterns
Syntax of String Operators:
The fundamental concept underlying the syntax of string operators is the insertion of special characters, which indicate operations, between the name of the variable and the right curly bracket. The operator inserts whatever arguments they may require to their right.
The initial set of operators for handling strings verifies the presence of variables and permits the replacement of default values in specific scenarios.
Conclusion
The {=~} operator is a very useful tool for Bash script writers. Your scripts can contain regular expression logic and intricate string pattern matching if you know how to use this operator. To make sure your regular expressions are functioning as intended, always test your scripts and utilize it inside double brackets\{[[{ {]]}. Cheers to writing scripts!