Counting files over a loop

Try this,

Count=0
for i in {$start..$stop}; do
   Counter="$(ls /home/me/*/file_$i.txt 2> /dev/null | wc -l)"
   Count=$((Count+Counter))
done
echo "$Count"

Don't use a loop at all. Instead, list all files and use a command like grep or akw to filter out the files between start and stop. printf won't have the problem Argument list too long as it is a bash built-in.

printf '%s\0' /home/me/*/file_*.txt |
grep -cEzf <(seq "$start" "$stop" | sed 's/.*/_&\.txt$/')

_{Here we assume you have the GNU versions of grep which can handle null bytes. This is important to process paths safely. The null byte is the only character which cannot be part of a path so we can use it to separate paths.
If you don't have the GNU version you can create something that delimits paths by newlines under the assumption that no path contains a newline character. Replace \0 with \n and remove the -z flag.}

If you change …_*.txt to something else you may also have to update the sed command.

1. Don't use eval unless you have no other alternative. It is potentially dangerous, depending on the contents of the $start and $stop variables. It is not a good idea to get into the habit of using it where it isn't necessary.

2. Don't use the output of ls for anything but viewing in a terminal. Attempting to parse ls, even in the simplest fashion, can and will fail in all sorts of ways. Use anything that can produce a NUL-separated list of filenames instead: find -print0 is often a good choice.

3. The bash built-in {x..y} sequence expansion can't evaluate variables, but the standalone seq program can take variables as arguments. It also has a useful -s option to specify the separator.

The following requires a version of grep that supports the -z option for NUL-separated input records (e.g. GNU, FreeBSD, and most other modern versions of grep).

# build a regular expression matching the desired sequence
re="$(seq -s '|' "$start" "$stop")"

# use the RE with `find ... -print0` and `grep -E -z -c`
find /home/me/*/ -maxdepth 1 -type f -name 'file_*.txt' -print0 | 
  grep -Ezc "/file_($re)\.txt$"

For example, if start=3 and stop=7, then $re will be 3|4|5|6|7. The grep command would then expand to:

grep -Ezc "/file_(3|4|5|6|7)\.txt$"

BTW, the -name 'file_*.txt' arguments for the find command aren't required. They can be dropped, and the pipeline will still run without error. All they do is reduce the input data that needs to be processed by grep. A very minor optimisation at best.

e.g.

find /home/me/*/ -maxdepth 1 -type f -print0 | grep -Ezc "/file_($re)\.txt$"

A bash solution:

(
shopt -s nullglob
start=1   # change as needed
stop=500  # change as needed
printf '%s\n' $(printf '/home/me/*/file_%s.txt\n' $(seq "$start" "$stop")) | wc -l
)

Enable nullglob to match only existing files and execute the script in a subshell (…), so we don't have to determine nullglob's previous state and reset its old state when done. The inner printf is used to generate all possible filename patterns and the the outer printf is needed to interpret the * as glob character. The printed output lines are counted with wc -l.

If I understand you correctly, there's no need for a loop:

Suppose a range between 12 and 76:

ls -l | grep -e "file_1[2-9].txt" -e "file_[2-6][0-9].txt" -e "file_7[0-6].txt"

Files 12 to 19

"file_1[2-9].txt"

Files 20 to 69:

"file_[2-6][0-9].txt"

Files 70 to 76

"file_7[0-6].txt"

You can use process substitution and grep -f to search only for files within a range.

E.g. To count all files named file_[0-9]+.txt between range of 10 to 20:

start=10
end=20
ls -f1 | grep -F -f <(printf "file_%s.txt\n" $(seq ${start} ${end}))|wc -l

With zsh:

count=0 range="<$start-$stop>"
/home/me/*/file_$~range.txt(Ne['((!++count))'])

Would give you the count without storing the list of files in memory.

• <1-100> is a zsh glob operator that matches decimal numbers in that range (note that it matches on 2 but also 000002 for instance)
• $~var is like $var except that the content of $var is considered as a pattern as opposed to a literal value.
• (Ne['code']) is a glob qualifier
• N: enables nullglob for that pattern so it doesn't fail if the glob doesn't match any file (which is always the case here).
• e['code'] selects files based on the evaluation of the code. Here the code (((!++count))) increments $count and always returns false so the files are not selected (but $count has been incremented which is all we care about here).