Number of files inside a directory where file names may have new lines (or any other weird char)

Question

I want to know the number of items (files, sub-directories etc) inside a particular directory.

There seems to be a lot of questions about it but most, if not all, answers seems to rely on wc -l. For instance:

ls -1 | wc -l

But that will give the wrong answer if one or more files have new lines in their names. Another problem here is that ls -1 might return more than just files.

A non portable answer was hidden inside the comments of one of the thousands similar questions. Works, but unfortunately it relies on -printf which is not available in my distro.

find -maxdepth 1 -type f -printf "\n" | wc -l (by godlygeek)

Is there a more portable solution that can correctly handle files containing any char in their names?

Answer 1

Assuming you don’t need your positional parameters, you can set them and count them:

set -- .* *
echo $#

This can be in a function, or in a subshell, to limit the impact of the set:

countfiles() {
    set -- .* *
    echo $#
}
countfiles

or

(set -- .* *; echo $#)

Only the function’s or subshell’s parameters are “lost” here, the positional parameters in the main context are untouched.

You can specify a path too:

set -- path/to/dir/.* path/to/dir/*
echo $#

The exact expansion of hidden files will depend on shell settings; POSIX shells should include . and .. when expanding .*, so these will be counted. If you don’t want to count them, check that they are included (look at $1 and $2), and subtract two from the result.

In some shells, dot expansion can be configured, and/or other expansions (.[^.]* ..?*) can be used to exclude . and ..; thus in Bash, using dotglob:

shopt -s dotglob
set -- *
echo $#

Answer 2

The following is probably not very elegant, but should be portable. It relies on shell arithmetic:

n=0; for f in *; do n=$((n+1)); done; echo "$n"

Note that this will not count hidden files. If you need them too, you would have to extend the iteration list:

n=0; for f in * .*; do n=$((n+1)); done; echo "$n"

Depending on your shell, the n=$((n+1)) can be golfed into ((n++)).

Note that the explicit shell loop makes this approach rather slow, which can become noticable if you are dealing with a directory containing several thousand files. The answer by Stephen Kitt is substantially faster, although a little obscure if you are new to shell scripting.

Answer 3

If you want POSIX compliance (which also means excluding bash and its shopt -s dotglob), one way of counting the files in a directory is this somewhat slow approach

find . -path './?*' ! -type f -prune -o -type f -exec echo x \; | wc -l

If you don't care what you've got you can simplify this considerably

find . -path './?*' -prune -exec echo x \; | wc -l

Actually, building on another answer, this will give you a count of all the non-directories (probably just files, but would include devices and pipes if any were present) in the current directory

( set -- * .* ; all=$#; set -- */ .*/ ; echo $(( all - $# -2 )) )

Answer 4

Try find'ing the inode numbers instead... which does not involve the filename.

$ find . -type f -printf '%i\n' 

But seeing your find doesnt have the printf

$ find . -type f -name 'test*' -exec stat -c "%i" {} \; 

will return just the inodes

$ find . -type f -name 'test*' -exec stat -c "%i" {} \; | wc -l

will give you the count you need.

Hope this helps.