Renomeie vários arquivos com base no padrão no Unix

Existem vários arquivos em um diretório que começam com o prefixo fgh, por exemplo:

fghfilea
fghfileb
fghfilec

Eu quero renomear todos eles para começar com o prefixo jkl. Existe um único comando para fazer isso em vez de renomear cada arquivo individualmente?

Existem várias maneiras, mas usar rename provavelmente será o mais fácil.

Usando uma versão de rename:

rename 's/^fgh/jkl/' fgh*

Usando outra versão rename(igual à resposta do Judy2K ):

rename fgh jkl fgh*

Você deve verificar a página de manual da sua plataforma para ver qual das opções acima se aplica.

É assim que sede mvpodemos ser usados ​​juntos para renomear:

for f in fgh*; do mv "$f" $(echo "$f" | sed 's/^fgh/jkl/g'); done

Conforme o comentário abaixo, se os nomes dos arquivos tiverem espaços, as aspas podem precisar envolver a subfunção que retorna o nome para o qual os arquivos são movidos:

for f in fgh*; do mv "$f" "$(echo $f | sed 's/^fgh/jkl/g')"; done

renomear pode não estar em todos os sistemas. Portanto, se você não o tiver, use o shell neste exemplo no bash shell

for f in fgh*; do mv "$f" "${f/fgh/xxx}";done

Usando mmv :

mmv "fgh*" "jkl#1"

Existem várias maneiras de fazer isso (nem todas funcionarão em todos os sistemas unixy):

• ls | cut -c4- | xargs -I§ mv fgh§ jkl§

  O § pode ser substituído por qualquer coisa que você achar conveniente. Você poderia fazer isso find -exectambém, mas que se comporta sutilmente diferente em muitos sistemas, então eu costumo evitar isso.

• for f in fgh*; do mv "$f" "${f/fgh/jkl}";done

  Bruto, mas eficaz, como se costuma dizer

• rename 's/^fgh/jkl/' fgh*

  Muito bonito, mas renomear não está presente no BSD, que é o sistema unix mais comum.

• rename fgh jkl fgh*

• ls | perl -ne 'chomp; next unless -e; $o = $_; s/fgh/jkl/; next if -e; rename $o, $_';

  Se você insistir em usar Perl, mas não houver renomeação no seu sistema, poderá usar esse monstro.

Alguns deles são um pouco complicados e a lista está longe de estar completa, mas você encontrará o que deseja aqui para praticamente todos os sistemas unix.

rename fgh jkl fgh*

Usando find, xargse sed:

find . -name "fgh*" -type f -print0 | xargs -0 -I {} sh -c 'mv "{}" "$(dirname "{}")/`echo $(basename "{}") | sed 's/^fgh/jkl/g'`"'

É mais complexo que a solução da @ nik, mas permite renomear arquivos recursivamente. Por exemplo, a estrutura,

.
├── fghdir
│   ├── fdhfilea
│   └── fghfilea
├── fghfile\ e
├── fghfilea
├── fghfileb
├── fghfilec
└── other
    ├── fghfile\ e
    ├── fghfilea
    ├── fghfileb
    └── fghfilec

seria transformado para isso,

.
├── fghdir
│   ├── fdhfilea
│   └── jklfilea
├── jklfile\ e
├── jklfilea
├── jklfileb
├── jklfilec
└── other
    ├── jklfile\ e
    ├── jklfilea
    ├── jklfileb
    └── jklfilec

A chave para fazê-lo funcionar xargsé invocar o shell do xargs .

Para instalar o script de renomeação do Perl :

sudo cpan install File::Rename

Existem duas renomeações, conforme mencionado nos comentários na resposta de Stephan202. As distribuições baseadas no Debian têm o nome do Perl . Red Hat / rpm distribuições tem a mudança de nome C .
O OS X não possui um instalado por padrão (pelo menos na versão 10.8), nem o Windows / Cygwin.

Aqui está uma maneira de fazer isso usando a linha de comando Groovy:

groovy -e 'new File(".").eachFileMatch(~/fgh.*/) {it.renameTo(it.name.replaceFirst("fgh", "jkl"))}'

