Borrar todos menos los archivos X más recientes en bash

Question

¿Existe una manera simple, en un entorno UNIX bastante estándar con bash, de ejecutar un comando para eliminar todos los archivos X menos los más recientes de un directorio?

Para dar un ejemplo más concreto, imagínese que un trabajo cron escribe un archivo (por ejemplo, un archivo de registro o una copia de seguridad tar-ed) en un directorio cada hora. Me gustaría una forma de ejecutar otra tarea cron que elimine los archivos más antiguos en ese directorio hasta que haya menos de, por ejemplo, 5.

Y para que quede claro, solo hay un archivo presente, nunca debería ser eliminado

Answer 1

Los problemas con las respuestas existentes:

• incapacidad para manejar nombres de archivo con espacios o saltos de línea embebidos.
  • en el caso de las soluciones que invocan rm directamente en una sustitución de orden sin comillas (rm `...`), hay un riesgo añadido de englobamiento no deseado.
• incapacidad para distinguir entre los archivos y directorios (es decir, si ocurrieron directorios para estar entre los 5 elementos del sistema de archivos más recientemente modificados, que le retiene con eficacia menos que 5 archivos, y aplicando rm a directorios fallar).

wnoise's answer direcciones de estas cuestiones, pero la solución es GNU específico de (y bastante complejo).

he aquí una solución pragmática, compatible con POSIX que viene con solamente una advertencia: no puede manejar nombres de archivo con incrustados nuevas líneas - pero yo no considero que una preocupación en el mundo real para la mayoría de la gente.

