Delete all but the most recent X files in bash

by

The problems with the existing answers:

  • inability to handle filenames with embedded spaces or newlines.
    • in the case of solutions that invoke rm directly on an unquoted command substitution (rm `...`), there’s an added risk of unintended globbing.
  • inability to distinguish between files and directories (i.e., if directories happened to be among the 5 most recently modified filesystem items, you’d effectively retain fewer than 5 files, and applying rm to directories will fail).

wnoise’s answer addresses these issues, but the solution is GNU-specific (and quite complex).

Here’s a pragmatic, POSIX-compliant solution that comes with only one caveat: it cannot handle filenames with embedded newlines – but I don’t consider that a real-world concern for most people.

For the record, here’s the explanation for why it’s generally not a good idea to parse ls output: http://mywiki.wooledge.org/ParsingLs

ls -tp | grep -v '/$' | tail -n +6 | xargs -I {} rm -- {}

Note: This command operates in the current directory; to target a directory explicitly, use a subshell ((...)) with cd:
(cd /path/to && ls -tp | grep -v '/$' | tail -n +6 | xargs -I {} rm -- {})
The same applies analogously to the commands below.

The above is inefficient, because xargs has to invoke rm separately for each filename.
However, your platform’s specific xargs implementation may allow you to solve this problem:

A solution that works with GNU xargs is to use -d '\n', which makes xargs consider each input line a separate argument, yet passes as many arguments as will fit on a command line at once:

ls -tp | grep -v '/$' | tail -n +6 | xargs -d '\n' -r rm --

Note: Option -r (--no-run-if-empty) ensures that rm is not invoked if there’s no input.

A solution that works with both GNU xargs and BSD xargs (including on macOS) – though technically still not POSIX-compliant – is to use -0 to handle NUL-separated input, after first translating newlines to NUL (0x0) chars., which also passes (typically) all filenames at once:

ls -tp | grep -v '/$' | tail -n +6 | tr '\n' '\0' | xargs -0 rm --

Explanation:

  • ls -tp prints the names of filesystem items sorted by how recently they were modified , in descending order (most recently modified items first) (-t), with directories printed with a trailing / to mark them as such (-p).

    • Note: It is the fact that ls -tp always outputs file / directory names only, not full paths, that necessitates the subshell approach mentioned above for targeting a directory other than the current one ((cd /path/to && ls -tp ...)).

  • grep -v '/$' then weeds out directories from the resulting listing, by omitting (-v) lines that have a trailing / (/$).

    • Caveat: Since a symlink that points to a directory is technically not itself a directory, such symlinks will not be excluded.

  • tail -n +6 skips the first 5 entries in the listing, in effect returning all but the 5 most recently modified files, if any.
    Note that in order to exclude N files, N+1 must be passed to tail -n +.

  • xargs -I {} rm -- {} (and its variations) then invokes on rm on all these files; if there are no matches at all, xargs won’t do anything.

    • xargs -I {} rm -- {} defines placeholder {} that represents each input line as a whole, so rm is then invoked once for each input line, but with filenames with embedded spaces handled correctly.
    • -- in all cases ensures that any filenames that happen to start with - aren’t mistaken for options by rm.

A variation on the original problem, in case the matching files need to be processed individually or collected in a shell array:

# One by one, in a shell loop (POSIX-compliant):
ls -tp | grep -v '/$' | tail -n +6 | while IFS= read -r f; do echo "$f"; done

# One by one, but using a Bash process substitution (<(...), 
# so that the variables inside the `while` loop remain in scope:
while IFS= read -r f; do echo "$f"; done < <(ls -tp | grep -v '/$' | tail -n +6)

# Collecting the matches in a Bash *array*:
IFS=$'\n' read -d '' -ra files  < <(ls -tp | grep -v '/$' | tail -n +6)
printf '%s\n' "${files[@]}" # print array elements

More Related Contents:

  1. Copy folder recursively, excluding some folders
  2. Extract version number from a string
  3. Difference between sh and Bash
  4. Pass commands as input to another command (su, ssh, sh, etc)
  5. Why do you need ./ (dot-slash) before executable or script name to run it in bash?
  6. What is the cleanest way to ssh and run multiple commands in Bash?
  7. How can I declare and use Boolean variables in a shell script?
  8. Test for non-zero length string in Bash: [ -n “$var” ] or [ “$var” ]
  9. How to iterate over an array using indirect reference?
  10. How do I check if a directory exists in a Bash shell script?
  11. Wait for a process to finish
  12. How to get the primary IP address of the local machine on Linux and OS X? [closed]
  13. How to suppress Terminated message after killing in bash?
  14. Variable interpolation in the shell
  15. How to do a logical OR operation for integer comparison in shell scripting?
  16. How to go to each directory and execute a command?
  17. Running a Bash script over ssh
  18. What does ” 2>&1 ” mean?
  19. How to resolve symbolic links in a shell script
  20. How do I check if a directory exists or not in a Bash shell script?
  21. Copy all files with a certain extension from all subdirectories
  22. Print a file’s last modified date in Bash
  23. Validate date format in a shell script
  24. bash script order of execution
  25. How can I convert tabs to spaces in every file of a directory?
  26. Multiplication on command line terminal
  27. Why doesn’t **sort** sort the same on every machine?
  28. How to properly nest Bash backticks
  29. How to include nohup inside a bash script?
  30. Subtract two variables in Bash

Leave a Comment