GNU Find – Understanding -regex with GNU Find

findregular expressionxargs

Background

I have what I think should be a simple case. I want to find all files with "cisco" in the name and do something with those files (via xargs).

Finding files with `ls`

Before I use xargs, the first step is listing all relevant files. Listing files is easy with ls | grep cisco…

[mpenning@Bucksnort post]$ ls | grep cisco
cisco-asa-double-nat.rst
cisco-asa-packet-capture.rst
cisco-eem-tcl.rst
cisco-ip-sla-tracking.rst
cisco_autonomous_to_lwap.rst
[mpenning@Bucksnort post]$

Finding files with `find`

Although it's probably not required in this specific case, find is generally considered safer when piping into xargs. However, all logic seems to go out the window when I use find -regex.

[mpenning@Bucksnort post]$ find -regextype grep -regex ".*/cisco*" -print
[mpenning@Bucksnort post]$

However, I know I can find those files…

[mpenning@Bucksnort post]$ find | grep cisco
./cisco-eem-tcl.rst
./parsing-cisco-output-w-textfsm.rst
./cisco_autonomous_to_lwap.rst
./cisco-ip-sla-tracking.rst
./cisco-asa-double-nat.rst
./cisco-asa-packet-capture.rst
[mpenning@Bucksnort post]$

Questions

I realize that find -regex has to match the full path that is returned, but why isn't find -regextype grep -regex ".*/cisco*" -print working above? Shouldn't .*/cisco* match the path?

NOTES

I know I could just use find -path "*cisco*" to solve the problem, but the point of the question is to understand why my -regex usage is wrong.

Best Answer

Finding with ls: first things first, ls | grep cisco is a bit verbose, since cisco isn't a regular expression. Try:

ls *cisco*

Using find: along the same lines, -regex is overkill with a simple, static pattern. How about:

find -name '*cisco*'

The quotes are required so the glob is interpreted by find, not the shell. Also, -print is required for many versions of find, but is optional (and the default predicate) for others (e.g. GNU find). Feel free to add it if you need it.

If you need to search for ‘cisco’ in the full pathname, you could try this:

find -path '*cisco*'

which is equivalent to find | fgrep cisco.

Using find with regular expressions: let's do that anyway, since this is what you want. Shamelessly copying from the GNU find manpage:

-regex pattern

          File  name  matches  regular  expression  pattern.  This is a match
          on the whole path, not a search.  For example, to match a file named
          `./fubar3', you can use the regular expression `.*bar.' or `.*b.*3',
          but not `f.*r3'.

What this means is that your regular expression is wrapped in an invisible ^...$, so it must match every character in the full pathname of the file. So, as nwildner and otokan said in the comments, you should use something like:

find -regex '.*cisco.*'

And you don't even need the -regextype for something this simple.

Related Solutions

Grep ‘OR’ regex problem

With normal regex, the characters (, | and ) need to be escaped. So you should use

$ grep "^ID.*\(ETS\|FBS\)" my_file.txt

You don't need the escapes when you use the extended regex (-E)option. See man grep, section "Basic vs Extended Regular Expressions".

‘regex’ and ‘name’ directives in find

-name pattern
              Base of file name (the path with the leading directories
              removed) matches shell pattern pattern.  Because the leading
              directories are removed, the file names considered for a match
              with -name will never include a slash, so `-name a/b' will
              never match anything (you probably need to use -path instead).
              A warning is issued if you try to do this, unless the
              environment variable POSIXLY_CORRECT is set.  The
              metacharacters (`*', `?', and `[]') match a `.' at the start
              of the base name (this is a change in findutils-4.2.2; see
              section STANDARDS CONFORMANCE below).  To ignore a directory
              and the files under it, use -prune; see an example in the
              description of -path.  Braces are not recognised as being
              special, despite the fact that some shells including Bash
              imbue braces with a special meaning in shell patterns.  The
              filename matching is performed with the use of the fnmatch(3)
              library function.  Don't forget to enclose the pattern in
              quotes in order to protect it from expansion by the shell.

It uses shell patterns not regex.

Source: find(1)

From the GNU manual under name:

Here are ways to search for files whose name matches a certain pattern. See Shell Pattern Matching, for a description of the pattern arguments to these tests.

2.1.4 Shell Pattern Matching

find and locate can compare file names, or parts of file names, to shell patterns. A shell pattern is a string that may contain the following special characters, which are known as wildcards or metacharacters.

You must quote patterns that contain metacharacters to prevent the shell from expanding them itself. Double and single quotes both work; so does escaping with a backslash.

*
Matches any zero or more characters.
?
Matches any one character.
[string]
Matches exactly one character that is a member of the string string. This is called a character class. As a shorthand, string may contain ranges, which consist of two characters with a dash between them. For example, the class ‘[a-z0-9_]’ matches a lowercase letter, a number, or an underscore. You can negate a class by placing a ‘!’ or ‘^’ immediately after the opening bracket. Thus, ‘[^A-Z@]’ matches any character except an uppercase letter or an at sign.
\
Removes the special meaning of the character that follows it. This works even in character classes.
In the find tests that do shell pattern matching (‘-name’, ‘-wholename’, etc.), wildcards in the pattern will match a ‘.’ at the beginning of a file name. This is also the case for locate. Thus, ‘find -name '*macs'’ will match a file named .emacs, as will ‘locate '*macs'’.

Slash characters have no special significance in the shell pattern matching that find and locate do, unlike in the shell, in which wildcards do not match them. Therefore, a pattern ‘foobar’ can match a file name ‘foo3/bar’, and a pattern ‘./srsc’ can match a file name ‘./src/misc’.

If you want to locate some files with the ‘locate’ command but don't need to see the full list you can use the ‘--limit’ option to see just a small number of results, or the ‘--count’ option to display only the total number of matches.

To answer your question:

find . -name "*.sw?" -type f