Como o Bash pode renomear uma série de pacotes para remover seus números de versão? Tenho brincado com os dois expre %%, sem sucesso.

Exemplos:

Xft2-2.1.13.pkg torna-se Xft2.pkg

jasper-1.900.1.pkg torna-se jasper.pkg

xorg-libXrandr-1.2.3.pkg torna-se xorg-libXrandr.pkg

Você pode usar o recurso de expansão de parâmetros do bash

for i in ./*.pkg ; do mv "$i" "${i/-[0-9.]*.pkg/.pkg}" ; done

As citações são necessárias para nomes de arquivos com espaços.

Se todos os arquivos estiverem no mesmo diretório, a sequência

ls | 
sed -n 's/\(.*\)\(-[0-9.]*\.pkg\)/mv "\1\2" "\1.pkg"/p' | 
sh

fará o seu trabalho. O comando sed criará uma sequência de comandos mv , que você pode canalizar para o shell. É melhor primeiro executar o pipeline sem o trailing | shpara verificar se o comando faz o que você deseja.

Para percorrer vários diretórios, use algo como

find . -type f |
sed -n 's/\(.*\)\(-[0-9.]*\.pkg\)/mv "\1\2" "\1.pkg"/p' |
sh

Observe que no sed a sequência de agrupamento da expressão regular são colchetes precedidos por uma barra invertida \(e \), em vez de colchetes simples (e ).

Vou fazer algo assim:

for file in *.pkg ; do
    mv $file $(echo $file | rev | cut -f2- -d- | rev).pkg
done

supostamente todos os seus arquivos estão no diretório atual. Se não, tente usar find conforme recomendado acima por Javier.

EDIT : Além disso, esta versão não usa nenhum recurso específico do bash, como os outros acima, o que leva você a mais portabilidade.

Aqui está um POSIX quase equivalente à resposta atualmente aceita . Isso troca a ${variable/substring/replacement}expansão de parâmetro apenas do Bash por uma que está disponível em qualquer shell compatível com Bourne.

for i in ./*.pkg; do
    mv "$i" "${i%-[0-9.]*.pkg}.pkg"
done

O parâmetro expansion ${variable%pattern}produz o valor de variablecom qualquer sufixo que corresponda patternremovido. (Também é ${variable#pattern}necessário remover um prefixo.)

Eu mantive o subpadrão -[0-9.]*da resposta aceita, embora talvez seja enganoso. Não é uma expressão regular, mas um padrão glob; portanto, não significa "um traço seguido de zero ou mais números ou pontos". Em vez disso, significa "um travessão, seguido por um número ou um ponto, seguido por qualquer coisa". O "qualquer coisa" será a correspondência mais curta possível, não a mais longa. (O Bash oferece ##e %%para cortar o prefixo ou sufixo mais longo possível, em vez do mais curto.)

Podemos presumir que sedestá disponível em qualquer * nix, mas não podemos ter certeza de que suportará sed -na geração de comandos mv. ( NOTA: Apenas GNU sedfaz isso.)

Mesmo assim, bash builtins e sed, podemos rapidamente criar uma função shell para fazer isso.

sedrename() {
  if [ $# -gt 1 ]; then
    sed_pattern=$1
    shift
    for file in $(ls $@); do
      mv -v "$file" "$(sed $sed_pattern <<< $file)"
    done
  else
    echo "usage: $0 sed_pattern files..."
  fi
}

Uso

sedrename 's|\(.*\)\(-[0-9.]*\.pkg\)|\1\2|' *.pkg

before:

./Xft2-2.1.13.pkg
./jasper-1.900.1.pkg
./xorg-libXrandr-1.2.3.pkg

after:

./Xft2.pkg
./jasper.pkg
./xorg-libXrandr.pkg

Criação de pastas de destino:

Uma vez mvque não cria pastas de destino automaticamente, não podemos usar nossa versão inicial do sedrename.

É uma mudança bastante pequena, então seria bom incluir esse recurso:

Precisaremos de uma função de utilidade abspath(ou caminho absoluto) já que o bash não tem essa função.

abspath () { case "$1" in
               /*)printf "%s\n" "$1";;
               *)printf "%s\n" "$PWD/$1";;
             esac; }

Assim que tivermos isso, podemos gerar a (s) pasta (s) de destino para um padrão sed / rename que inclui uma nova estrutura de pastas.

Isso garantirá que saibamos os nomes de nossas pastas de destino. Quando renomearmos, precisaremos usá-lo no nome do arquivo de destino.

# generate the rename target
target="$(sed $sed_pattern <<< $file)"

# Use absolute path of the rename target to make target folder structure
mkdir -p "$(dirname $(abspath $target))"

# finally move the file to the target name/folders
mv -v "$file" "$target"

Aqui está o script com reconhecimento de pasta completo ...

sedrename() {
  if [ $# -gt 1 ]; then
    sed_pattern=$1
    shift
    for file in $(ls $@); do
      target="$(sed $sed_pattern <<< $file)"
      mkdir -p "$(dirname $(abspath $target))"
      mv -v "$file" "$target"
    done
  else
    echo "usage: $0 sed_pattern files..."
  fi
}

Claro, ele ainda funciona quando não temos pastas de destino específicas também.

Se quisermos colocar todas as músicas em uma pasta, ./Beethoven/podemos fazer o seguinte:

Uso

sedrename 's|Beethoven - |Beethoven/|g' *.mp3

before:

./Beethoven - Fur Elise.mp3
./Beethoven - Moonlight Sonata.mp3
./Beethoven - Ode to Joy.mp3
./Beethoven - Rage Over the Lost Penny.mp3

after:

./Beethoven/Fur Elise.mp3
./Beethoven/Moonlight Sonata.mp3
./Beethoven/Ode to Joy.mp3
./Beethoven/Rage Over the Lost Penny.mp3

Rodada de bônus ...

Usando este script para mover arquivos de pastas para uma única pasta:

Supondo que desejamos reunir todos os arquivos correspondentes e colocá-los na pasta atual, podemos fazer isso:

sedrename 's|.*/||' **/*.mp3

