How to Compare Strings & Numbers in Bash

Strings are an important aspect of working with scripts. 

As such, string comparison lies at the heart of bash scripting. This idea can take many practical forms, such as comparing two strings to check their character sequence or length. These comparisons are critical in decision-making structures where comparisons determine which statement blocks are executed. 

Bash offers several ways to compare strings for equality, inequality, and even character order. This guide takes a user-friendly approach to the basics, demonstrating the use of bash string comparison operators in if-else statements and case structures through practical examples.

As you read through this guide, you’ll learn the basics of comparing strings in Bash and become confident in handling and changing strings in the Bash shell scripts, an essential skill for Linux power users. 

Let’s jump in and discover how to compare strings accurately and efficiently in the Bash environment!

Basic Concepts in Bash String Comparison

Before delving into the details of basic concepts, let’s take a look at the following table that lists some of the commonly used string comparison operators:

The fundamental purpose of string comparison in Bash is to determine whether two strings are equal or share any of the following relationships:

• Equality and Inequality (of Strings/Numbers)
• Case Insensitive Comparison
• Numeric and Lexicographic Comparison
• Greater and Lesser String Comparison

Equality and Inequality [of Strings]

When comparing strings in Bash, use the = equality operator and the != operator for inequality. It’s critical to understand that Bash treats strings as a collection of characters. 

For instance, we’ll compare str1 and str2 as string variables in a script.

str1=“Hi”

str2=“Everyone”

if [ "$str1" = "$str2" ]; then

echo "The strings are equal."

else

echo "The strings are not equal."

fi

Here’s the output of this script:

Equality and Inequality [in Numbers]

Bash supports all conventional numerical comparison operators, including -eq for equality and -ne for non-equality. For instance, consider the following two variables that will be compared in a script:

n1=1

n2=9

# Compare the numbers

if [ "$n1" -eq "$n2" ]; then

echo "The numbers are equal."

else

echo "The numbers are distinct."

fi

When executed, you’ll see the following output:

Case Insensitive Comparison

There are situations when comparing strings without considering the case (e.g., A or a) is a critical requirement. You can make a case-insensitive comparison using ${string,,} to transform each string to lowercase.

For instance, consider the following script:

str1=“REDSWITCHES”

str2=“redswitches”

if [[ "${str1,,}" = "${str2,,}" ]]; then

echo "The strings are equal (case-insensitive)."

else

echo “The strings are not equal.”

fi

Numeric and Lexicographic Bash String Comparison

The lexicographic comparison involves comparing two strings in alphabetic order. In this process, we convert the characters in each string into Unicode values and then compare these values one by one, starting from the beginning. This process continues until the process encounters a NULL character.

Strings are usually compared using </> operators enclosed in double brackets [[ ]]. Note that the operators within single brackets [] are interpreted as literals, 

Consider the following script that compares two strings:

str1=“Redswitches”

str2=“Servers”

if [[ "$str1" > "$str2" ]]; then

echo "$str1 comes before $str2."

else

echo "$str1 comes after $str2."

fi

Greater and Lesser Numerical Comparison

You may need to determine if two numbers are greater, smaller, or equal. For this, you can use the -gt (greater than) or -lt (less than) operators.

The following script allows you to see this comparison in action:

n1=1

n2=9

if [ "$n1" -gt "$n2" ]; then

echo "$n1 is greater than $n2."

elif [ "$n1" -lt "$n2" ]; then

echo "$n1 is less than $n2."

else

echo "Both numbers are equal."

# Compare for greater or smaller values

fi 

Using Test Constructs

Test constructs in Bash scripts are fundamental to verifying conditions. They are frequently used to determine the course of action based on the truth value of conditions. The following is the list of four test constructs crucially used in Bash scripting:

• Square Brackets
• Double Brackets
• The test Command
• Compound Conditions

Square Brackets

Let’s start with square brackets ([ ]). They are commonly represented in the test statement. The typical syntax is:

var=“RedSwitches”

# Using square brackets for string comparison operators

if [ "$var" = “RedSwitches” ]; then

echo "The variable name is Redswitches!”

fi

