How do I reverse a for loop?

In bash or ksh, put the file names in an array, and iterate over that array in reverse order.

files=(/var/logs/foo*.log)
for ((i=${#files[@]}-1; i>=0; i--)); do
  bar "${files[$i]}"
done

The code above also works in zsh if the ksh_arrays option is set (it is in ksh emulation mode). There's a simpler method in zsh, which is to reverse the order of the matches through a glob qualifier:

for f in /var/logs/foo*.log(On); do bar $f; done

POSIX doesn't include arrays, so if you want to be portable, your only option to directly store an array of strings is the positional parameters.

set -- /var/logs/foo*.log
i=$#
while [ $i -gt 0 ]; do
  eval "f=\${$i}"
  bar "$f"
  i=$((i-1))
done

Try this, unless you consider line breaks as "funky characters":

ls /var/logs/foo*.log | tac | while read f; do
    bar "$f"
done

If anyone is trying to figure out how to reverse iterate over a space-delimited string list, this works:

reverse() {
  tac <(echo "$@" | tr ' ' '\n') | tr '\n' ' '
}

list="a bb ccc"

for i in `reverse $list`; do
  echo "$i"
done
> ccc
> bb 
> a

In your example you're looping over several files, but I found this question because of its more general title which could also cover looping over an array, or reversing based on any number of orders.

Here's how to do that in Zsh:

If you're looping over the elements in an array, use this syntax (source)

for f in ${(Oa)your_array}; do
    ...
done

O sorts the array lexically in reverse, except when combined other ordering flags in which case it reverses the order. Specifically, here with a, it sorts in reverse array order.

As @Gilles said, instead of building an array and then looping over them in reverse order using the O and a parameter expansion flags, you can can directly affect the order of the glob expansion using the oX and OX glob qualifiers.

for f in /var/log/foo*.log(On)

Will reverse order your globbed files. On is short for ^on, that is: order by name in reverse.

Instead of n for name, the o glob qualifier can also be followed by:

• L file Length
• l number of links
• m, a, c for modification/access/change-status time
• d depth (which can be combined with the others)
• N Not sort.

And ^o or O can be used in place of o to reverse the order and the n qualifier can affect the name order so it be numeric which is generally useful for log files with numeric suffixes.

For instance:

zgrep -hi error /var/log/syslog*(nOn)

To look for errors in chronological order relying on the names of the files sorted numerically, or:

zgrep -hi error /var/log/syslog*(Om)

Relying on the last modification time of those files.

For more examples, see https://github.com/grml/zsh-lovers/blob/master/zsh-lovers.1.txt and http://reasoniamhere.com/2014/01/11/outrageously-useful-tips-to-master-your-z-shell/

find /var/logs/ -name 'foo*.log' -print0 | tail -r | xargs -0 bar

Should operate the way you want (this was tested on Mac OS X and I have a caveat below...).

From the man page for find:

-print0
         This primary always evaluates to true.  It prints the pathname of the current file to standard output, followed by an ASCII NUL character (charac-
         ter code 0).

Basically, you're finding the files that match your string + glob and terminating each with a NUL character. If your filenames contain newlines or other strange characters, find should handle this well.

tail -r

takes the standard input through the pipe and reverses it (note that tail -r prints all of the input to stdout, and not just the last 10 lines, which is the standard default. man tail for more info).

We then pipe that to xargs -0 :

-0      Change xargs to expect NUL (``\0'') characters as separators, instead of spaces and newlines.  This is expected to be used in concert with the
         -print0 function in find(1).

Here, xargs expects to see arguments separated by the NUL character, which you passed from find and reversed with tail.

My caveat: I've read that tail doesn't play well with null-terminated strings. This worked well on Mac OS X, but I can't guarantee that's the case for all *nixes. Tread carefully.

I should also mention that GNU Parallel is often used as an xargs alternative. You may check that out, too.

I may be missing something, so others should chime in.

Since version 5.3, the bash shell has a GLOBSORT special parameter which affects the sorting order of glob expansions.

So here, you could do:

GLOBSORT=-name
shopt -s nullglob
shopt -u failglob
for file in /var/log/foo*.log; do
  ...
done

As an equivalent of zsh's:

for file in /var/log/foo*.log(NOn); do
  ...
done

bash's GLOBSTART=-numeric is however not equivalent to zsh's n qualifier (as in foo*.log(NnOn)) and is of very limited utility as it only works for all-numeric file paths (not even names).

Mac OSX does not support the tac command. The solution by @tcdyl works when you are calling a single command in a for loop. For all other cases, the following is the simplest way to get around it.

This approach does not support having newlines in your filenames. The underlying reason is, that tail -r sorts its input as delimited by newlines.

for i in `ls -1 [filename pattern] | tail -r`; do [commands here]; done

However, there is a way to get around the newline limitation. If you know your filenames do not contain a certain character (say, '='), then you can use tr to replace all newlines to become this character, and then do the sorting. The result would look as follows:

for i in `find [directory] -name '[filename]' -print0 | tr '\n' '=' | tr '\0' '\n'
| tail -r | tr '\n' '\0' | tr '=' '\n' | xargs -0`; do [commands]; done

Note: depending on your version of tr, it might not support '\0' as a character. This can usually be worked around by changing the locale to C (but I don't remember how exactly, since after fixing it once it now works on my computer). If you get an error message, and you cannot find the workaround, then please post it as a comment, so I can help you troubleshoot it.

an easy way is using ls -ras mentioned by @David Schwartz

for f in $(ls -r /var/logs/foo*.log); do
    bar "$f"
done

Based on https://unix.stackexchange.com/a/27385/508263

You can avoid problems with new lines by using \0 like:

printf "abc\na\0cde\nb\0" | tac -s '' | while read -d '' f; do
    bar "$f";
done

give output:

cde
b
abc
a

tac -s '' is split by char \0

read -d '' is read until char \0

To get logs files you can use find /var/logs/ -name 'foo*.log' -print0 like https://unix.stackexchange.com/a/424431/508263 did