Remova todos os arquivos, exceto todos os 12º

Eu tenho alguns milhares de arquivos no formato filename.12345.end. Eu só quero manter cada 12º arquivo, então file.00012.end, file.00024.end ... file.99996.end e exclua todo o resto.

Os arquivos também podem ter números anteriores no nome do arquivo e normalmente têm o formato: file.00064.name.99999.end

Eu uso o shell Bash e não consigo descobrir como fazer um loop sobre os arquivos e, em seguida, obter o número e verificar se ele está number%%12=0 excluindo o arquivo, se não estiver. Alguém pode me ajudar?

Obrigado Dorina

Aqui está uma solução Perl. Isso deve ser muito mais rápido para milhares de arquivos:

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

Que pode ser ainda mais condensado em:

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

Se você tiver muitos arquivos e não puder usar o simples *, poderá fazer algo como:

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

Quanto à velocidade, aqui está uma comparação dessa abordagem e a shell fornecida em uma das outras respostas:

$ 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

Como você pode ver, a diferença é enorme, como esperado .

Explicação

• O -esimplesmente está dizendo perlpara executar o script fornecido na linha de comando.
• @ARGVé uma variável especial que contém todos os argumentos fornecidos ao script. Como estamos fornecendo *, ele conterá todos os arquivos (e diretórios) no diretório atual.

• O greppesquisará a lista de nomes de arquivos e procurará por qualquer que corresponda a uma sequência de números, um ponto e end(/(\d+)\.end/) .

• Como os números ( \d) estão em um grupo de captura (parênteses), eles são salvos como $1. Portanto grep, verificará se esse número é múltiplo de 12 e, se não for, o nome do arquivo será retornado. Em outras palavras, a matriz @badcontém a lista de arquivos a serem excluídos.

• A lista é então passada para a unlink()qual remove os arquivos (mas não os diretórios).

Como seus nomes de arquivo estão no formato file.00064.name.99999.end, primeiro precisamos aparar tudo, exceto nosso número. Usaremos um forloop para fazer isso.

Também precisamos dizer ao shell do Bash para usar a base 10, porque a aritmética do Bash tratará os números começando com um 0 como base 8, o que irá atrapalhar as coisas para nós.

Como um script, para ser iniciado quando no diretório que contém arquivos, use:

#!/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 você pode usar este comando muito longo e feio para fazer a mesma coisa:

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

Para explicar todas as partes:

• for f in ./* significa para tudo no diretório atual, faça .... Isso define cada arquivo ou diretório encontrado como a variável $ f.
• if [[ -f "$f" ]]verifica se o item encontrado é um arquivo; caso contrário, saltamos para a echo "$f is not...parte, o que significa que não começamos a excluir diretórios acidentalmente.
• file="${f%.*}" define a variável $ file como o nome do arquivo aparando o que vier depois da última . .
• if [[ $((10#${file##*.} % 12)) -eq 0 ]]é onde a aritmética principal entra em ação. Ela ${file##*.}apara tudo antes da última .em nosso nome de arquivo sem extensão. $(( $num % $num2 ))é a sintaxe da aritmética do Bash para usar a operação de módulo, 10#no início diz ao Bash para usar a base 10, para lidar com os 0s iniciais traquinas. $((10#${file##*.} % 12))então nos deixa o restante do número de nossos nomes de arquivos dividido por 12. -ne 0verifica se o restante é "diferente de zero".
• Se o restante não for igual a 0, o arquivo será excluído com o rmcomando, você poderá substituí-lo rmpela echoprimeira vez, para verificar se os arquivos esperados serão excluídos.

Essa solução não é recursiva, o que significa que processará apenas os arquivos no diretório atual e não entrará em nenhum subdiretório.

A ifdeclaração com o echocomando para avisar sobre diretórios não é realmente necessária, pois rm, por si só, reclamará de diretórios e não os excluirá, portanto:

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

Também funcionará corretamente.

Você pode usar a expansão de colchete Bash para gerar nomes contendo cada 12º número. Vamos criar alguns dados de teste

$ 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

Então podemos usar o seguinte

$ 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

No entanto, funciona desesperadamente lento para uma grande quantidade de arquivos - leva tempo e memória para gerar milhares de nomes - por isso é mais um truque que a solução eficiente.

Um pouco longo, mas é o que me veio à mente.

 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

Explicação: Exclua cada 12º arquivo onze vezes.

Com toda humildade, acho que essa solução é muito melhor do que a outra resposta:

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

Uma pequena explicação: Primeiro, geramos uma lista de arquivos com find. Obtemos todos os arquivos cujo nome termina com.end e que estão na profundidade de 1 (ou seja, eles estão diretamente no diretório de trabalho e não em nenhuma subpasta. Você pode deixar isso de fora se não houver subpastas). A lista de saída será classificada em ordem alfabética.

Em seguida, canalizamos essa lista para awkonde usamos a variável especial NRque é o número da linha. Deixamos de fora todos os arquivos 12, imprimindo os arquivos onde NR%12 != 0. O awkcomando pode ser abreviado para awk 'NR%12', porque o resultado do operador módulo é interpretado como um valor booleano e, de {print}qualquer forma, é implicitamente feito.

Portanto, agora temos uma lista de arquivos que precisam ser excluídos, o que podemos fazer com xargs e rm. xargsexecuta o comando fornecido ( rm) com a entrada padrão como argumentos.

Se você tiver muitos arquivos, receberá um erro ao dizer algo como 'lista de argumentos muito longa' (na minha máquina esse limite é de 256 kB e o mínimo exigido pelo POSIX é de 4096 bytes). Isso pode ser evitado pela -n 100bandeira, que divide os argumentos a cada 100 palavras (não linhas, algo a ser observado se os nomes dos arquivos tiverem espaços) e executa um rmcomando separado , cada um com apenas 100 argumentos.

Para usar apenas o bash, minha primeira abordagem seria: 1. mover todos os arquivos que você deseja manter em outro diretório (ou seja, todos aqueles cujo número no nome do arquivo é múltiplo de 12) e depois 2. excluir todos os arquivos restantes no diretório, 3. coloque os múltiplos de 12 arquivos que você guardou onde estavam. Então, algo assim pode funcionar:

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