Eliminar todos los archivos X más recientes en bash

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

Para dar un poco más de un ejemplo concreto, imagine un trabajo cron escribiendo un archivo (por ejemplo, un archivo de registro o una copia de seguridad protegida) en un directorio cada hora. Me gustaría una forma de ejecutar otro trabajo cron que eliminaría los archivos más antiguos de ese directorio hasta que haya menos de, por ejemplo, 5.

Y para ser claros, solo hay un archivo presente, nunca se debe eliminar.

Los problemas con las respuestas existentes:

• incapacidad para manejar nombres de archivos con espacios incrustados o nuevas líneas.
  • en el caso de soluciones que invocan rmdirectamente en una sustitución de comando sin comillas ( rm `...`), existe un riesgo adicional de bloqueo involuntario.
• incapacidad para distinguir entre archivos y directorios (es decir, si los directorios se encontraran entre los 5 elementos del sistema de archivos modificados más recientemente, efectivamente retendría menos de 5 archivos, y la aplicación rma los directorios fallará).

La respuesta de wnoise aborda estos problemas, pero la solución es específica de GNU (y bastante compleja).

Aquí hay una solución pragmática y compatible con POSIX que viene con una sola advertencia : no puede manejar nombres de archivo con líneas nuevas incrustadas , pero no considero que sea una preocupación del mundo real para la mayoría de las personas.

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

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

Lo anterior es ineficiente , porque xargstiene que invocar rmuna vez para cada nombre de archivo.
Su plataforma xargspuede permitirle resolver este problema:

Si tiene GNU xargs , use -d '\n', lo que hace que xargscada línea de entrada sea un argumento separado, pero pasa tantos argumentos como quepan en una línea de comando a la vez :

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

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

Si tiene BSD xargs (incluido en macOS ), puede usarlo -0para manejar la NULentrada separada, después de traducir primero las nuevas líneas a NUL( 0x0) caracteres, que también pasa (típicamente) todos los nombres de archivo a la vez (también funcionará con GNU xargs):

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

Explicación:

• ls -tpimprime los nombres de los elementos del sistema de archivos ordenados por la última vez que se modificaron, en orden descendente (los elementos modificados más recientemente primero) ( -t), con directorios impresos con un final /para marcarlos como tales ( -p).
• grep -v '/$'luego elimina los directorios de la lista resultante, omitiendo las -vlíneas ( ) que tienen un final /( /$).
  • Advertencia : dado que un enlace simbólico que apunta a un directorio técnicamente no es en sí un directorio, dichos enlaces simbólicos no se excluirán.
• tail -n +6se salta las primeras 5 entradas en el perfil, en efecto, volviendo todo , pero los 5 archivos más recientemente modificados, en su caso.
  Tenga en cuenta que para excluir Narchivos, N+1debe pasarse a tail -n +.
• xargs -I {} rm -- {}(y sus variaciones) luego se invoca rmen todos estos archivos; Si no hay coincidencias, xargsno hará nada.
  • xargs -I {} rm -- {}define el marcador de posición {}que representa cada línea de entrada como un todo , por lo que rmse invoca una vez para cada línea de entrada, pero con nombres de archivo con espacios incrustados manejados correctamente.
  • --en todos los casos asegura que cualquier nombre de archivo con el que empiece -no se confunda con las opciones de rm.

Una variación del problema original, en caso de que los archivos coincidentes deban procesarse individualmente o recopilarse en una matriz de shell :

# 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

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

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

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

Esta versión admite nombres con espacios:

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

Variante más simple de la respuesta de thelsdj:

ls -tr | head -n -5 | xargs --no-run-if-empty rm 

ls -tr muestra todos los archivos, el más antiguo primero (-t el más nuevo primero, -r al revés).

head -n -5 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.

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 find para -printf, y GNU sort para -z, y GNU awk para "\ 0", y GNU xargs para -0, pero maneja archivos con líneas o espacios incrustados.

Todas estas respuestas fallan 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

Esta:

1. funciona cuando hay directorios en el directorio actual

2. intenta eliminar cada archivo incluso si no se pudo eliminar el anterior (debido a permisos, etc.)

3. falla a salvo cuando el número de archivos en el directorio actual es excesivo y xargsnormalmente lo atornillaría (el -x)

4. no atiende espacios en los nombres de archivo (¿tal vez está utilizando el sistema operativo incorrecto?)

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

Enumere los nombres de archivo por hora de modificación, citando cada nombre de archivo. Excluir los primeros 3 (3 más recientes). Eliminar el resto.

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

