Supprimer tous les fichiers sauf tous les 12

J'ai quelques milliers de fichiers au format filename.12345.end. Je veux seulement conserver chaque 12ème fichier, donc file.00012.end, file.00024.end ... file.99996.end et supprimer tout le reste.

Les fichiers peuvent également avoir des numéros plus tôt dans leur nom de fichier et sont normalement de la forme: file.00064.name.99999.end

J'utilise le shell Bash et ne peux pas comprendre comment boucler sur les fichiers, puis sortir le numéro et vérifier s'il number%%12=0 supprime le fichier sinon. Quelqu'un peut-il m'aider?

Merci, Dorina

Voici une solution Perl. Cela devrait être beaucoup plus rapide pour des milliers de fichiers:

perl -e '@bad=grep{/(\d+)\.end/ && $1 % 12 != 0}@ARGV; unlink @bad' *

Qui peut être encore condensé en:

perl -e 'unlink grep{/(\d+)\.end/ && $1 % 12 != 0}@ARGV;' *

Si vous avez trop de fichiers et ne pouvez pas utiliser le simple *, vous pouvez faire quelque chose comme:

perl -e 'opendir($d,"."); unlink grep{/(\d+)\.end/ && $1 % 12 != 0} readdir($dir)'

En ce qui concerne la vitesse, voici une comparaison de cette approche et celle du shell fournie dans l'une des autres réponses:

$ touch file.{01..64}.name.{00001..01000}.end
$ ls | wc
  64000   64000 1472000
