Comprehensive Guide to File Matching in Linux: From Wildcards to Regular Expressions

When operating files in Linux, the most common actions are viewing, copying, moving, and deleting. Behind these commands, a low-key yet ubiquitous helper is the wildcard.

However, sometimes the filenames to match are too numerous or complex, and wildcards fall short. At this point, regular expressions come into play.

In this article, we will clarify the differences and connections between these two, as well as when to use each.

1. Wildcards: The Basics of File Matching

Wildcards are the most commonly used method for file matching in Linux.

Commands like `ls`, `cp`, `mv`, `rm`, and `tar` do not actually recognize wildcards themselves; instead, the Shell expands the wildcards into actual filenames before executing the command.

For example, if you input:

ls *.log

In reality, the Shell transforms it into:

ls access.log error.log system.log

This means that the function of the wildcard is completed before the command is executed.

Sometimes you may encounter a situation where executing ls *.log results in a list of files that do not end with .log.

Don’t panic; this is usually because the nullglob option was inadvertently enabled.

Simply execute the following command to restore normalcy:

shopt -u nullglob

2. Common Wildcard Patterns

There are several commonly used patterns:

*: Matches any character of any length (excluding /). Example: *.txt matches all files ending with .txt.
?: Matches any single character. Example: ?.sh matches a.sh, b.sh, etc., but does not match ab.sh.
[abc]: Matches any one character within the brackets. Example: [abc].log matches a.log, b.log, and c.log.
[!abc] or [^abc]: Matches characters not in the brackets. Example: [!0-9]* matches files that do not start with a digit.
[0-9]: Matches characters within a specified range. Example: file[0-9].txt matches file0.txt to file9.txt.

These patterns are sufficient for most daily scenarios, such as batch deleting logs, moving scripts, and copying files of the same type.

3. Extended Wildcards: More Flexible Matching

If you enable extended wildcards with shopt -s extglob, you can use more powerful patterns.

Here are a few examples:

@(foo|bar): Matches foo or bar. Example: @(foo|bar).txt matches foo.txt and bar.txt.
*(pattern): Matches zero or more repetitions. Example: *(test) can match an empty string, test, or testtest.
+(pattern): Matches one or more repetitions. Example: +(foo|bar) matches foofoo, barfoo, etc.
?(pattern): Matches zero or one. Example: ?(debug).log matches app.log or appdebug.log.
!(pattern): Matches strings that do not conform to any pattern in the brackets. Example: !(tmp|bak) matches all files except tmp and bak.

This syntax may look a bit like regular expressions, but it is still parsed by the Shell itself.

It works especially well for files with regular naming conventions, such as grouped logs or versioned files.

4. Path-Level Matching: The Recursive Power of globstar

Furthermore, you can enable the ** recursive wildcard with shopt -s globstar:

ls **/*.sh

This will recursively match all .sh files in the current directory and all subdirectories.

This is very suitable for managing large projects or multi-level file structures.

5. When Filename Rules Are Too Complex, Use Regular Expressions

Wildcards are simple and efficient, but they have inherent limitations:

They can only match “filenames” and do not cross directories by default (unless using **);
They have limited expressiveness, making them unsuitable for complex naming patterns like dates.

At this point, it is time to use regular expressions.

The find command can use both wildcards (-name) and regular expressions (-regex).

Practical Uses of `find`:

1. Use wildcards to match filenames (most common)

find . -name "*.log"

2. Use regular expressions to match complex filenames

find . -regex '.*/[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]\.log'

This matches logs in the format of 2025-10-31.log. However, we would prefer to write [0-9][0-9][0-9][0-9] as [0-9]{4}, which requires using the -regextype posix-extended option. A better solution is provided at the end of this article.

By default, find uses Emacs regular syntax, not the POSIX ERE (Extended Regular Expressions) we are familiar with.

Note: The -regex option in find matches the complete path starting from the root directory, including directory names. Therefore, the preceding .* is usually necessary, while whether to include / depends on whether you want to match the complete filename.

3. Case-insensitive matching

find /var/log -iregex '.*\(error\|warn\)\.log'

4. Combine with exec for further actions

find . -regex '.*\.bak$' -exec rm -f {} \;

6. Wildcards or Regular Expressions? How to Choose the Right One

If you are just doing simple matching in the current directory, wildcards are the fastest.
For recursive file searches, use find -name.
If the filename pattern is too complex (like dates or version numbers), use find -regex.
To search for file contents, use grep -E.

In summary:

Wildcards quickly match filenames, while regular expressions match complex patterns; wildcards are expanded by the Shell, while regular expressions are parsed by commands.

7. Conclusion

Wildcards are the matching language of the Shell;
Extended wildcards (extglob) make it more powerful;
globstar enables recursion;
Regular expressions are more complex matching tools, best used in conjunction with find and grep<code> for maximum power.

💡 Bonus: Making `find` Regular Expressions More Convenient

As mentioned earlier, to allow find to support regex patterns like <code>{2} and +, you need to add the -regextype posix-extended option.

The problem is that typing this long string every time can be cumbersome.

A more convenient approach is to write a small function that automatically adds it for you (note: after copying the code, you may need to replace whitespace characters with spaces to run it):

efind() {  # Save the original parameter array  args=("$@")
  # Find the position of -regex or -iregex  idx=-1  for i in "{!args[@]}"; do    if [[ "${args[$i]}" == "-regex" || "${args[$i]}" == "-iregex" ]]; then      idx=$i      break    fi  done
  if [ $idx -ge 0 ]; then    # Insert -regextype posix-extended before -regex/-iregex    prefix=( "${args[@]:0:$idx}" )    suffix=( "${args[@]:$idx}" )    args=( "${prefix[@]}" -regextype posix-extended "${suffix[@]}" )  fi
  # Call the system's find (to avoid recursive calls to the function itself)  command find "${args[@]}"}

Add this function to your toolbox, and you can use it like this:

efind . -regex '.*/[0-9]{4}-[0-9]{2}-[0-9]{2}\.log'

This function will automatically insert -regextype posix-extended in the appropriate place, making it both safe and convenient.

Comprehensive Guide to File Matching in Linux: From Wildcards to Regular Expressions

1. Wildcards: The Basics of File Matching

Wildcards are the most commonly used method for file matching in Linux.

For example, if you input:

2. Common Wildcard Patterns

There are several commonly used patterns:

3. Extended Wildcards: More Flexible Matching

4. Path-Level Matching: The Recursive Power of globstar

5. When Filename Rules Are Too Complex, Use Regular Expressions

Practical Uses of `<span><span>find</span></span>`:

6. Wildcards or Regular Expressions? How to Choose the Right One

7. Conclusion

💡 Bonus: Making `<span><span>find</span></span>` Regular Expressions More Convenient

Recommended Reading

Leave a Comment Cancel reply

1. Wildcards: The Basics of File Matching

Wildcards are the most commonly used method for file matching in Linux.

For example, if you input:

2. Common Wildcard Patterns

There are several commonly used patterns:

3. Extended Wildcards: More Flexible Matching

4. Path-Level Matching: The Recursive Power of globstar

5. When Filename Rules Are Too Complex, Use Regular Expressions

Practical Uses of <span><span>find</span></span>:

6. Wildcards or Regular Expressions? How to Choose the Right One

7. Conclusion

💡 Bonus: Making <span><span>find</span></span> Regular Expressions More Convenient

Recommended Reading

Related posts

Leave a Comment Cancel reply

Practical Uses of `<span><span>find</span></span>`:

💡 Bonus: Making `<span><span>find</span></span>` Regular Expressions More Convenient