Supprimer tous les fichiers X sauf les plus récents dans bash

Existe-t-il un moyen simple, dans un environnement UNIX assez standard avec bash, d'exécuter une commande pour supprimer tous les fichiers X sauf les plus récents d'un répertoire?

Pour donner un peu plus d'exemple concret, imaginez une tâche cron écrivant un fichier (par exemple, un fichier journal ou une sauvegarde tarée) dans un répertoire toutes les heures. Je voudrais un moyen d'avoir un autre travail cron en cours d'exécution qui supprimerait les fichiers les plus anciens de ce répertoire jusqu'à ce qu'il y en ait moins, disons, 5.

Et juste pour être clair, il n'y a qu'un seul fichier présent, il ne devrait jamais être supprimé.

Les problèmes avec les réponses existantes:

• incapacité à gérer les noms de fichiers avec des espaces incorporés ou des retours à la ligne.
  • dans le cas de solutions qui invoquent rmdirectement sur une commande substitution ( rm `...`) sans guillemets , il y a un risque supplémentaire de globbing involontaire.
• l'incapacité de faire la distinction entre les fichiers et les répertoires (par exemple, si les répertoires se trouvaient parmi les 5 éléments du système de fichiers les plus récemment modifiés, vous conserveriez effectivement moins de 5 fichiers et l'application rmaux répertoires échouera).

La réponse de wnoise aborde ces problèmes, mais la solution est spécifique à GNU (et assez complexe).

Voici une solution pragmatique et conforme à POSIX qui ne comporte qu'une seule mise en garde : elle ne peut pas gérer les noms de fichiers avec des sauts de ligne intégrés - mais je ne considère pas cela comme une préoccupation du monde réel pour la plupart des gens.

^{Pour mémoire, voici l'explication des raisons pour lesquelles ce n'est généralement pas une bonne idée d'analyser la lssortie: http://mywiki.wooledge.org/ParsingLs}

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

Ce qui précède est inefficace , car xargsdoit être invoqué rmune fois pour chaque nom de fichier.
Votre plateforme xargspeut vous permettre de résoudre ce problème:

Si vous avez GNU xargs , utilisez -d '\n', ce qui fait de xargschaque ligne d'entrée un argument distinct, tout en transmettant autant d'arguments que possible sur une ligne de commande à la fois :

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

^{-r( --no-run-if-empty) garantit que ce rmn'est pas appelé s'il n'y a pas d'entrée.}

Si vous avez BSD xargs (y compris sur macOS ), vous pouvez utiliser -0pour gérer les NULentrées séparées, après avoir d'abord traduit les sauts de ligne en NUL( 0x0) chars., Qui transmet également (généralement) tous les noms de fichiers à la fois (fonctionnera également avec GNU xargs):

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

Explication:

• ls -tpimprime les noms des éléments du système de fichiers triés selon leur date de modification, par ordre décroissant (les éléments les plus récemment modifiés en premier) ( -t), avec les répertoires imprimés avec une fin /pour les marquer comme tels ( -p).
• grep -v '/$'puis élimine les répertoires de la liste résultante, en omettant ( -v) les lignes qui ont un fin /( /$).
  • Attention : comme un lien symbolique qui pointe vers un répertoire n'est techniquement pas lui-même un répertoire, de tels liens symboliques ne seront pas exclus.
• tail -n +6ignore les 5 premières entrées de la liste, renvoyant en fait tous les fichiers modifiés sauf les 5 derniers, le cas échéant.
  Notez que pour exclure des Nfichiers, N+1doit être passé à tail -n +.
• xargs -I {} rm -- {}(et ses variantes) invoque alors rmsur tous ces fichiers; s'il n'y a aucune correspondance, xargsne fera rien.
  • xargs -I {} rm -- {}définit un espace réservé {}qui représente chaque ligne d'entrée dans son ensemble , il rmest donc appelé une fois pour chaque ligne d'entrée, mais avec les noms de fichiers avec des espaces incorporés gérés correctement.
  • --dans tous les cas, garantit que les noms de fichiers commençant par -ne sont pas confondus avec les options de rm.

Une variante du problème d'origine, au cas où les fichiers correspondants doivent être traités individuellement ou collectés dans un tableau 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

Supprimez tous les fichiers les plus récents d'un répertoire, sauf 5 (ou n'importe quel nombre).

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

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

Cette version prend en charge les noms avec des espaces:

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

Variante plus simple de la réponse de thelsdj:

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

ls -tr affiche tous les fichiers, le plus ancien en premier (-t le plus récent en premier, -r inverse).