Double Brackets

Double brackets ([[ ]]) help handle more complex test conditions than square brackets. For example:

string=“Hello”

if [[ "$string" == H* ]]; then

echo "The string starts with an H.”

fi

The Test Statement

In Bash scripting, the test statement is used instead of square brackets for string comparison because it provides a more straightforward way to evaluate conditions. Instead of relying on square brackets, the test statement enhances readability and makes the script logic easier to follow. 

For instance, consider the following script:

Number=50

# Using the test statement for the numeric comparison

test $Number -gt 10 && echo "The value is greater than 10."

Compound Conditions

Logical compound comparison operators can evaluate many conditions at once. For instance:

n1=7

n2=5

# Evaluating multiple conditions

if [[ $n1 -lt 7 && $n2 -gt 5 ]]; then

echo "Both conditions are true."

fi

Check String Length

When it comes to comparing strings, the following are the most critical use cases: 

• Length of a string
• Whether a string is “empty”

Length of a String

In many Bash scripts, determining the length of the string is a common requirement. The len statement is a simple way to find the length of a given string in Bash scripts.

Consider the following script.

string=“RedSwitches”

len=${#string}

echo $len

The output of this script is 11.

Here’s a more detailed example of using the string’s length in script execution:

#!/bin/bash

myString="Hello, World!"

length=${#myString}  # Get the length of the string

if [ "$length" -gt 10 ]; then

    echo "The string is longer than 10 characters."

else

    echo "The string is 10 characters or shorter."

fi

Finding Out if a String is Empty

An empty string is a character-free string. Finding empty strings is crucial, mainly when processing data or verifying user input, because of the adverse impact of empty strings in data manipulation.

The following script shows how to detect if a string is empty:

s_value=“”

if [[ -z $s_value ]]; then

echo "The string is empty."

else

echo "The string is non-empty string."

fi

Why Should You Manage Empty Strings

Handling empty strings is crucial in Bash scripting. If not managed properly, they can lead to unexpected issues, primarily when used as arguments or parameters. Ensuring your scripts calculate string lengths and check for empty strings makes them more reliable and less prone to execution errors.

Patterns and Wildcards

In Bash scripting, pattern matching and wildcards are essential tools for text processing. They provide a productive approach to searching, filtering, and working with data. Acknowledging and applying these patterns guarantees adaptability when working with strings, improving accuracy and control. 

Advanced Pattern Matching

Extended globbing provides advanced pattern recognition capabilities in Bash but requires the shopt command to be enabled.

shopt -s extglob

# Using advanced patterns

str=“54321”

if [[ $str== +([0-9]) ]]; then

echo "The string contains only numbers."

fi

Wildcard Characters in Bash Scripts

In pattern matching, wildcards are characters that stand in for other characters. When handling filenames and string data in Bash, they are very helpful in working with multiple files.

In Bash scripting, the most often used wildcards are:

*: Compatible with any character, even zero.
?: Only one character is matched.

For instance,

echo *.gzip

# This will display all files with a .gzip extension in the current directory.

Pattern Matching in Strings

In addition, Bash allows pattern matching within strings, which makes it possible to find particular patterns or sequences within text input.

str=“Linux is easy“

if [[ $str == Lin* ]]; then

#here if the string matches with the comparative value in condition, then,

echo "String starts with Open"

else

echo "String doesn't start with Open"

fi

Case Conversion And Sensitivity

Case sensitivity is important in Bash scripting. By default, Bash script execution sees Hello and hello as different strings because Bash comparison is case-sensitive. 

Here are some use cases with easy-to-follow syntax-based examples:

Fundamental Case Sensitivity

It is important to distinguish the accurate representation of two strings when comparing them.

s1=“RS”

s2=“rs”

# Case-sensitive comparison

if [[ $s1 == $s2 ]]; 

then

echo "Strings are the same."

else

echo "Strings are different."

fi

Lowercase

The basic syntax to change a string’s entire character set to lowercase is as follows:

string=“REDSWITCHES”

lowercase=“${string,,}”

echo $lowercase

For example:

#!/bin/bash

string1="Hello World"

string2="hello world"

# Convert both strings to lowercase using parameter expansion

lowercaseString1="${string1,,}"

lowercaseString2="${string2,,}"

# Compare the lowercase strings

if [ "$lowercaseString1" = "$lowercaseString2" ]; 

then

    echo "The strings are the same (case-insensitive comparison)."

else

    echo "The strings are different."

fi

Case Conversion

String operations become more versatile with the techniques provided by case conversion in Bash.

string=“RedSwitches”

uppercase=“${string^^}"

echo $uppercase

# Output: REDSWITCHES 

Comparison of Strings Without Considering the Case

In certain situations, you may want a string comparison without considering the case of the strings:

str1=“Hello”

str2=“hellO”

# Case-insensitive comparison

if [[ ${str1,,} == ${str2,,} ]]; 

then

echo "Strings match, irrespective of their case."

fi

Also Read: How to Read Files Line by Line in a Bash Script [5 Simple Methods Inside!]

Conclusion : Bash Sting Comparison

Bash string comparison is vital in shell scripting, empowering developers to make decisions based on string content. By using operators like == or !=, developers can easily check for equality or inequality. The < and > operators add the ability for lexicographical comparisons, while [[ … ]] offers extended functionality.

Knowing how to compare strings in Bash is essential for creating effective conditional statements and controlling script flow. 

RedSwitches offers the best dedicated server pricing and delivers instant dedicated servers, usually on the same day the order gets approved. Whether you need a dedicated server, a traffic-friendly 10Gbps dedicated server, or a powerful bare metal server, we are your trusted hosting partner.

FAQs

Q. What is string comparison in Bash?

String comparison in Bash refers to comparing two strings to check if they are equal, not equal, empty, or if one contains the other. This is useful for various conditional operations in Bash scripting. 

Q. How do you check if two strings are equal in Bash?

To check if two strings are equal in Bash, use the comparison operator == within square brackets. For example, you can use the following syntax: 

if [ "$string1" == "$string2" ]; 

then 

echo "Strings are equal";

else 

echo "Strings are different"; 

fi

Q. How do you compare two strings using regular expressions in Bash?

In Bash, you can use the comparison operator =~ within a conditional statement to compare two strings using regular expressions. For example, you can use the following syntax: 

if [[ "$string1" =~ $regex ]]; 

then 

echo "String contains the substring"; 

else 

echo "String does not contain the substring"; 

fi

Q. How to check if a string is empty in Bash?

To check if a string is empty in Bash, use the -z comparison operator within square brackets. For example, you can use the following syntax: 

if [ -z "$string" ]; 

then 

echo "String is empty"; 

else 

echo "String is not empty"; 

fi

Q. What is the syntax for comparing two strings in Bash?

The syntax for comparing two strings in Bash involves using the comparison operators within square brackets and a conditional statement. You can use operators like == for equality, != for inequality, and =~ for regular expression-based comparison.

Q. How do you check if a string contains a substring in Bash?

In Bash, you use the comparison operator =~ and a regular expression representing the substring to check if a string contains a substring. You can then perform the check within a conditional statement.

Q. Why is string comparison important in Bash scripting?

String comparison is important in Bash scripting as it allows you to perform conditional operations based on the comparison results. This is essential for writing Bash scripts that need to compare and operate on different strings.

Q. Should double quotes be used around the strings when comparing two strings in Bash?

Yes, when comparing two strings in Bash, it is recommended to use double quotes around the strings to handle cases where the strings may contain spaces or special characters. This helps to ensure accurate string comparison.

Q. What are the standard operators used to compare strings in Bash?

The familiar operators used to compare strings in Bash include == for equality, != for inequality, -z to check for empty strings, and =~ for regular expression-based comparisons. These operators are essential for writing conditional statements in Bash scripts.

Q. How do you compare whether the first string is greater than the second string in Bash?

To compare whether the first string is greater than the second one in Bash, use the comparison operator > within a conditional statement. For example, you can use the following syntax: 

if [ "$string1" > "$string2" ]; 

then

echo "First string is greater"; 

else 

echo "Second string is greater or they are equal"; 

fi