grep, short for "global regular expression print," is a fundamental command-line utility in Linux and other Unix-like operating systems. It's used to search plain-text data sets for lines that match a given pattern. But why is it so essential for Linux users?

For system administrators, grep is indispensable for sifting through system logs, configuration files, and other textual data to quickly identify errors, monitor system performance, and troubleshoot issues. Need to find all instances of a particular error code in a massive log file? grep can do it in seconds.

For developers, grep is a powerful tool for debugging code, searching for specific function calls, and understanding codebases. Finding where a specific variable is used throughout a project becomes a breeze. Its speed makes it invaluable when working with large codebases.

And for scripting, grep allows the user to search files for specific lines that have certain patterns in them and only return those lines. It allows powerful automation through even simple bash scripts.

The name grep originates from the "global regular expression print" command in the ed text editor, a standard part of early Unix systems. Ken Thompson created grep as a standalone utility, showcasing its importance even in the early days of Unix. Grep quickly became an essential utility due to its efficiency in processing text.

At its core, grep excels at searching, filtering, and analyzing text-based data. Whether you're looking for a specific keyword, a complex pattern, or simply trying to extract relevant information from a large file, grep provides the tools you need.

This article will guide you through mastering grep, starting with the fundamentals and progressing to advanced techniques. We'll cover essential options, regular expressions, practical use cases, and how to integrate grep into your scripting workflows. By the end of this article, you'll be well-equipped to leverage the full power of grep to efficiently manage and analyze text data in your Linux environment.

Getting Started with grep: The Fundamentals

The fundamental purpose of grep is to search text. Its basic syntax is:

Let's break down each element:

• OPTIONS: These are flags that modify the behavior of grep. They are optional. You can specify multiple options, often with short (e.g., -i for case-insensitive search) or long (e.g., --ignore-case) forms. We will explore many of the most useful options in the next section.
• PATTERN: This is the search term you are looking for. It can be a simple string of characters ("keyword"), or a more complex regular expression. The pattern should generally be enclosed in double quotes ( "...") to prevent the shell from interpreting special characters within the pattern.
• FILE...: This specifies the file(s) that grep should search within. You can specify a single file, multiple files separated by spaces, or use wildcards to match multiple files. If you don't specify any files, grep will read from standard input (e.g., the output of another command piped to grep).

Basic Examples

Here are some basic examples to illustrate how grep is used:

• Searching a single file:
  
  Shell

  1	grep "keyword" filename.txt

  
  This command searches the file named filename.txt for lines containing the word "keyword" and prints those lines to the terminal.
• Searching multiple files:
  
  Shell

  1	grep "keyword" file1.txt file2.txt file3.txt

  
  This command searches three files: file1.txt, file2.txt, and file3.txt for lines containing the word "keyword" and prints those lines to the terminal, along with the name of the file where the match was found.
• Searching all files in the current directory:
  
  Shell

  1	grep "keyword" *

  
  This command uses the * wildcard to search all files in the current directory for lines containing the word "keyword".
  Warning: Be careful when using the asterisk ( *) wildcard. It expands to include all files in the current directory, including hidden files (files whose names begin with a dot, like .hidden_file.txt) and potentially other unexpected files. This can lead to unintended consequences, especially if your pattern contains special characters that might be interpreted by the shell during filename expansion.

Understanding Patterns and Files

At its core, grep searches for occurrences of a specific pattern within the provided files. The pattern is a sequence of characters that grep attempts to match within each line of the input file(s). If a line contains the pattern, grep, by default, prints that line to the standard output.

The term "file" in this context refers to any readable file that contains textual data. Grep can process a wide variety of file types, including source code files, configuration files, log files, plain text documents, and more.

Shell Expansion

It's crucial to understand how the shell (e.g., Bash) interprets special characters like * and ? before passing arguments to grep. This process is called shell expansion or globbing.