head -n -5 affiche toutes les lignes sauf les 5 dernières (c'est-à-dire les 5 fichiers les plus récents).

xargs rm appelle rm pour chaque fichier sélectionné.

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

Requiert GNU find pour -printf, et GNU sort pour -z, et GNU awk pour "\ 0", et GNU xargs pour -0, mais gère les fichiers avec des retours à la ligne ou des espaces intégrés.

Toutes ces réponses échouent lorsqu'il y a des répertoires dans le répertoire courant. Voici quelque chose qui fonctionne:

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

Ce:

1. fonctionne quand il y a des répertoires dans le répertoire courant

2. essaie de supprimer chaque fichier même si le précédent n'a pas pu être supprimé (en raison des autorisations, etc.)

3. échoue en toute sécurité lorsque le nombre de fichiers dans le répertoire actuel est excessif et xargsvous foutrait normalement (le -x)

4. ne prend pas en charge les espaces dans les noms de fichiers (peut-être que vous utilisez le mauvais système d'exploitation?)

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

Répertoriez les noms de fichiers par heure de modification, en citant chaque nom de fichier. Excluez les 3 premiers (3 les plus récents). Retirez le reste.

EDIT après un commentaire utile de mklement0 (merci!): Argument corrigé -n + 3, et notez que cela ne fonctionnera pas comme prévu si les noms de fichiers contiennent des nouvelles lignes et / ou le répertoire contient des sous-répertoires.

Ignorer les nouvelles lignes, c'est ignorer la sécurité et un bon codage. wnoise avait la seule bonne réponse. Voici une variante de son qui met les noms de fichiers dans un tableau $ x

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

Si les noms de fichiers n'ont pas d'espaces, cela fonctionnera:

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

Si les noms de fichiers ont des espaces, quelque chose comme

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

Logique de base:

• obtenir une liste des fichiers par ordre chronologique, une colonne
• obtenir tout sauf les 5 premiers (n = 5 pour cet exemple)
• première version: envoyez-les à rm
• deuxième version: générer un script qui les supprimera correctement

Avec zsh

En supposant que vous ne vous souciez pas des répertoires actuels et que vous n'aurez pas plus de 999 fichiers (choisissez un plus grand nombre si vous le souhaitez, ou créez une boucle while).

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

Dans *(.om[6,999]), les .fichiers moyens, l' oordre de tri des moyens vers le haut, les mmoyens par date de modification (mis apour le temps d'accès ou cpour le changement d'inode), le [6,999]choisit une plage de fichiers, donc ne rm le 5 en premier.

Je me rends compte que c'est un vieux fil, mais peut-être que quelqu'un en profitera. Cette commande trouvera les fichiers dans le répertoire courant:

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

C'est un peu plus robuste que certaines des réponses précédentes car cela permet de limiter votre domaine de recherche aux fichiers correspondant aux expressions. Tout d'abord, trouvez les fichiers correspondant aux conditions souhaitées. Imprimez ces fichiers avec les horodatages à côté d'eux.

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

Ensuite, triez-les par horodatage:

sort -r -z -n

Ensuite, supprimez les 4 fichiers les plus récents de la liste:

tail -n+5

Prenez la 2ème colonne (le nom du fichier, pas l'horodatage):

awk '{ print $2; }'

Et puis enveloppez tout cela dans une déclaration for:

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

Cela peut être une commande plus verbeuse, mais j'ai eu beaucoup plus de chance de pouvoir cibler des fichiers conditionnels et d'exécuter des commandes plus complexes contre eux.

trouvé cmd intéressant dans Sed-Onliners - Supprimez les 3 dernières lignes - trouvez-le parfait pour une autre façon d'écorcher le chat (d'accord pas) mais idée:

 #!/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

Supprime tous les fichiers sauf les 10 derniers (les plus récents)

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

Si moins de 10 fichiers aucun fichier n'est supprimé et vous aurez: tête d'erreur: nombre de lignes illégal - 0

Pour compter les fichiers avec bash

J'avais besoin d'une solution élégante pour le busybox (routeur), tous les xargs ou solutions de baie étaient inutiles pour moi - aucune commande de ce type n'est disponible là-bas. find and mtime n'est pas la bonne réponse car nous parlons de 10 éléments et pas nécessairement de 10 jours. La réponse d'Espo était la plus courte et la plus propre et probablement la plus universelle.

Les erreurs avec les espaces et lorsqu'aucun fichier ne doit être supprimé sont simplement résolus de la manière standard:

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

Version un peu plus éducative: nous pouvons tout faire si nous utilisons awk différemment. Normalement, j'utilise cette méthode pour passer (renvoyer) des variables de awk au sh. Comme nous lisons tout le temps ce qui ne peut être fait, je prie de différer: voici la méthode.

Exemple pour les fichiers .tar sans problème concernant les espaces dans le nom de fichier. Pour tester, remplacez "rm" par "ls".

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

Explication:

ls -td *.tarrépertorie tous les fichiers .tar triés par heure. Pour appliquer à tous les fichiers du dossier courant, supprimez la partie "d * .tar"

awk 'NR>7... saute les 7 premières lignes

print "rm \"" $0 "\"" construit une ligne: rm "nom de fichier"

eval l'exécute

Puisque nous utilisons rm, je n'utiliserais pas la commande ci-dessus dans un script! Une utilisation plus sage est:

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

Dans le cas de l'utilisation de la ls -tcommande ne fera aucun mal sur des exemples aussi stupides que: touch 'foo " bar'ettouch 'hello * world' . Non pas que nous ayons jamais créé des fichiers avec de tels noms dans la vraie vie!

Sidenote. Si nous voulions passer une variable au sh de cette façon, nous modifierions simplement l'impression (forme simple, aucun espace toléré):

print "VarName="$1

pour définir la variable VarNamesur la valeur de $1. Plusieurs variables peuvent être créées en une seule fois. Cela VarNamedevient une variable sh normale et peut être normalement utilisée dans un script ou un shell par la suite. Donc, pour créer des variables avec awk et les rendre au 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

J'en ai fait un script shell bash. Utilisation: keep NUM DIRoù NUM est le nombre de fichiers à conserver et DIR est le répertoire à nettoyer.

#!/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