Bash - mover/renomear arquivos classificados numéricos do número de entrada em diante [duplicado]

Isso faz o que você quer. Uma coisa: só funciona em BASH, eu acho. MAXDIGITSé opcional, eu coloco lá caso você precise trabalhar com três dígitos ou mais. Se você não usá-lo, exclua as linhas correspondentes.

    #!/bin/bash

    BOTTOM=$1
    SHIFT=$2
    MAXDIGITS=0$3
    for filename in $(ls -r *.{txt,log}); do
        PREFIX=${filename%%_*}
        NEWPREFIX=$(expr $PREFIX + $SHIFT)
        if [ $PREFIX -ge $BOTTOM ]; then
            NEWPREFIX=$(printf %${MAXDIGITS}d $NEWPREFIX)
            mv $filename ${NEWPREFIX}_${filename#*_}
        fi
    done

Para usá-lo:

    ./myscript <BOTTOM> <SHIFT> <MAXDIGITS>
    ### Example:
    ./miscript 03 02 2 #This means "Start at 03_filename.*, shift the prefixes by 2 and use 2 digits to construct the new prefixes".

Se você tiver outros arquivos no mesmo diretório que não estejam de acordo com a mesma sintaxe (prefix_filename.{txt,log}), você deve filtrá-los. Além disso, usei o "_" para separar o prefixo do nome do arquivo, portanto, se você alterar isso, precisará corrigir o código.

Para o que vale a pena, aqui está um bashone-liner que envolve duas substituições de processos e um procedimento muito simples awk:

$ ls -r -1 *_file_name.{txt,log}    # list initial files in reverse order
05_file_name.log
05_file_name.txt
04_file_name.log
03_file_name.txt
03_file_name.log
03_file_name.txt
02_file_name.log
02_file_name.txt
01_file_name.log
01_file_name.txt

$ source <(awk 'BEGIN{FS="_"} $1>2 {prefix=$1+2; printf ("mv -f %s %0.2d_%s_%s\n",$0,prefix,$2,$3)}' <(ls -r -1 *_file_name.{log,txt}))

$ ls -1 *_file_name.{txt,log}     # list resulting files
01_file_name.log
01_file_name.txt
02_file_name.log
02_file_name.txt
05_file_name.log
05_file_name.txt
06_file_name.log
06_file_name.txt
07_file_name.log
07_file_name.txt

Explicação:

O forro acima é lido, ou pelo menos "compreendido", da direita para a esquerda.

• ls -r -1 *_file_name.{log,txt} lista todos os arquivos a serem processados ​​em ordem inversa, no formato de uma coluna.
  Observe que, se os prefixos de arquivo (simbolizados por *) incluírem caracteres não numéricos, você poderá obter resultados imprevistos/indesejados. Para evitar isso, filtre os arquivos a serem processados ​​nesta fase.

• <(...)substituição do processo. Ele permite que a saída do resultado anterior seja referenciada usando um descritor de arquivo, ou seja, um arquivo temporário especial chamado pipe nomeado . Para detalhes emite man bashno terminal.

• awkroteiro:

  • BEGIN{FS="_"} antes de começar a processar os registros, defina o separador de campo do registro para "_" (1º bloco do awk)
  • awkcondicional do 2º bloco do $1>2: processa apenas os registros cujo prefixo do nome do arquivo é estritamente maior que 2
  • prefix=$1+2define a variável interna "prefixo" do awk. Torná-lo numericamente igual ao prefixo $1+ 2
  • use printf("my_format",var1,var2,...)para imprimir comandos formatados, separados por uma nova linha. Observe que a formatação envolve %0.2d, ou seja, imprimir awka variável "prefixo" como um número de dois dígitos com preenchimento 0 sempre que necessário. A saída é:
    mv -f 05_file_name.log 07_file_name.log
mv -f 05_file_name.txt 07_file_name.txt
mv -f 04_file_name.log 06_file_name.log
mv -f 04_file_name.txt 06_file_name.txt
mv -f 03_file_name.log 05_file_name.log
mv -f 03_file_name.txt 05_file_name.txt
    
• trate essa saída classificada como mais um arquivo (substituição do segundo processo) e forneça-o para executar os mv -f ...comandos.

Se você se pergunta por que usar repetidamente a substituição do processo de entrada ou saída (não uma coisa POSIX!) bashé vantajoso, veja isso , por exemplo.

Nota final:

Incluir parâmetros de tempo de execução no one-liner acima e encapsulá-lo em um script de shell executável é fácil, começando com a definição VAR1e VAR2a atribuição ao awkprocedimento do :

$ source <(awk -v VAR1=2 -v VAR2=2 'BEGIN{FS="_"} $1>VAR1 {prefix=$1+VAR2; printf ("mv -f %s %0.2d_%s_%s\n",$0,prefix,$2,$3)}' <(ls -r -1 *_file_name.{log,txt}))

E em um script executável, script.sh:

$ cat script.sh
#!/usr/bin/bash
if [ "$#" -eq 2 ] ; then
    source  <(awk -v VAR1=$1 -v VAR2=$2 'BEGIN{FS="_"} $1>VAR1 {prefix=$1+VAR2; printf ("mv -f %s %0.2d_%s_%s\n",$0,prefix,$2,$3)}' 
              <(ls -r -1 *_file_name.{log,txt})
             )
    exit 0
else
    echo "   Usage: script.sh VAR1 VAR2.\n    Abort execution (exit code 1)."
    exit 1
fi

onde VAR1e VAR2tem o significado definido no OP. Se você precisar usar esse script no ambiente de produção, recomendo adicionar várias verificações e proteções contra falhas para garantir que os valores de seus arquivos de entrada e variáveis ​​sejam os esperados em todos os momentos.

O script do @MarceloCastro é bom, embora seja baseado em um forloop, que costumo evitar sempre que possível. forloops tendem a ser lentos, algo que você pode notar se processar uma grande quantidade de arquivos.

Eu fiz este script que se encaixaria no seu objetivo.

for files in *.extensions
do
  num=$(echo "$files" | awk '{print $1}' | cut -c1-2)
  if [ $num -gt 2 ]; then
     AS=$((num+2))
     temp=$(echo "$files" | cut -c 3-)
     mv $files 0$AS"$temp"
  fi
done

Com zsh:

$ autoload zmv
$ zmv -n -f '(<3->)(_*)(#qnOn)' '${(l:2::0:)$(($1+2))}$2'
mv -- 05_file_name.txt 07_file_name.txt
mv -- 05_file_name.log 07_file_name.log
mv -- 04_file_name.txt 06_file_name.txt
mv -- 04_file_name.log 06_file_name.log
mv -- 03_file_name.txt 05_file_name.txt
mv -- 03_file_name.log 05_file_name.log

Em seguida, remova -n(para execução a seco) para realmente fazê-lo.

• zmv pattern replacement: zmvé uma função autocarregável que aproveita os poderosos zsh glob e operadores de expansão para renomear arquivos complexos.
• <x-y>corresponde ao número decimal x a y.
• (#q...)qualificador glob
• nOn: nnumericamente rder o(invertido com O maiúsculo) por name. Então 05...virá antes 04...conforme necessário aqui já que estamos incrementando os números.
• ${(l:n::padding:)expansion}: left pad a expansão para comprimento n usando padding . Então, com ${(l:2::0:)}, pad esquerdo para comprimento 2 com 0s.
• $(($1+2)), o primeiro grupo capturado incrementado em 2.
• $2: o segundo grupo de captura: o que vem depois do número inicial.