Check If Output Contains String in Bash

1. Overview

In this article, we will see how to check if output contains String in Bash using grep, Conditional Expressions, awk, sed commands with various options.

2. Introduction to Problem Statement

We will use ls -l to list directories and files in long format and search for .txt string in the output.
For example:

Our goal is to search for .txt in ls -l command’s output. Expected output is:

3. Using grep Command

The grep is a text-searching utility optimized for pattern matching, making it highly efficient and fast for such tasks.

Let’s see with help of example:

Explanation:

• This method uses grep -q ".txt", where -q stands for "quiet". It causes grep to not output anything but to exit with status 0 if the pattern is found, and 1 otherwise.
• The if statement then checks the exit status of grep. If grep finds the string, the first block (echo "Text files found.") is executed; if not, the else block executes.

3.1 Searching for Pattern Using grep

We can use grep with -E option to search for pattern in the Output.

Suppose we need to find all .txt files in a folder. In this scenario, we can utilize *.txt as the pattern to match these specific files.

The -E option enables extended regular expressions, allowing us to use patterns like *.txt. This method is particularly effective for pattern matching within scripts.

3.2 Searching with case-insensitive string

By default, grep search is case-sensitive. To do a case-insensitive search, use -i option.

4. Using Bash Conditional Expressions

Bash conditional expressions are a powerful feature in shell scripting, allowing for decision-making based on the evaluation of conditions within a script.

4.1 Searching for Pattern

In Bash, the `[[ ... =~ ... ]] construct is used for regular expression matching. Here, the =~ operator matches the left-hand side $output with the regular expression $pattern on the right-hand side.

Let’s see with the help of example:

Here, if the match is found, the if block will execute. The [[ $output =~ $pattern]] condition evaluates as true and the message "Text files found." is printed. Otherwise, the condition evaluates as false, and the else block will execute with the message "No text files.".

4.2 Searching with case-insensitive string

In Bash version 4 and later, we can use the shopt -s nocasematch option to enable case-insensitive matching for the [[ ]] conditional expressions.

Example with shopt:

In this example, shopt -s nocasematch enables case-insensitive pattern matching within [[ ]], and shopt -u nocasematch is used to unset this option after the check.

This method is generally fast, especially for simple patterns and smaller outputs. However, it may be less efficient for complex patterns or large outputs compared to grep.

5. Using awk

awk is a powerful scripting language for text processing and is typically used for data extraction.
Let’s use awk to search string .txt in the output.

Explanation:

• ls -l command to list file in the directory.
• | is used to pass output of ls -lto awk command.
• awk scans the output of ls -l for lines containing .txt.
• It sets a flag found when the pattern is matched.
• The END block in awk is used to print the final output based on the found flag.

This method is highly efficient, particularly for complex data manipulation.

Further reading:

Bash Check if Array contains Value

Read more →

Check if String Starts with Another String in Bash

Read more →

6. Using sed with grep Command

The sed (Stream Editor) is a powerful and versatile text processing tool that performs text transformations on an input stream (a file or input from a pipeline).

Here, we will use sed for preprocessing and grep for final check. Let’s see with the help of example:

Explanation:

• sed '/\.txt/!d' deletes all lines not containing .txt.
• The output is then piped to grep to check if there’s any remaining text.
• This method combines sed for preprocessing with grep for final detection.

Let’s understand more about sed '/\.txt/!d':

• sed: This is the stream editor command in Unix/Linux, used for parsing and transforming text.

• '/.txt/!d': This is the expression passed to sed, consisting of two parts:

  • /.txt/: This part is a pattern match. It looks for lines that contain the string .txt. The dot . is escaped as . to indicate a literal period character, since in regular expressions, a dot is a special character that matches any single character.

  • !: The exclamation mark is used here to negate the pattern match. It means "for lines that do not match the pattern".

  • d: This is the delete command in sed. It deletes the lines from the output.

While sed is efficient for text processing, this method may be less performant due to the use of multiple commands and pipes.

7. Conclusion

In Bash, checking if a command’s output contains a specific string can be accomplished through various methods, each with its advantages. grep stands out for its simplicity and efficiency in pattern searching. Bash conditional expressions offer a built-in solution without external dependencies. awk provides a robust approach for more complex text processing needs. Lastly, sed, combined with grep, offers a versatile approach, though it might be less efficient for simple tasks.