No Solaris, você pode tentar:

for file in `find ./ -name "*TextForRename*"`; do 
    mv -f "$file" "${file/TextForRename/NewText}"
done

#!/bin/sh

#replace all files ended witn .f77 to .f90 in a directory

for filename in *.f77
do 
    #echo $filename
    #b= echo $filename | cut -d. -f1
    #echo $b    
    mv "${filename}" "${filename%.f77}.f90"    
done

Esse script funcionou para mim na renomeação recursiva com diretórios / nomes de arquivos possivelmente contendo espaços em branco:

find . -type f -name "*\;*" | while read fname; do
    dirname=`dirname "$fname"`
    filename=`basename "$fname"`
    newname=`echo "$filename" | sed -e "s/;/ /g"`
    mv "${dirname}/$filename" "${dirname}/$newname"
done

Observe a sedexpressão que neste exemplo substitui todas as ocorrências de ;com espaço . Obviamente, isso deve ser substituído de acordo com as necessidades específicas.

Usando ferramentas StringSolver (windows e Linux bash), que são processadas por exemplos:

filter fghfilea ok fghreport ok notfghfile notok; mv --all --filter fghfilea jklfilea

Primeiro, ele calcula um filtro com base em exemplos , onde a entrada é o nome do arquivo e a saída (ok e notok, seqüências arbitrárias). Se o filtro tivesse a opção --auto ou fosse invocado sozinho após esse comando, ele criaria uma pasta oke uma pasta notoke enviaria arquivos respectivamente para eles.

Em seguida, usando o filtro, o mvcomando é uma movimentação semi-automática que se torna automática com o modificador --auto. Usando o filtro anterior, graças ao --filter, ele encontra um mapeamento de fghfileapara jklfileae depois o aplica em todos os arquivos filtrados.

Outras soluções de uma linha

Outras maneiras equivalentes de fazer o mesmo (cada linha é equivalente), para que você possa escolher sua maneira favorita de fazê-lo.

filter fghfilea ok fghreport ok notfghfile notok; mv --filter fghfilea jklfilea; mv
filter fghfilea ok fghreport ok notfghfile notok; auto --all --filter fghfilea "mv fghfilea jklfilea"
# Even better, automatically infers the file name
filter fghfilea ok fghreport ok notfghfile notok; auto --all --filter "mv fghfilea jklfilea"

Solução em várias etapas

Para descobrir com cuidado se os comandos estão funcionando bem, você pode digitar o seguinte:

filter fghfilea ok
filter fghfileb ok
filter fghfileb notok

e quando tiver certeza de que o filtro está bom, execute o primeiro movimento:

mv fghfilea jklfilea

Se você deseja testar e usar o filtro anterior, digite:

mv --test --filter

Se a transformação não for o que você queria (por exemplo, mesmo que mv --explainvocê veja que algo está errado), digite mv --clearpara reiniciar os arquivos em movimento ou adicione mais exemplos em mv input1 input2que input1 e input2 são outros exemplos

Quando estiver confiante, basta digitar

mv --filter

e voilà! Toda a renomeação é feita usando o filtro.

AVISO LEGAL: Eu sou co-autor deste trabalho feito para fins acadêmicos. Também pode haver um recurso de produção de festança em breve.

Foi muito mais fácil (no meu Mac) fazer isso no Ruby. Aqui estão 2 exemplos:

# for your fgh example. renames all files from "fgh..." to "jkl..."
files = Dir['fgh*']

files.each do |f|
  f2 = f.gsub('fgh', 'jkl')
  system("mv #{f} #{f2}")
end

# renames all files in directory from "021roman.rb" to "021_roman.rb"
files = Dir['*rb'].select {|f| f =~ /^[0-9]{3}[a-zA-Z]+/}

files.each do |f|
  f1 = f.clone
  f2 = f.insert(3, '_')
  system("mv #{f1} #{f2}")
end

Usando renamer :

$ renamer --find /^fgh/ --replace jkl * --dry-run

Remova a --dry-runbandeira quando estiver satisfeito, a saída parece correta.

Minha versão de renomear arquivos em massa:

for i in *; do
    echo "mv $i $i"
done |
sed -e "s#from_pattern#to_pattern#g” > result1.sh
sh result1.sh

Eu recomendaria usar meu próprio script, que resolve esse problema. Ele também possui opções para alterar a codificação dos nomes dos arquivos e converter diacríticos combinados em caracteres pré-compostos, um problema que sempre tenho ao copiar arquivos do meu Mac.

#!/usr/bin/perl

# Copyright (c) 2014 André von Kugland

# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distribute, sublicense,
# and/or sell copies of the Software, and to permit persons to whom the
# Software is furnished to do so, subject to the following conditions:

# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.

# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
# DEALINGS IN THE SOFTWARE.

$help_msg =
"rename.pl, a script to rename files in batches, using Perl
           expressions to transform their names.
Usage:
    rename.pl [options] FILE1 [FILE2 ...]
Where options can be:
    -v                      Verbose.
    -vv                     Very verbose.
    --apply                 Really apply modifications.
    -e PERLCODE             Execute PERLCODE. (e.g. 's/a/b/g')
    --from-charset=CS       Source charset. (e.g. \"iso-8859-1\")
    --to-charset=CS         Destination charset. (e.g. \"utf-8\")
    --unicode-normalize=NF  Unicode normalization form. (e.g. \"KD\")
    --basename              Modifies only the last element of the path.
";

use Encode;
use Getopt::Long;
use Unicode::Normalize 'normalize';
use File::Basename;
use I18N::Langinfo qw(langinfo CODESET);

Getopt::Long::Configure ("bundling");

# ----------------------------------------------------------------------------------------------- #
#                                           Our variables.                                        #
# ----------------------------------------------------------------------------------------------- #

my $apply = 0;
my $verbose = 0;
my $help = 0;
my $debug = 0;
my $basename = 0;
my $unicode_normalize = "";
my @scripts;
my $from_charset = "";
my $to_charset = "";
my $codeset = "";

# ----------------------------------------------------------------------------------------------- #
#                                        Get cmdline options.                                     #
# ----------------------------------------------------------------------------------------------- #

$result = GetOptions ("apply" => \$apply,
                      "verbose|v+" => \$verbose,
                      "execute|e=s" => \@scripts,
                      "from-charset=s" => \$from_charset,
                      "to-charset=s" => \$to_charset,
                      "unicode-normalize=s" => \$unicode_normalize,
                      "basename" => \$basename,
                      "help|h|?" => \$help,
                      "debug" => \$debug);

# If not going to apply, then be verbose.
if (!$apply && $verbose == 0) {
  $verbose = 1;
}

if ((($#scripts == -1)
  && (($from_charset eq "") || ($to_charset eq ""))
  && $unicode_normalize eq "")
  || ($#ARGV == -1) || ($help)) {
  print $help_msg;
  exit(0);
}

if (($to_charset ne "" && $from_charset eq "")
  ||($from_charset eq "" && $to_charset ne "")
  ||($to_charset eq "" && $from_charset eq "" && $unicode_normalize ne "")) {
  $codeset = langinfo(CODESET);
  $to_charset = $codeset if $from_charset ne "" && $to_charset eq "";
  $from_charset = $codeset if $from_charset eq "" && $to_charset ne "";
}

# ----------------------------------------------------------------------------------------------- #
#         Composes the filter function using the @scripts array and possibly other options.       #
# ----------------------------------------------------------------------------------------------- #

$f = "sub filterfunc() {\n    my \$s = shift;\n";
$f .= "    my \$d = dirname(\$s);\n    my \$s = basename(\$s);\n" if ($basename != 0);
$f .= "    for (\$s) {\n";
$f .= "        $_;\n" foreach (@scripts);   # Get scripts from '-e' opt. #
# Handle charset translation and normalization.
if (($from_charset ne "") && ($to_charset ne "")) {
  if ($unicode_normalize eq "") {
    $f .= "        \$_ = encode(\"$to_charset\", decode(\"$from_charset\", \$_));\n";
  } else {
    $f .= "        \$_ = encode(\"$to_charset\", normalize(\"$unicode_normalize\", decode(\"$from_charset\", \$_)));\n"
  }
} elsif (($from_charset ne "") || ($to_charset ne "")) {
    die "You can't use `from-charset' nor `to-charset' alone";
} elsif ($unicode_normalize ne "") {
  $f .= "        \$_ = encode(\"$codeset\", normalize(\"$unicode_normalize\", decode(\"$codeset\", \$_)));\n"
}
$f .= "    }\n";
$f .= "    \$s = \$d . '/' . \$s;\n" if ($basename != 0);
$f .= "    return \$s;\n}\n";
print "Generated function:\n\n$f" if ($debug);

# ----------------------------------------------------------------------------------------------- #
#                 Evaluates the filter function body, so to define it in our scope.               #
# ----------------------------------------------------------------------------------------------- #

eval $f;

# ----------------------------------------------------------------------------------------------- #
#                  Main loop, which passes names through filters and renames files.               #
# ----------------------------------------------------------------------------------------------- #

foreach (@ARGV) {
  $old_name = $_;
  $new_name = filterfunc($_);

  if ($old_name ne $new_name) {
    if (!$apply or (rename $old_name, $new_name)) {
      print "`$old_name' => `$new_name'\n" if ($verbose);
    } else {
      print "Cannot rename `$old_name' to `$new_name'.\n";
    }
  } else {
    print "`$old_name' unchanged.\n" if ($verbose > 1);
  }
}

Isso funcionou para mim usando o regexp:

Eu queria que os arquivos fossem renomeados assim:

file0001.txt -> 1.txt
ofile0002.txt -> 2.txt 
f_i_l_e0003.txt -> 3.txt

use o [az | _] + 0 * ([0-9] +. ) regexp onde ([0-9] +. ) é uma subcadeia de grupo a ser usada no comando rename

ls -1 | awk 'match($0, /[a-z|\_]+0*([0-9]+.*)/, arr) { print   arr[0]  " "  arr[1] }'|xargs  -l mv

Produz:

mv file0001.txt 1.txt
mv ofile0002.txt 2.txt
mv f_i_l_e0003.txt 3.txt

Outro exemplo:

file001abc.txt -> abc1.txt
ofile0002abcd.txt -> abcd2.txt 

ls -1 | awk 'match($0, /[a-z|\_]+0*([0-9]+.*)([a-z]+)/, arr) { print   arr[0]  " "  arr[2] arr[1] }'|xargs  -l mv

Produz:

  mv file001abc.txt abc1.txt
  mv ofile0002abcd.txt abcd2.txt 

Atenção, tenha cuidado.

Eu escrevi esse script para procurar todos os arquivos .mkv renomeando recursivamente os arquivos encontrados para .avi. Você pode personalizá-lo para seus neeeds. Adicionei algumas outras coisas, como obter diretório, extensão e nome de arquivo a partir de um caminho, caso você precise se referir a algo no futuro.

find . -type f -name "*.mkv" | while read fp; do 
fd=$(dirname "${fp}");
fn=$(basename "${fp}");
ext="${fn##*.}";
f="${fn%.*}";
new_fp="${fd}/${f}.avi"
mv -v "$fp" "$new_fp" 
done;

Um script genérico para executar uma sedexpressão em uma lista de arquivos (combina a sedsolução com a renamesolução ):

#!/bin/sh

e=$1
shift

for f in $*; do
    fNew=$(echo "$f" | sed "$e")
    mv "$f" "$fNew";
done

Invoque passando uma sedexpressão para o script e, em seguida, qualquer lista de arquivos, como uma versão de rename:

script.sh 's/^fgh/jkl/' fgh*

Você também pode usar o script abaixo. é muito fácil rodar no terminal ...

// Renomeie vários arquivos por vez

for file in  FILE_NAME*
do
    mv -i "${file}" "${file/FILE_NAME/RENAMED_FILE_NAME}"
done

Exemplo:-

for file in  hello*
do
    mv -i "${file}" "${file/hello/JAISHREE}"
done

Outra possível expansão de parâmetro :

for f in fgh*; do mv -- "$f" "jkl${f:3}"; done