$ time for f in ./* ; do file="${f%.*}"; if [[ $((10#${file##*.} % 12)) -ne 0 ]]; then rm "$f"; fi; done

real    2m44.258s
user    0m9.183s
sys     1m7.647s

$ touch file.{01..64}.name.{00001..01000}.end
$ time perl -e 'unlink grep{/(\d+)\.end/ && $1 % 12 != 0}@ARGV;' *

real    0m0.610s
user    0m0.317s
sys     0m0.290s

Comme vous pouvez le voir, la différence est énorme, comme prévu .

Explication

• Le -edit simplement perld'exécuter le script donné sur la ligne de commande.
• @ARGVest une variable spéciale contenant tous les arguments donnés au script. Puisque nous le donnons *, il contiendra tous les fichiers (et répertoires) du répertoire courant.

• Le greprecherche dans la liste des noms de fichiers et recherche ceux qui correspondent à une chaîne de chiffres, un point et end( /(\d+)\.end/).

• Étant donné que les nombres ( \d) sont dans un groupe de capture (parenthèses), ils sont enregistrés sous $1. Le grepvérifie alors si ce nombre est un multiple de 12 et, si ce n'est pas le cas, le nom du fichier sera retourné. En d'autres termes, le tableau @badcontient la liste des fichiers à supprimer.

• La liste est ensuite passée à unlink()laquelle supprime les fichiers (mais pas les répertoires).

Étant donné que vos noms de fichiers sont au format file.00064.name.99999.end, nous devons d'abord supprimer tout sauf notre numéro. Nous allons utiliser une forboucle pour ce faire.

Nous devons également dire au shell Bash d'utiliser la base 10, car l'arithmétique Bash traitera les nombres commençant par un 0 comme base 8, ce qui gâchera les choses pour nous.

En tant que script, pour être lancé dans le répertoire contenant les fichiers, utilisez:

#!/bin/bash

for f in ./*
do
  if [[ -f "$f" ]]; then
    file="${f%.*}"
    if [[ $((10#${file##*.} % 12)) -ne 0 ]]; then
      rm "$f"
    fi
  else
    echo "$f is not a file, skipping."
  fi
done

Ou vous pouvez utiliser cette très longue commande laide pour faire la même chose:

for f in ./* ; do if [[ -f "$f" ]]; then file="${f%.*}"; if [[ $((10#${file##*.} % 12)) -ne 0 ]]; then rm "$f"; fi; else echo "$f is not a file, skipping."; fi; done

Pour expliquer toutes les parties:

• for f in ./* signifie pour tout dans le répertoire courant, faire .... Ceci définit chaque fichier ou répertoire trouvé comme variable $ f.
• if [[ -f "$f" ]]vérifie si l'élément trouvé est un fichier, sinon nous sautons à la echo "$f is not...partie, ce qui signifie que nous ne commençons pas à supprimer les répertoires accidentellement.
• file="${f%.*}" définit la variable $ file comme nom de fichier, supprimant tout ce qui vient après le dernier . .
• if [[ $((10#${file##*.} % 12)) -eq 0 ]]C'est là que l'arithmétique principale entre en jeu. Le ${file##*.}coupe tout avant le dernier .dans notre nom de fichier sans extension. $(( $num % $num2 ))est la syntaxe pour que l'arithmétique Bash utilise l'opération modulo, la commande 10#indique au début à Bash d'utiliser la base 10 pour gérer les 0 en tête embêtants. $((10#${file##*.} % 12))nous laisse ensuite le reste de notre nombre de noms de fichiers divisé par 12.-ne 0 vérifie si le reste n'est "pas égal" à zéro.
• Si le reste n'est pas égal à 0, le fichier est supprimé avec la rmcommande, vous voudrez peut-être le remplacer rmpar echolors de la première exécution, pour vérifier que vous obtenez les fichiers attendus à supprimer.

Cette solution est non récursive, ce qui signifie qu'elle ne traitera que les fichiers du répertoire en cours, elle n'ira dans aucun sous-répertoire.

L' ifinstruction avec la echocommande pour avertir des répertoires n'est pas vraiment nécessaire car rmelle se plaindra des répertoires et ne les supprimera pas, donc:

#!/bin/bash

for f in ./*
do
  file="${f%.*}"
  if [[ $((10#${file##*.} % 12)) -ne 0 ]]; then
    rm "$f"
  fi
done

Ou

for f in ./* ; do file="${f%.*}"; if [[ $((10#${file##*.} % 12)) -ne 0 ]]; then rm "$f"; fi; done

Fonctionnera correctement aussi.

Vous pouvez utiliser l'expansion du support Bash pour générer des noms contenant tous les 12 numéros. Créons des données de test

$ touch file.{0..9}{0..9}{0..9}{0..9}{0..9}.end # create test data
$ mv file.00024.end file.00024.end.name.99999.end # testing this form of filenames

Ensuite, nous pouvons utiliser ce qui suit

$ ls 'file.'{00012..100..12}* # print these with numbers less than 100
file.00012.end                 file.00036.end  file.00060.end  file.00084.end
file.00024.end.name.99999.end  file.00048.end  file.00072.end  file.00096.end
$ rm 'file.'{00012..100000..12}* # do the job

Fonctionne désespérément lentement pour une grande quantité de fichiers - cela prend du temps et de la mémoire pour générer des milliers de noms - c'est donc plus une astuce qu'une solution efficace.

Un peu long, mais c'est ce qui m'est venu à l'esprit.

 for num in $(seq 1 1 11) ; do
     for sequence in $(seq -f %05g $num 12 99999) ; do
         rm file.$sequence.end.99999;
     done
 done

Explication: supprimez tous les 12 fichiers onze fois.

En toute humilité, je pense que cette solution est beaucoup plus agréable que l'autre réponse:

find . -name '*.end' -depth 1 | awk 'NR%12 != 0 {print}' | xargs -n100 rm

Une petite explication: nous générons d'abord une liste de fichiers avec find. Nous obtenons tous les fichiers dont le nom se termine par.end et qui sont à une profondeur de 1 (c'est-à-dire qu'ils sont directement dans le répertoire de travail et non dans aucun sous-dossier. Vous pouvez laisser cela de côté s'il n'y a pas de sous-dossier). La liste de sortie sera triée par ordre alphabétique.

Ensuite, nous dirigeons cette liste vers awk, où nous utilisons la variable spéciale NRqui est le numéro de ligne. Nous omettons tous les 12 fichiers en imprimant les fichiers où NR%12 != 0. La awkcommande peut être raccourcie awk 'NR%12', car le résultat de l'opérateur modulo est interprété comme une valeur booléenne et {print}est implicitement fait de toute façon.

Alors maintenant, nous avons une liste de fichiers qui doivent être supprimés, ce que nous pouvons faire avec xargs et rm. xargsexécute la commande donnée (rm ) avec l'entrée standard comme arguments.

Si vous avez beaucoup de fichiers, vous obtiendrez une erreur disant quelque chose comme «liste d'arguments trop longue» (sur ma machine, cette limite est de 256 Ko et le minimum requis par POSIX est de 4096 octets). Cela peut être évité par l' -n 100indicateur, qui divise les arguments tous les 100 mots (pas les lignes, quelque chose à surveiller si vos noms de fichier ont des espaces) et exécute une rmcommande distincte , chacun avec seulement 100 arguments.

Pour utiliser uniquement bash, ma première approche serait de: 1. déplacer tous les fichiers que vous souhaitez conserver dans un autre répertoire (c'est-à-dire tous ceux dont le nombre dans le nom de fichier est un multiple de 12) puis 2. supprimer tous les fichiers restants dans le répertoire, puis 3. remettez les fichiers multiples de 12 que vous avez conservés là où ils étaient. Donc, quelque chose comme ça pourrait fonctionner:

cd dir_containing_files
mkdir keep_these_files
n=0
while [ "${n}" -lt 99999 ]; do
  padded_n="`echo -n "00000${n}" | tail -c 5`"
  mv "filename${padded_n}.end" keep_these_files/
  n=$[n+12]
done
rm filename*.end
mv keep_these_files/* .
rmdir keep_these_files