before:

./Beethoven/Fur Elise.mp3
./Beethoven/Moonlight Sonata.mp3
./Beethoven/Ode to Joy.mp3
./Beethoven/Rage Over the Lost Penny.mp3

after:

./Beethoven/ # (now empty)
./Fur Elise.mp3
./Moonlight Sonata.mp3
./Ode to Joy.mp3
./Rage Over the Lost Penny.mp3

Nota sobre padrões de regex sed

Regras regulares de padrão sed se aplicam a este script, esses padrões não são PCRE (Expressões regulares compatíveis com Perl). Você poderia ter estendido a sintaxe de expressão regular do sed, usando sed -rou sed -E dependendo da sua plataforma.

Consulte o POSIX compatível man re_formatpara uma descrição completa dos padrões de expressão regular básica e estendida sed.

Acho que renomear é uma ferramenta muito mais simples de usar para esse tipo de coisa. Eu encontrei no Homebrew para OSX

Para o seu exemplo, eu faria:

rename 's/\d*?\.\d*?\.\d*?//' *.pkg

O 's' significa substituto. O formato é s / searchPattern / replacement / files_to_apply. Você precisa usar regex para isso, o que exige um pouco de estudo, mas vale a pena o esforço.

melhor uso sedpara isso, algo como:

find . -type f -name "*.pkg" |
 sed -e 's/((.*)-[0-9.]*\.pkg)/\1 \2.pkg/g' |
 while read nameA nameB; do
    mv $nameA $nameB;
 done

descobrir a expressão regular é deixado como um exercício (assim como lidar com nomes de arquivos que incluem espaços)

Isso parece funcionar assumindo que

• tudo termina com $ pkg
• sua versão # sempre começa com "-"

retire o .pkg, depois retire - ..

for x in $(ls); do echo $x $(echo $x | sed 's/\.pkg//g' | sed 's/-.*//g').pkg; done

Eu tinha vários *.txtarquivos para serem renomeados como .sqlna mesma pasta. abaixo funcionou para mim:

for i in \`ls *.txt | awk -F "." '{print $1}'\` ;do mv $i.txt $i.sql; done

Obrigado por essas respostas. Eu também tive algum tipo de problema. Movendo arquivos .nzb.queued para arquivos .nzb. Tinha espaços e outras falhas nos nomes dos arquivos e isso resolveu meu problema:

find . -type f -name "*.nzb.queued" |
sed -ne "s/^\(\(.*\).nzb.queued\)$/mv -v \"\1\" \"\2.nzb\"/p" |
sh

É baseado na resposta de Diomidis Spinellis.

O regex cria um grupo para todo o nome do arquivo e um grupo para a parte anterior a .nzb.queued e, a seguir, cria um comando de movimentação do shell. Com as cordas entre aspas. Isso também evita a criação de um loop no script de shell porque isso já é feito pelo sed.