When you use *, the shell replaces it with a list of all non-hidden files and directories in the current directory (that aren't hidden, starting with a dot). Similarly, ? matches any single character. So, if you have files named file1.txt, file2.txt, and file3.txt, the command grep "keyword" file?.txt will expand to grep "keyword" file1.txt file2.txt file3.txt before grep even sees the command.

Essential grep Options: Controlling Your Search

While the basic grep command is useful, its true power lies in its various options, which allow you to fine-tune your searches and extract precisely the information you need. Here's a look at some of the most essential grep options:

Case-Insensitive Search (-i)

By default, grep performs case-sensitive searches, meaning that it distinguishes between uppercase and lowercase letters. The -i option tells grep to ignore case distinctions, effectively making the search case-insensitive. This is particularly useful when you're not sure of the capitalization used in the text you're searching.

Example: Let's say you want to find all occurrences of the word "Linux" in a file, but you're not sure if it's capitalized as "Linux", "linux", "LINUX", or some other variation. The -i option will match all of these:

Inverted Match (-v)

The -v option inverts the match. Instead of displaying lines that contain the specified pattern, it displays lines that do not contain the pattern. This is exceptionally useful for filtering out unwanted lines from logs, configuration files, or other data.

Example: Imagine you're analyzing a log file and want to see all lines except those containing the word "DEBUG". You can use the following command:

This will show you all the lines in application.log that don't include the string "DEBUG", effectively filtering out the debug messages.

Line Numbers (-n)

The -n option displays the line number along with each matching line. This is incredibly helpful for pinpointing the exact location of matches within a file, making it invaluable for debugging code or analyzing log files.

Example: If you're troubleshooting an error reported in a log file, knowing the exact line number where the error occurred can save you a lot of time. If you run:

The output might look something like this:

This tells you that the error "NullPointerException" occurred on line 123 of the error.log file.

Counting Matches (-c)

The -c option provides a quick summary of occurrences by displaying only a count of the number of matching lines, rather than the lines themselves. This is useful when you need to know how many times a pattern appears in a file without seeing each individual match.

Example: To quickly determine how many error messages are in a log file, you can use:

The output will be a single number representing the number of lines in application.log that contain the word "ERROR".

Files with Matches Only (-l)

The -l (lowercase L) option lists only the names of the files that contain at least one match for the specified pattern. It doesn't display the matching lines themselves. This is handy for quickly identifying which files within a set contain a particular pattern.

Example: Suppose you're searching through a directory of configuration files to find which ones contain a specific setting. You can use:

This will output a list of .conf files in the current directory that contain the string database\_host =.

Whole Word Matching (-w)

The -w option ensures that the pattern matches only whole words, preventing partial matches. For example, if you search for "the" with -w, it will only match the word "the" and not words like "there" or "other". This can be useful for avoiding false positives when searching for specific keywords.

Example: If you want to find all instances of the word "error" but avoid matching words like "terror" or "erroneous", use:

Recursive Search (-r or -R)

The -r or -R options enable recursive searching, allowing grep to traverse through all files within a directory and its subdirectories. The key difference between the two is how they handle symbolic links: -r does not follow symbolic links, while -R does follow them.

Example: To search for all occurrences of "functionName" within all .py files in a project directory and its subdirectories, you can use:

For more advanced file searching capabilities, including searching by file type, size, and modification date, check out our guide on the find command.

Only Matching Part (-o)

The -o option tells grep to display only the matching part of the line, rather than the entire line. This is useful when you only need to extract the specific text that matches the pattern.

Example: If you want to extract all the IP addresses from a log file, you could use a regular expression with -o:

This will print each IP address found in logfile.txt on a separate line.

Context Control (-A, -B, -C)

Sometimes, you need to understand the context surrounding a matching line to get a better understanding of the data. Grep provides options to display lines before, after, or around the matching line:

• -A NUM: Prints NUM lines *after* the matching line (A for After).
• -B NUM: Prints NUM lines *before* the matching line (B for Before).
• -C NUM: Prints NUM lines *both before and after* the matching line (C for Context). This is equivalent to using -A NUM -B NUM.

Example: To see two lines of context after each line containing the word "error" in a log file, you would use:

This will print the matching line, followed by the next two lines in the file, providing valuable context for troubleshooting.

Unleashing the Power of Regular Expressions

Regular expressions (regex or regexp) are sequences of characters that define a search pattern. They are an incredibly powerful tool for pattern matching in text, allowing you to perform complex and flexible searches far beyond what's possible with simple string matching. In the context of grep, regular expressions enable you to search for lines that conform to specific patterns, rather than just literal strings.

Why are regular expressions so powerful? They provide a concise and flexible way to describe complex patterns in text. Instead of searching for a specific word, you can search for variations of that word, or even entire classes of words that match a certain structure. They are invaluable for:

• Data validation: Ensuring that data conforms to a specific format (e.g., email addresses, phone numbers).
• Data extraction: Pulling specific pieces of information from large text files (e.g., IP addresses, URLs).
• Text manipulation: Replacing or modifying text based on complex patterns.
• Log analysis: Identifying specific events or errors in log files.

Key Metacharacters

Regular expressions use special characters, called metacharacters, to define the search pattern. Here's a detailed explanation of some key metacharacters:

• . (dot): The dot matches any single character (except for newline character in some implementations, though it can usually be made to match a newline as well).
  Example: The pattern "a.c" would match "abc", "a1c", "a#c", and even "a c".
• * (asterisk): The asterisk matches zero or more occurrences of the preceding character or group. This is a "greedy" quantifier, meaning it will match as much as possible.
  Example: The pattern "ab*c" would match "ac", "abc", "abbc", "abbbc", and so on. It matches 'a', followed by zero or more 'b's, followed by 'c'.
• + (plus): The plus matches one or more occurrences of the preceding character or group. Like the asterisk, it's a greedy quantifier.
  Example: The pattern "ab+c" would match "abc", "abbc", "abbbc", but *not* "ac". It requires at least one 'b' between 'a' and 'c'.
• ? (question mark): The question mark matches zero or one occurrence of the preceding character or group.
  Example: The pattern "ab?c" would match "ac" and "abc", but not "abbc". It allows for an optional 'b' between 'a' and 'c'.
• ^ (caret): The caret matches the beginning of a line.
  Example: The pattern "^abc" would only match lines that start with "abc". A line like "defabc" would not match.
• $ (dollar sign): The dollar sign matches the end of a line.
  Example: The pattern "xyz$" would only match lines that end with "xyz". A line like "xyzabc" would not match.
• [] (square brackets): Square brackets define a character class, matching any single character within the brackets.
  Example: The pattern [abc] would match "a", "b", or "c". The pattern [a-z] matches any lowercase letter, and [0-9] matches any digit.
• [^] (negated character class): A negated character class matches any single character not within the brackets.
  Example: The pattern [^abc] would match any character *except* "a", "b", or "c". The pattern [^0-9] matches any character that is not a digit.
• \ (backslash): The backslash is used for escaping special characters, allowing you to treat them as literal characters instead of metacharacters.
  Example: To search for a literal dot (.), you would use the pattern "\.". To search for a literal backslash, you would use "\\".
• | (pipe): The pipe represents alternation (OR), allowing you to match one of several patterns.
  Example: The pattern cat|dog|bird would match "cat", "dog", or "bird".
• () (parentheses): Parentheses are used for grouping characters together and creating capturing groups. Capturing groups allow you to refer back to the matched text later in the pattern or in a replacement string (using backreferences).
  Example: The pattern (abc)+ would match one or more occurrences of the group "abc", such as "abc", "abcabc", "abcabcabc", and so on.

Regex Examples

Here are some practical examples of using regular expressions with grep:

• Lines starting with "abc":
  
  Shell

  1	grep "^abc" file.txt

  
  This command searches for lines in file.txt that begin with the string "abc".
• Lines ending with "xyz":
  
  Shell

  1	grep "xyz$" file.txt

  
  This command searches for lines in file.txt that end with the string "xyz".
• Validating email addresses (simplified):
  
  Shell

  1	grep -E "[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}" file.txt

  
  This command uses the -E option (for extended regular expressions, explained below) and searches for strings that resemble email addresses. This is a simplified version and might not catch all valid email addresses, but it's a good starting point. It looks for one or more alphanumeric characters, dots, underscores, percent signs, plus or minus signs before an @ symbol. After the @ symbol is at least one alphanumeric character, dot or hyphen. Finally the domain needs to have a dot followed by two or more aplhanumeric characters (like .com or .net).
• Matching IP addresses:
  
  Shell

  1	grep -E "[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}" file.txt

  
  This command uses -E to find strings that match the typical pattern of an IP address (four sets of one to three digits separated by dots).

Extended Regular Expressions (-E)

The -E option tells grep to use extended regular expressions. Extended regular expressions include additional metacharacters and features that make patterns more concise and readable. For example, with extended regular expressions, you don't need to escape the pipe symbol ( |) for alternation, and you have access to quantifiers like + and ? without escaping them.

While standard (or "basic") regular expressions are always available in grep, the -E option is often preferred because it provides a more intuitive and expressive way to define patterns.

Perl Compatible Regular Expressions (-P)

The -P option enables Perl Compatible Regular Expressions (PCRE), which offer an even richer set of features and metacharacters than extended regular expressions. PCRE is a very powerful and flexible regular expression engine that is widely used in programming languages like Perl and Python.

While PCRE offers the greatest flexibility, it can also be more complex and potentially slower than basic or extended regular expressions. Therefore, it's best to use PCRE only when you need its advanced features. Be aware that not all grep implementations support the -P option.

Practical grep Examples: Real-World Use Cases

To truly appreciate the power of grep, it's helpful to see it in action. Here are several real-world examples demonstrating how grep can be used in various scenarios.

Basic Examples

These simple examples illustrate the most basic usage of grep:

• Shell

  1	grep "a" file.txt

  
  This command searches file.txt for all lines containing the letter "a".
• Shell

  1	grep "g" file.txt

  
  This command searches file.txt for all lines containing the letter "g".
• Shell

  1	grep "on" file.txt

  
  This command searches file.txt for all lines containing the string "on".

Log Analysis

Grep is an invaluable tool for analyzing log files to identify errors, track events, and troubleshoot problems.

• Finding error messages:
  
  Shell

  1	grep "ERROR" error.log

  
  This command searches the error.log file for all lines containing the word "ERROR", which is a common convention for indicating error messages. It quickly isolates the lines that require attention.
• Filtering by date:
  
  Shell

  1	grep "2023-10-27" access.log

  
  This command searches the access.log file for all lines containing the date "2023-10-27", allowing you to focus on events that occurred on a specific day. The exact date format will depend on how your logs are configured.

System Administration

Grep is frequently used by system administrators to manage processes, find files, and review system configurations.

• Listing processes containing a specific keyword:
  
  Shell

  1	ps aux | grep "process_name"

  
  This command combines the ps aux command (which lists all running processes) with grep to filter the output and display only the processes whose names contain the string "process\_name". This is useful for monitoring specific processes or identifying resource-intensive processes. It's common to add another grep -v grep to the end of the command to filter out the grep process itself.
  
  Shell

  1	ps aux | grep "process_name" | grep -v grep

• Finding files owned by a particular user:
  
  Shell

  1	ls -l | grep "username"

  
  This command combines the ls -l command (which lists files and directories with detailed information) with grep to filter the output and display only the files and directories owned by the user "username". This is useful for managing user accounts and ensuring proper file ownership. To change file ownership, see our guide on the chown command. For a more detailed explanation of ls output, see our article: Unleashing the Power of ls.
• Finding files with specific permissions:
  
  Shell

  1	ls -l | grep "^-rwxr-xr-x"

  
  This command uses ls -l to list files and then filters the output using grep to show only files that have the specific permissions "-rwxr-xr-x". The ^ ensures that the permission string is at the beginning of the line. This can be useful for identifying files with potentially insecure permissions or for enforcing specific security policies. To modify file permissions, refer to our guide on the chmod command.

Code Searching

Grep is a valuable tool for developers searching through codebases.

• Finding all occurrences of a function call in a codebase:
  
  Shell

  1	grep -r "my_function(" /path/to/codebase

  
  This command recursively searches through the specified codebase for all instances where the function "my\_function(" is called. The parenthesis are escaped to be interpreted as literal characters.

Configuration File Review

Grep is often used to find particular configurations.

• Finding specific settings in a configuration file:
  
  Shell

  1	grep "setting_name =" /etc/application.conf

  
  This command searches the specified configuration file for lines that contain the text "setting\_name =".

grep in Bash Scripting: Automating Tasks

Grep is not only a powerful command-line tool but also a valuable component in Bash scripts, enabling you to automate tasks based on pattern matching in text files. By integrating grep into your scripts, you can create dynamic and responsive workflows that adapt to the contents of your data.

Using grep in Conditional Statements

One common use of grep in Bash scripts is within conditional statements. You can use the exit status of grep (0 for success, non-zero for failure) to control the flow of your script.

The -q (quiet) option is particularly useful in conditional statements. When -q is used, grep suppresses its normal output to standard output. It will still return an exit code indicating success (0) if the pattern is found, or failure (non-zero) if not found. This allows you to test for the presence of a pattern without cluttering the terminal with unnecessary output.

Storing grep Output in Variables

You can store the output of grep in a variable for further processing within your script. This allows you to manipulate the matching lines or use them as input for other commands.

In this example, the variable result will contain all the lines from file.txt that match the specified pattern.

Example Script

Here's a simple example of a Bash script that uses grep to check if a feature is enabled in a configuration file:

This script first defines the name of the configuration file in the FILENAME variable. Then, it uses grep -q to check if the line "ENABLED=true" exists in the file. Based on the exit status of grep, the script prints a message indicating whether the feature is enabled or disabled.

Using grep with loops

You can combine grep with loops to process each line of a file that matches a pattern. For example, you can use a while loop to iterate over the matching lines and perform some action on each line:

This script uses process substitution < <(command) to pass the output of grep to the while loop. The IFS= read -r line construct is used to read each line into the line variable without any word splitting or backslash interpretation.

Error handling: Checking grep's exit code

It's good practice to check the exit code of grep in your scripts to handle cases where the pattern is not found or an error occurs. You can access the exit code of the last executed command using the $? variable.

By checking the exit code, you can ensure that your script handles both successful and unsuccessful grep executions gracefully.

Advanced grep Techniques: Becoming a grep Expert

Once you've mastered the fundamentals of grep, you can unlock even greater power by exploring advanced techniques that combine grep with other commands and tools. These techniques allow you to perform complex filtering, handle tricky filenames, and leverage specialized grep alternatives for enhanced performance.

Piping with grep

One of the most common and powerful techniques is to pipe the output of another command to grep. This allows you to chain commands together and perform complex filtering operations in a single line.

In this example, the output of command is piped to grep, which then filters the output and displays only the lines that match the specified pattern. This is a fundamental technique for combining the power of multiple command-line utilities.

Example: To list all currently running processes that are related to Apache, you can use the following command:

The ps aux command lists all running processes, and the output is then piped to grep, which filters the list to show only the processes that contain the string "apache" in their name or arguments.

grep with xargs: Handling filenames with spaces

Filenames containing spaces can be problematic for many command-line utilities, including grep. The xargs command provides a way to handle filenames with spaces correctly. By using the -print0 option with find and the -0 option with xargs, you can safely pass filenames with spaces to grep.

Here's how this command works:

• find . -name "*.txt" -print0: This command finds all files with the .txt extension in the current directory and its subdirectories, and prints their names separated by null characters (instead of spaces).
• xargs -0 grep "pattern": This command takes the null-separated filenames from find and passes them as arguments to grep. The -0 option tells xargs to expect null-separated filenames.

This approach ensures that filenames with spaces are treated as single arguments, preventing grep from misinterpreting them.

grep with find: Combining file searching and content filtering

Another powerful combination is to use grep with the find command. This allows you to search for files based on various criteria (e.g., name, size, modification date) and then filter the contents of those files using grep.

One common way to combine find and grep is to use the -exec option of find:

This command does the following:

• find . -name "*.log": This finds all files with the .log extension in the current directory and its subdirectories.
• -exec grep "error" {} \;: For each file found, this executes the command grep "error" {}, where {} is replaced with the name of the file. The \; at the end indicates the end of the command to be executed.

This command effectively searches for the string "error" within all .log files in the specified directory and its subdirectories.

See our guide on the find command for more information.

grep Alternatives: ag (the silver searcher) and ripgrep (rg)

While grep is a powerful tool, several alternatives offer improved performance and features, especially for searching large codebases. Two popular alternatives are:

• ag (the silver searcher): Ag is designed for speed and is often significantly faster than grep, especially when searching large directories. It ignores files that match patterns in .gitignore files by default, making it ideal for searching codebases.
• ripgrep (rg): Ripgrep is another fast and feature-rich alternative to grep. It also respects .gitignore files and supports advanced features like automatic recursion, colored output, and various file type filters.

Both ag and ripgrep are excellent choices for developers who need to search codebases quickly and efficiently. They often have more sensible defaults as well, such as automatically doing recursive searches.

Tips and Best Practices

To maximize your efficiency and avoid common pitfalls when using grep, consider these tips and best practices:

• Optimizing grep Performance: Avoiding unnecessary regex complexity. Regular expressions can be powerful, but complex regex patterns can significantly slow down grep's performance, especially when searching large files. If possible, use simpler patterns or literal strings when appropriate. Avoid using overly complex regex features when a simpler approach will suffice. The simpler your pattern is, the faster grep will run.
• Common grep Mistakes: Forgetting to quote patterns, incorrect regex syntax. One of the most common mistakes is forgetting to enclose patterns in quotes, especially when they contain spaces or special characters. Failing to do so can lead to unexpected results or errors due to shell expansion. Always quote your patterns to ensure that grep receives the pattern as intended.Also, be mindful of regular expression syntax. Incorrect syntax can lead to patterns not matching what you expect, or even to errors. Double-check your regex patterns and use online regex testers to verify their behavior.
• Dealing with Large Files: Using -m (max-count) to limit output. When searching very large files, grep can produce a massive amount of output, which can be slow and overwhelming. Use the -m (max-count) option to limit the number of matching lines that grep outputs. This can significantly improve performance and make it easier to analyze the results. For example: grep -m 10 "pattern" large_file.txt will output the first 10 lines that match "pattern".
• Creating grep Aliases: Simplifying common commands. If you find yourself frequently using the same grep commands with specific options, consider creating aliases to simplify your workflow. Aliases are shortcuts that allow you to execute a longer command with a shorter, more memorable name. You can define aliases in your .bashrc or .zshrc file. For example:
  
  Shell

  1	alias gli='grep -i -n'

  
  This alias allows you to use gli to perform a case-insensitive search and display line numbers, saving you from typing grep -i -n every time.
• Security Considerations: Sanitizing user input when used in scripts. When using grep in scripts that accept user input, it's crucial to sanitize the input to prevent command injection vulnerabilities. If a user can inject arbitrary commands into the pattern that's passed to grep, they could potentially execute malicious code on your system.Use appropriate escaping techniques to prevent users from injecting special characters or commands into the grep pattern. The best way to do this is to use a safe mechanism to quote all input. If writing in bash, this means surrounding the input in single quotes (') and escaping any single quotes that are already in the user provided string.

Conclusion

In this article, we've explored the power and versatility of grep, a fundamental command-line tool for searching and filtering text in Linux and other Unix-like operating systems. We've covered the basic syntax of grep, essential options for controlling your searches, and the power of regular expressions for defining complex patterns. We've also examined practical use cases for grep in log analysis, system administration, code searching, and Bash scripting, as well as advanced techniques for combining grep with other commands and tools.

Grep remains an indispensable tool for Linux users due to its efficiency, flexibility, and wide range of applications. Whether you're a system administrator troubleshooting server issues, a developer debugging code, or a data analyst extracting insights from large datasets, grep provides a reliable and efficient way to find the information you need.

While we've covered a significant amount of ground in this article, there's always more to learn about regular expressions. We encourage you to continue exploring the world of regular expressions and experiment with different patterns to master their full potential. Many online resources and tutorials can help you deepen your understanding of regex syntax and techniques.

The best way to truly master grep is to practice and experiment with it regularly. Try using grep in your daily workflows, and don't be afraid to try new options and techniques. The more you use grep, the more comfortable and proficient you'll become with it. So go ahead, open up your terminal, and start grepping!

Regular Expression Cheat Sheet

This cheat sheet provides a quick reference to commonly used regular expression metacharacters and their meanings for use with the grep command.

Metacharacter	Description	Example
.	Matches any single character (except newline in some implementations)	a.c matches "abc", "a1c", "a#c"
*	Matches zero or more occurrences of the preceding character or group	ab*c matches "ac", "abc", "abbc", "abbbc"
+	Matches one or more occurrences of the preceding character or group (Extended Regex -E)	ab+c matches "abc", "abbc", "abbbc", but not "ac"
?	Matches zero or one occurrence of the preceding character or group (Extended Regex -E)	ab?c matches "ac", "abc"
^	Matches the beginning of a line	^abc matches lines starting with "abc"
$	Matches the end of a line	xyz$ matches lines ending with "xyz"
[]	Defines a character class, matching any single character within the brackets	[abc] matches "a", "b", or "c" [a-z] matches any lowercase letter [0-9] matches any digit
[^]	Defines a negated character class, matching any single character not within the brackets	[^abc] matches any character except "a", "b", or "c" [^0-9] matches any non-digit character
\	Escapes a special character, treating it as a literal character	\. matches a literal dot (.) \\ matches a literal backslash (\)
|	Alternation (OR), matching one of several patterns (Extended Regex -E)	cat|dog|bird matches "cat", "dog", or "bird"
()	Groups characters together and creates capturing groups (Extended/PCRE Regex -E/-P)	(abc)+ matches one or more occurrences of "abc" (e.g., "abc", "abcabc", "abcabcabc")
{n}	Matches exactly n occurrences of the preceding character or group (Extended Regex -E)	a{3} matches "aaa"
{n,}	Matches n or more occurrences of the preceding character or group (Extended Regex -E)	a{2,} matches "aa", "aaa", "aaaa", etc.
{n,m}	Matches between n and m occurrences of the preceding character or group (Extended Regex -E)	a{2,4} matches "aa", "aaa", "aaaa"
\b	Matches a word boundary. Requires Perl-compatible regular expressions (-P).	\bword\b matches "word" but not "sword" or "wordy".

Note: The -E option is required for extended regular expressions, and -P for Perl-compatible regular expressions.