Ignorar las nuevas líneas es ignorar la seguridad y la buena codificación. wnoise tuvo la única buena respuesta. Aquí hay una variación de él 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 )

Si los nombres de archivo no tienen espacios, esto 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 orden de tiempo, una columna
• obtener todos menos los primeros 5 (n = 5 para este ejemplo)
• primera versión: envíelas a rm
• segunda versión: gen un script que los eliminará correctamente

Con zsh

Asumiendo que no le interesan los directorios actuales y que no tendrá más de 999 archivos (elija un número mayor si lo desea, o cree un ciclo while).

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

En *(.om[6,999])los .archivos de medios, el oorden de clasificación de los medios, los mmedios por fecha de modificación (puesto apara el tiempo de acceso o cpara el cambio de inodo), [6,999]elige un rango de archivo, por lo que no rm los 5 primero.

Me doy cuenta de que este es un hilo viejo, pero tal vez alguien se beneficie 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 a archivos que coincidan con expresiones. Primero, encuentre archivos que coincidan con las condiciones que desee. Imprima esos archivos con las marcas de tiempo junto a ellos.

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

A continuación, ordénelos por las marcas de tiempo:

sort -r -z -n

Luego, elimine los 4 archivos más recientes de la lista:

tail -n+5

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

awk '{ print $2; }'

Y luego envuelva todo en una declaración for:

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

Este puede ser un comando más detallado, pero tuve mucha mejor suerte al poder dirigir archivos condicionales y ejecutar comandos más complejos contra ellos.

encontró cmd interesante en Sed-Onliners - Elimina las últimas 3 líneas - encuentra perfecto para otra forma de pelar al gato (está bien, no) pero 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

Elimina todos menos los 10 últimos archivos (la mayoría recientes)

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

Si hay menos de 10 archivos, no se eliminará ningún archivo y tendrá: cabeza de error: recuento de líneas ilegales - 0

Para contar archivos con bash

Necesitaba una solución elegante para el busybox (enrutador), todas las soluciones de xargs o array me resultaron inútiles; no hay tal comando disponible allí. find and mtime no es la respuesta adecuada, ya que estamos hablando de 10 elementos y no necesariamente de 10 días. La respuesta de Espo fue la más corta, más limpia y probablemente la más irreversible.

Los errores con espacios y cuando no se van a eliminar archivos se resuelven simplemente de la manera estándar:

rm "$(ls -td *.tar | awk 'NR>7')" 2>&-

Versión un poco más educativa: podemos hacerlo todo si usamos awk de manera diferente. Normalmente, uso este método para pasar (devolver) variables del awk al sh. Como leemos todo el tiempo que no se puede hacer, ruego diferir: aquí está el método.

Ejemplo para archivos .tar sin problemas con respecto a los espacios en el nombre del archivo. Para probar, reemplace "rm" con el "ls".

eval $(ls -td *.tar | awk 'NR>7 { print "rm \"" $0 "\""}')

Explicación:

ls -td *.tarenumera todos los archivos .tar ordenados por hora. Para aplicar a todos los archivos en la carpeta actual, elimine la parte "d * .tar"

awk 'NR>7... salta las primeras 7 líneas

print "rm \"" $0 "\"" construye una línea: rm "nombre de archivo"

eval lo ejecuta

Como estamos usando rm, ¡no usaría el comando anterior en un script! El uso más sabio es:

(cd /FolderToDeleteWithin && eval $(ls -td *.tar | awk 'NR>7 { print "rm \"" $0 "\""}'))

En el caso de usar el ls -tcomando no hará ningún daño en ejemplos tan tontos como: touch 'foo " bar'ytouch 'hello * world' . ¡No es que alguna vez creamos archivos con tales nombres en la vida real!

Nota al margen. Si quisiéramos pasar una variable al sh de esta manera, simplemente modificaríamos la impresión (forma simple, sin espacios tolerados):

print "VarName="$1

para establecer la variable VarNameal valor de $1. Se pueden crear múltiples variables de una vez. Esto se VarNameconvierte en una variable sh normal y se puede usar normalmente en un script o shell después. Entonces, para crear variables con awk y devolverlas al shell:

eval $(ls -td *.tar | awk 'NR>7 { print "VarName=\""$1"\""  }'); echo "$VarName"

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

Hice esto en un script de shell bash. Uso: keep NUM DIRdonde NUM es el número de archivos que se deben mantener y DIR es el directorio que se desea 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