^{Para el registro, aquí está la explicación de por qué no es generalmente una buena idea para analizar ls de salida: http://mywiki.wooledge.org/ParsingLs}

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

Lo anterior es ineficiente, porque xargs tiene que invocar rm una vez para cada nombre de archivo.
de xargs puede permitir que usted para solucionar este problema su plataforma:

Si tiene GNUxargs, utilice -d '\n', lo que hace xargs consideran cada línea de entrada un argumento separado, sin embargo, pasa a tantos argumentos como quepan en una línea de comandos a la vez :

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

^{-r (--no-run-if-empty) asegura que rm no se invoca si no hay entrada.}

Si tiene BSDxargs (incluyendo el OS X), se puede utilizar para manejar -0NUL de entrada Separado, después de traducir primero a las nuevas líneas NUL (0x0) caracteres., Que también pasa (normalmente) todos los ficheros a la vez (también trabajará con GNU xargs):

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

Explicación:

• ls -tp grabados los nombres de los elementos del sistema de archivos ordenados por cuánto tiempo hace que se modificaron, en orden descendente (modificado más recientemente artículos primero) (-t), con directorios impresos con un trailing / para marcarlos como tal (-p).
• grep -v '/$' elimina los directorios de la lista resultante, omitiendo (-v) líneas que tienen un / posterior (/$).
  • Advertencia: Desde un enlace simbólico que apunta a un directorio técnicamente no es en sí un directorio, se no ser excluidos dichos enlaces simbólicos.
• tail -n +6 se salta los primeros 5 entradas en el perfil, en efecto, devolver todos los pero los 5 archivos más recientemente modificados, en su caso.
  Tenga en cuenta que para excluir los archivos N, N+1 debe pasarse a xargs -n +.
• xargs -I {} rm -- {} (y sus variaciones) luego invoca en rm en todos estos archivos; si no hay ninguna coincidencia, xargs no hará nada.
  • xargs -I {} rm -- {} define marcador de posición {} que representa cada línea de entrada como un todo, de modo rm es entonces invocado una vez por cada línea de entrada, pero con nombres de archivo con espacios incrustados se maneja correctamente.
  • -- en todos los casos se asegura de que los nombres de archivo que le suceden a comenzar con - no se confundan con las opciones por rm.

---

A variación en el problema original, en caso de que los archivos coincidentes necesitan ser procesados ​​individualmente o recogió en una matriz de cáscara:

# 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 

Answer 2

Quite todos menos 5 (o el número) de los archivos más recientes en un directorio.

rm `ls -t | awk 'NR>5'` 

Answer 3

(ls -t|head -n 5;ls)|sort|uniq -u|xargs rm 

Esta versión es compatible con nombres con espacios:

(ls -t|head -n 5;ls)|sort|uniq -u|sed -e 's,.*,"&",g'|xargs rm 

Answer 4

Si los nombres de archivo no tienen espacios, esto va a funcionar:

ls -C1 -t| awk 'NR>5'|xargs rm 

Si los nombres de archivo tienen espacios , algo así como

ls -C1 -t | awk 'NR>5' | sed -e "s/^/rm '/" -e "s/$/'/" | sh 

lógica básica:

• Obtener una lista de los archivos en el orden del tiempo, una columna
• obtener todos menos los primeros 5 (n = 5 para este ejemplo)
• primera versión: enviar los a rm
• segundos versión: gen una secuencia de comandos que les quite adecuadamente

Answer 5

Todas estas respuestas fallar cuando hay directorios en el directorio actual. Aquí hay algo que funciona:

find . -maxdepth 1 -type f | xargs -x ls -t | awk 'NR>5' | xargs -L1 rm 

Este:

1. funciona cuando hay directorios en el directorio actual

2. trata de eliminar todos los archivos, incluso si el anterior no puede ser eliminado (debido a permisos, etc.)

3. falla cuando el número de archivos en el directorio actual es excesivo y xargs normalmente se atornille sobre (el -x)

4. no está pensado para espacios en los nombres de archivo (tal vez usted está utilizando el sistema operativo mal?)

Answer 6

find . -maxdepth 1 -type f -printf '%T@ %p\0' | sort -r -z -n | awk 'BEGIN { RS="\0"; ORS="\0"; FS="" } NR > 5 { sub("^[0-9]*(.[0-9]*)? ", ""); print }' | xargs -0 rm -f 

Requiere GNU encontrar para -printf , y GNU ordena para -z, y GNU awk para "\ 0", y GNU xargs para -0, pero maneja archivos con nuevas líneas o espacios incrustados.

Answer 7

Ignorar líneas nuevas es ignorar la seguridad y una buena codificación.wnoise tuvo la única buena respuesta. Aquí es una variación de la que pone los nombres de archivo en una matriz $ x

while IFS= read -rd ''; do 
    x+=("${REPLY#* }"); 
done < <(find . -maxdepth 1 -printf '%T@ %p\0' | sort -r -z -n) 

Answer 8

Correr en Debian (asuma su igual en otras distribuciones consigo: rm: no se puede eliminar el directorio `..'

que es bastante molesto ...

De todos modos, pellizqué lo anterior y también agregué grep al comando. En mi caso, tengo 6 archivos de respaldo en un directorio, por ejemplo, archivo1.tar archivo2.tar archivo3.tar etc. y quiero eliminar solo el archivo más antiguo (elimine el primer archivo en mi caso)

La secuencia de comandos que ejecuté para eliminar el archivo más antiguo fue:

ls -C1 -t | archivo grep | awk 'NR> 5' | xargs rm

Esto (como anteriormente) borra el primero de mis archivos, p. file1.tar esto también deja estar con fichero2 archivo3 file4 File5 y file6

Answer 9

Con zsh

Suponiendo que no se preocupan por los directorios actuales y que no tendrá más de 999 archivos (elegir un número más grande si usted quiere , o crea un ciclo while).

[ 6 -le `ls *(.)|wc -l` ] && rm *(.om[6,999]) 

En *(.om[6,999]), la . significa archivos, el o significa orden de clasificación hasta, las m medios por fecha de modificación (ponen a por el tiempo de acceso o c para el cambio inodo), el [6,999] elige una serie de archivos, así que no rm el 5 primero.

Answer 10

más simple variante de la respuesta de thelsdj:

ls -tr | head -n -5 | xargs rm 

ls -tr muestra todos los archivos, el más antiguo primero (-t nuevos primero, -R inversa).

head -n muestra todas menos las 5 últimas líneas (es decir, los 5 archivos más nuevos).

xargs rm llama a rm para cada archivo seleccionado.

Answer 11

leaveCount=5 
fileCount=$(ls -1 *.log | wc -l) 
tailCount=$((fileCount - leaveCount)) 

# avoid negative tail argument 
[[ $tailCount < 0 ]] && tailCount=0 

ls -t *.log | tail -$tailCount | xargs rm -f 

Answer 12

ls -tQ | tail -n+4 | xargs rm 

lista los archivos por fecha de modificación, citando a cada nombre de archivo. Excluya los primeros 3 (3 más recientes). Eliminar el resto

EDITAR después del comentario útil de mklement0 (¡gracias!): Argumento corregido -n + 3, y tenga en cuenta que esto no funcionará como se espera si los nombres de archivo contienen líneas nuevas y/o el directorio contiene subdirectorios.

Answer 13

Hice esto en una secuencia de comandos bash shell. Uso: keep NUM DIR donde NUM es la cantidad de archivos que se deben conservar y DIR es el directorio que se debe eliminar.

#!/bin/bash 
# Keep last N files by date. 
# Usage: keep NUMBER DIRECTORY 
echo "" 
if [ $# -lt 2 ]; then 
    echo "Usage: $0 NUMFILES DIR" 
    echo "Keep last N newest files." 
    exit 1 
fi 
if [ ! -e $2 ]; then 
    echo "ERROR: directory '$1' does not exist" 
    exit 1 
fi 
if [ ! -d $2 ]; then 
    echo "ERROR: '$1' is not a directory" 
    exit 1 
fi 
pushd $2 > /dev/null 
ls -tp | grep -v '/' | tail -n +"$1" | xargs -I {} rm -- {} 
popd > /dev/null 
echo "Done. Kept $1 most recent files in $2." 
ls $2|wc -l 

Answer 14

encontró cmd interesantes de SED-onliners - Eliminar 3 últimas líneas - fnd que es perfecto para otra forma a la piel del gato (bueno no), pero la idea:

#!/bin/bash 
# sed cmd chng #2 to value file wish to retain 

cd /opt/depot 

ls -1 MyMintFiles*.zip > BigList 
sed -n -e :a -e '1,2!{P;N;D;};N;ba' BigList > DeList 

for i in `cat DeList` 
do 
echo "Deleted $i" 
rm -f $i 
#echo "File(s) gonzo " 
#read junk 
done 
exit 0 

Answer 15

me di cuenta que es un viejo hilo, pero tal vez alguien se beneficiará de esto. Este comando encontrar archivos en el directorio actual:

for F in $(find . -maxdepth 1 -type f -name "*_srv_logs_*.tar.gz" -printf '%T@ %p\n' | sort -r -z -n | tail -n+5 | awk '{ print $2; }'); do rm $F; done 

esto es un poco más robusto que algunas de las respuestas anteriores ya que permite limitar su dominio de búsqueda de archivos que coinciden con las expresiones. Primero, encuentre los archivos que coincidan con las condiciones que desee. Imprima esos archivos con las marcas de tiempo al lado de ellos.

find . -maxdepth 1 -type f -name "*_srv_logs_*.tar.gz" -printf '%T@ %p\n' 

A continuación, clasificarlos por las marcas de tiempo:

sort -r -z -n 

A continuación, desprender los 4 archivos más recientes de la lista:

tail -n+5 

Coge la segunda columna (el nombre del archivo, no la marca de tiempo):

awk '{ print $2; }' 

An d luego envolver toda esa cosa en una sentencia for:

for F in $(); do rm $F; done 

Esto puede ser un comando más detallado, pero tenía mucha mejor suerte de ser capaz de dirigirse a los archivos y ejecutar comandos condicionales más complejos contra ellos.

Answer 16

elimina todas las 10 últimas (mas recientes) Archivos

ls -t1 | head -n $(echo $(ls -1 | wc -l) - 10 | bc) | xargs rm 

Si es menos de 10 archivos ningún archivo se elimina y se tendrán: cabeza de error: número de líneas ilegales - 0

To count files with bash