Find command if filename doesn’t exists in directory

find

How I want to display the folder that do not have certain file. But the concern is, the file is same name but different cases.

Case study:
In tools directory, there are subdirectories that contain readme/README file and some of them does not have. For example

/toola/readme
/toolb/README
/toolc/ (does not have readme file)

I want find command to display only toolc folder by using this command.

find . -maxdepth 2 ! -name '*readme*' -o ! -name '*README*' | awk -F "/" '{print $$2}' | uniq

But it doesn't work. It display all file since toola doesn't have README and toolb doesn't have readme

Best Answer

You can't use find to look for files that do not exist. However, you may use find to look for directories, and then test whether the given filenames exists in those directories.

When using find to look for directories, make sure that you use -type d. Then test each of the found directories for the files README and readme.

Assuming the following directory hierarchy for some top-directory projects:

projects/
|-- toola
|   |-- doc
|   |-- readme
|   `-- src
|-- toolb
|   |-- doc
|   `-- src
|-- toolc
|   |-- README
|   |-- doc
|   `-- src
`-- toold
    |-- doc
    `-- src

Using find to find the directories directly under projects that does not contain a README or readme file:

$ find projects -mindepth 1 -maxdepth 1 -type d \
    ! -exec test -f {}/README ';' \
    ! -exec test -f {}/readme ';' -print
projects/toolb
projects/toold

Here, we find any directory directly under projects and then use the test utility to determine which one of the found directories do not contain either of the two files.

This is exactly equivalent of

find projects -mindepth 1 -maxdepth 1 -type d \
    -exec [ ! -f {}/README ] ';' \
    -exec [ ! -f {}/readme ] ';' -print

Another formulation of the above:

find projects -mindepth 1 -maxdepth 1 -type d -exec sh -c '
    for pathname do
        if [ ! -f "$pathname/README" ] &&
           [ ! -f "$pathname/readme" ]; then
            printf "%s\n" "$pathname"
        fi
    done' sh {} +

Here, we let a small in-line shell script do the actual testing for the two files and print the pathname of the directories that does not contain either of them. The find utility acts like a "pathname generator" of pathnames to directories for the in-line script to iterate over.

In fact, if the directory structure is like this, we may choose to not use find at all:

for pathname in projects/*/; do
    if [ ! -f "$pathname/README" ] &&
       [ ! -f "$pathname/readme" ]; then
        printf '%s\n' "$pathname"
    fi
done

Note the trailing slash in the projects/*/ pattern. It's this that makes the pattern only match directories (or symbolic links to directories).

A difference between doing it this way and using find is that with the above shell loop, we will exclude hidden directories under project and will include symbolic links to directories.

In all cases, we iterate over the pathnames of directories, and we test for the non-existence of the two filenames.

The only caveat is that the -f test will also be true for a symbolic link to a regular file.

Understanding the -exec option of `find`

Related Solutions

Command Line – Find Files by Filename Length

grep looks for patterns in the contents of the files. If you want to look at the names of the files, you can just use a shell glob (if you want to consider only filenames in the current directory):

echo ?.go

(By the way, it's the shell that evaluates the glob, not the echo command.)

If you want to look in directories recursively, starting with the current directory, the tool to use is find:

find . -name '?.go'

(Note that you have to quote the pattern to prevent the shell from evaluating it as a glob before find gets invoked.)

Shell – Text files containing their own name

To be maximally portable and work when filenames may include spaces or other characters from IFS, and on systems where find does not handle {} inside quotes, use find -exec in combination with sh and ordinary parameter passing:

find DIRECTORY -type f -exec sh -c 'grep -lFe "$(basename "$1")" "$1"' sh {} ';'

find DIRECTORY -type f enumerates all the ordinary files under DIRECTORY recursively. -exec ... ';' runs a command for each file it finds. The meat of it is the sh command through to {}, which:

Runs the standard shell with a script command string grep -lFe "$(basename "$1")" "$1" for every file matched, which:
- Finds the base filename of the matched file ($1) using command substitution and basename - both the command substitution and the variable are quoted to account for the cases where they may contain blanks or wildcards; and
- greps the matched file (still "$1") for that basename, using -l to print only the name of the matched file. "$1" is quoted again to account for blanks or wildcards.
And passes in two arguments to sh: "sh" and {}. sh is meant for the inline script's $0 (the name of the running program, which the shell uses for error reporting for instance). find will replace an argument consisting exactly of {} with the matched filename, so the sh script itself gets a single argument with the full file path available as $1.

This will work on any POSIX-compatible system. Using {} inside a quoted string with find -exec has implementation-defined behaviour, and so isn't portable (though it is supported by GNU grep and most of the BSDs) and is dangerous as the file name is interpreted as shell code.

Arbitrary filenames always need quoting when they may contain whitespace, wildcard characters or the value of the IFS input field separator variable is unknown; otherwise they will be split into multiple words and will make the program behave in unexpected ways.

More efficiently, you can use find -exec with + to run the minimum number of shells possible:

find DIRECTORY -type f -exec sh -c 'for x in "$@" ; do grep -lFe "$(basename "$x")" "$x" ; done' sh {} '+'

This is still portable, but provides many file paths to each execution of sh, so it doesn't start as many shells. Inside the shell program is a for loop that looks at each of the files. If this is something that's going to run frequently, this is a better option than using ";" to terminate the command.

Best Answer

Related Solutions

Command Line – Find Files by Filename Length

Shell – Text files containing their own name

Related Question