Comando rename: Renomeando Arquivos em Massa

Comando rename: Renomeando Arquivos em Massa
Tempo de leitura: Cerca de 10 min Dificuldade: Iniciante

O que você vai conseguir fazer

  • Visualizar a renomeação com `rename -n` antes de executar de verdade
  • Trocar extensões e textos em massa com `s/antigo/novo/`
  • Distinguir a versão Perl da util-linux com `rename --version` e trocar a sintaxe

Pré-requisitos (leia estes primeiro)

O Que Você Vai Aprender

  • Como renomear muitos arquivos de uma vez com um único comando
  • O hábito seguro de visualizar mudanças com -n antes de qualquer renomeação
  • Como a substituição s/antigo/novo/ troca extensões ou texto em massa
  • Como distinguir os dois comandos rename diferentes (Perl vs util-linux)

As palavras deste artigo

O rename reescreve nomes de arquivo. É justamente por isso que você aprende o -n primeiro. Com o -n ligado, nenhum arquivo muda.

Resumo Rápido (os padrões para memorizar primeiro)

  • Visualizar primeiro --> rename -n 's/antigo/novo/' * (mostra o plano, não muda nada)
  • Depois executar --> rename 's/antigo/novo/' *
  • Maiúsculas para minúsculas --> rename 'y/A-Z/a-z/' *
  • Não sabe qual rename você tem --> rename --version

Premissas (ambiente alvo)

  • SO: Ubuntu / Debian. O rename padrão é a versão Perl
  • Em outras distribuições (Fedora e afins) você pode ter a versão util-linux. A sintaxe dela é diferente (coberta na Seção 6)

Três hábitos que deixam a prática segura

Um rename errado muda vários nomes de uma vez. Os nomes antigos não voltam sozinhos. Estes três hábitos deixam a prática segura.

  1. Crie um diretório de prática e trabalhe só dentro dele (por exemplo, mkdir -p ~/rename-practice && cd ~/rename-practice)
  2. Teste em arquivos descartáveis, como os vazios criados com touch
  3. Sempre adicione -n antes da execução real e leia as mudanças planejadas

Note que o rename não faz parte do terminalUm programa interativo que interpreta os comandos digitados e os executa. virtual deste site. Teste em uma máquina Linux real ou no WSL. É justamente por isso que os três hábitos acima importam.

1. O Que É o Comando rename?

Conclusão: rename muda os nomes de muitos arquivos de uma vez usando um padrão, eliminando a necessidade de executar mv um arquivo por vez.

Lina: Senpai, eu tenho 50 arquivos como photo1.jpeg e photo2.jpeg. Quero mudar cada extensão para .jpg.
Lina: Tenho que corrigir um por um com mv?
Veterano Linny: Fazer 50 na mão seria doloroso. É exatamente para isso que o rename serve.
Veterano Linny: O mv é uma ferramenta para renomear um arquivo. O rename é uma ferramenta para renomear muitos de uma vez.
Lina: Então eu não preciso digitar mv 50 vezes?
Veterano Linny: Isso. Um comando renomeia todos os 50.
Veterano Linny: E você pode indicar um padrão, como "substituir apenas a parte .jpeg por .jpg". Essa é a verdadeira força dele.

A ideia básica do rename

rename 's/jpeg/jpg/' *.jpeg
        ↑           ↑
        |           arquivos alvo (aqui, todo .jpeg)
        regra (substituir jpeg por jpg)

Ele faz uma coisa só: encontra jpeg no nome do arquivo e reescreve para jpg. E faz isso em todos os arquivos alvo de uma vez.

2. Por Que Usar rename?

Conclusão: mv é suficiente para um arquivo, mas ineficiente para dezenas sob a mesma regra. rename permite escrever o padrão uma vez.

Lina: Eu já consigo renomear com mv, certo? Por que aprender o rename?
Veterano Linny: Boa pergunta. Para renomear um único arquivo, como mv old.txt new.txt, o mv basta.
Veterano Linny: O problema é mudar 100 arquivos pela mesma regra. Com mv você digitaria o comando 100 vezes.
Lina: Isso realmente não é prático.
Veterano Linny: Com rename você escreve a regra uma vez e ela se aplica a tudo.
Veterano Linny: Tarefas como "adicionar 2026_ no início de cada nome" ou "transformar espaços em underscores" terminam num comando só. E dão menos erro de digitação.

Renomear arquivos é difícil de desfazer. Digitar mv 50 vezes convida a erros de digitação.

Concentrar o trabalho em uma única regra rename deixa apenas uma coisa para conferir, o que é mais seguro.

Há o outro lado. Uma regra errada muda os 50 nomes de uma vez. Por isso a visualização com -n da próxima seção é essencial.

3. Sempre Visualize Com -n Primeiro (o hábito essencial)

Conclusão: Sempre execute rename com -n primeiro para ver exatamente o que mudaria, depois remova -n para aplicar de verdade.

A coisa mais importante com o rename é nunca executar às cegas. Adicione -n primeiro. Ele é a forma curta de --nono, o modo sem ação.

Com o -n, apenas o plano de mudanças aparece.

$ rename -n 's/jpeg/jpg/' *.jpeg
rename(photo1.jpeg, photo1.jpg)
rename(photo2.jpeg, photo2.jpg)
rename(photo3.jpeg, photo3.jpg)
Lina: Apareceu rename(photo1.jpeg, photo1.jpg). Os arquivos mudaram de verdade?
Veterano Linny: Não. Enquanto o -n estiver ativo, nenhum arquivo mudou.
Veterano Linny: É uma prévia que diz "se você executasse isso, seria assim". Ela aparece como rename(antes, depois).
Lina: Então ele me mostra o plano primeiro. Isso é tranquilizador.
Veterano Linny: Quando a saída parecer correta, remova o -n e execute o mesmo comando de novo. Aí a renomeação acontece de verdade.

Quando o plano parecer correto, remova -n para executar de verdade.

$ rename 's/jpeg/jpg/' *.jpeg

Agora os arquivos estão realmente renomeados. Adicione -v (--verbose) para imprimir os nomes que foram mudados.

$ rename -v 's/jpeg/jpg/' *.jpeg
photo1.jpeg renamed as photo1.jpg
photo2.jpeg renamed as photo2.jpg

A regra de ouro

  1. Execute rename -n 'regra' alvos para conferir o plano
  2. Se a saída estiver correta, remova o -n e execute
  3. Se tiver dúvida, adicione -v para ver o resultado também

Mantenha sempre esse hábito de dois passos: visualizar, depois executar.

4. Substituindo Texto Com s///

Conclusão: 's/antes/depois/' é a forma mais comum. Substitui texto dentro dos nomes de arquivo por outro texto.

O rename do Ubuntu (versão Perl) recebe uma regra de substituição como 's/antigo/novo/'. Isso vem da linguagem Perl, onde s significa substitute.

# Mudar extensao .jpeg para .jpg
$ rename -n 's/jpeg/jpg/' *.jpeg

# Mudar "draft" para "final" nos nomes
$ rename -n 's/draft/final/' *

# Adicionar "2026_" no inicio (^ significa inicio do nome)
$ rename -n 's/^/2026_/' *

# Adicionar ".bak" no final ($ significa fim do nome)
$ rename -n 's/$/.bak/' *
Lina: O que é o s no início de s/jpeg/jpg/? Ele está separado por barras.
Veterano Linny: O s é o sinal de "substitute" (substituir). s/A/B/ significa "encontre A e substitua por B".
Veterano Linny: As barras / são separadores. Basta lembrar s/antes/depois/.
Lina: Também vejo ^ e $. O que são esses?
Veterano Linny: São marcadores de posição. O ^ é o início do nome e o $ é o fim do nome.
Veterano Linny: Então s/^/2026_/ significa "adicionar 2026_ na frente". E s/$/.bak/ significa "adicionar .bak no final".
Veterano Linny: No começo, esses dois padrões já bastam.

Padrões comuns de substituição

O que você quer Regra
Mudar a extensão s/jpeg/jpg/
Trocar uma string s/draft/final/
Adicionar texto no início s/^/prefix_/
Adicionar texto no final s/$/_suffix/
Deletar uma string s/_copy//

Deixar a substituição vazia (//) significa "deletar essa string".

5. Normalizando Maiúsculas/Minúsculas Com y///

Conclusão: 'y/A-Z/a-z/' converte maiúsculas para minúsculas em massa. Mapeia caracteres um a um.

Para deixar nomes de arquivo em minúsculo, use 'y/A-Z/a-z/'. Aqui o y indica uma tradução no nível de caractere, chamada transliterate em inglês.

# Tornar todas as letras maiusculas em minusculas
$ rename -n 'y/A-Z/a-z/' *

# Tornar todas as letras minusculas em maiusculas
$ rename -n 'y/a-z/A-Z/' *
Lina: Tenho arquivos como IMG_001.JPG com maiúsculas misturadas. Quero todos em minúsculas.
Veterano Linny: Então y/A-Z/a-z/ é perfeito. Ele troca cada A-Z pelo correspondente a-z, um caractere por vez.
Veterano Linny: Assim IMG_001.JPG vira img_001.jpg.
Lina: Isso é diferente de s///?
Veterano Linny: O s/// substitui um bloco de texto. O y/// substitui um caractere por vez usando uma tabela de mapeamento.
Veterano Linny: Quando você quer mudar uma classe inteira de caracteres, como maiúsculas para minúsculas, o y/// é a opção certa.

5-1. Lina se enrola: um arquivo se recusou a mudar

Lina: Na minha pasta de prática eu criei File.txt e file.txt. Rodei rename 'y/A-Z/a-z/' * e apareceu uma mensagem que eu nunca tinha visto.
$ ls
File.txt  file.txt
$ rename 'y/A-Z/a-z/' *
File.txt not renamed: file.txt already exists
$ ls
File.txt  file.txt
Lina: Eu esperava os dois em minúsculo. Um deles não mudou.
Veterano Linny: Passar para minúsculo produz o nome file.txt. Um arquivo com esse nome já existia.
Veterano Linny: O rename do Ubuntu (versão Perl) para em vez de sobrescrever quando o nome de destino existe. Por isso apareceu not renamed.
Lina: Então ele não sobrescreve calado. Isso foi inesperado.
Veterano Linny: Isso. Ele só sobrescreve quando você adiciona -f. Isso não dá para desfazer, então não use -f neste artigo.
Lina: Entendi. Vou ler not renamed como "esse nome já está ocupado".

A mesma verificação acontece com o -n, então você percebe ainda na prévia.

$ rename -n 'y/A-Z/a-z/' *
File.txt not renamed: file.txt already exists

Cuidado com dois arquivos que diferem apenas em maiúsculas e minúsculas. Passar File.txt e file.txt para minúsculo produz o mesmo nome.

Por padrão o segundo é ignorado, não sobrescrito. Uma linha not renamed significa que aquele arquivo ficou como estava.

Só o -f (--force) sobrescreve, e o original não volta. Este artigo nunca usa -f.

6. Cuidado Com Dois Comandos rename Diferentes (Perl vs util-linux)

Conclusão: Existem dois comandos diferentes ambos chamados rename, com sintaxe diferente. Execute rename --version para ver qual você tem. O padrão do Ubuntu é a versão Perl.

Na verdade existem dois comandos com o mesmo nome mas internos diferentes. Esse é o maior ponto de confusão para iniciantes.

Lina: Pesquisei online e encontrei exemplos escritos sem barras, como rename .jpeg .jpg *.jpeg. Qual está correto?
Veterano Linny: Ambos estão corretos. Mas são comandos rename diferentes. Existem principalmente dois tipos.
Lina: O mesmo nome, mas internos diferentes?
Veterano Linny: Isso. Então a primeira coisa a fazer é confirmar qual você tem. Execute rename --version e você vai saber.
$ rename --version

Para a versão Perl (padrão Ubuntu / Debian), você verá algo como File::Rename.

/usr/bin/rename using File::Rename version 1.xx

Para a versão util-linux, você verá as palavras util-linux.

rename from util-linux 2.xx

Os dois comandos rename

Item Versão Perl (file-rename) Versão util-linux
Comum em Ubuntu / Debian Fedora / RHEL, etc.
Sintaxe rename 's/A/B/' * rename A B arquivos
Padrões Expressões regulares Substituição simples
Dry-run -n -n

Expressão regular é um jeito de descrever uma sequência de caracteres como padrão. A forma s/A/B/ usada neste artigo é um tipo dela.

Este artigo assume a versão Perl (padrão Ubuntu). Na versão util-linux, a mesma mudança .jpeg --> .jpg fica assim:

Se você está na versão util-linux, a mesma operação fica assim.

# util-linux version: rename DE PARA arquivos-alvo
$ rename .jpeg .jpg *.jpeg

Se a versão Perl não estiver instalada no Ubuntu, adicione com sudo apt install rename. A instalação exige privilégios de administrador.

De qualquer forma, verifique rename --version primeiro.

7. Armadilhas Comuns para Iniciantes

Conclusão: Executar sem -n, mirar em muitos arquivos e confundir as versões Perl e util-linux são os três erros mais comuns.

7-1. Executar sem -n

# Ruim: executar imediatamente sem verificacao (uma regra errada atinge tudo)
$ rename 's/a/b/' *

# Bom: visualizar com -n primeiro
$ rename -n 's/a/b/' *

Renomear é difícil de desfazer. Sempre olhe o plano com -n antes da execução real. Só isso já previne a maioria dos acidentes.

7-2. Mirar em muitos arquivos

# Arriscado: todo arquivo no diretorio atual e alvo
$ rename -n 's/o/0/' *

# Seguro: restringir o alvo a .txt
$ rename -n 's/o/0/' *.txt

* corresponde a todo arquivo do diretório atual. Assim, arquivos não pretendidos acabam sendo pegos. Restrinja o alcance com algo como *.txt.

7-3. Usar a versão util-linux esperando a versão Perl

Lina: Executei rename 's/jpeg/jpg/' *.jpeg mas nada mudou.
Veterano Linny: Você provavelmente está na versão util-linux. Ela não entende a forma s/.../.../.
Veterano Linny: Verifique com rename --version. Se for util-linux, mude para a forma rename .jpeg .jpg *.jpeg.

8. Mini Exercícios: Tente Você Mesmo

Conclusão: Crie arquivos de prática, depois tente substituição, prefixo e conversão para minúsculas em três exercícios, cada um com -n.

Lina: Quero experimentar na prática. Mas tenho medo de quebrar arquivos reais.
Veterano Linny: Por isso criamos arquivos vazios de prática. Arquivos feitos com touch não têm conteúdo, então perder um não custa nada.
Veterano Linny: Crie antes um diretório de prática e trabalhe só dentro dele.

Prepare os arquivos de prática.

$ mkdir -p ~/rename-practice && cd ~/rename-practice
$ touch photo1.JPEG photo2.JPEG report_draft.txt

Desafio 1: Mostre o que a mudança de .JPEG para .jpg faria, sem executar.

Ver Dica 1 (Direcionamento)

Você ainda não vai executar. Quer apenas o plano do que aconteceria.

Isso pede uma opção a mais.

Ver Dica 2 (Nome do comando)

Use rename. A opção que só mostra o plano é -n. Escreva a regra na forma 's/antes/depois/'.

Aponte para os arquivos com *.JPEG.

Ver Resposta 
$ rename -n 's/JPEG/jpg/' *.JPEG
rename(photo1.JPEG, photo1.jpg)
rename(photo2.JPEG, photo2.jpg)

Ver o plano assim significa que deu certo. Nenhum arquivo mudou ainda.

Desafio 2: Mude draft para final em report_draft.txt. Confira o plano e depois execute de verdade.

Ver Dica 1 (Direcionamento)

Você executa o mesmo comando duas vezes. A primeira confere o plano e a segunda aplica.

Na segunda vez, remova a opção de prévia.

Ver Dica 2 (Nome do comando)

A regra é 's/draft/final/'. Adicione -n na primeira vez e remova -n na segunda.

Você pode indicar o arquivo alvo pelo nome.

Ver Resposta 
$ rename -n 's/draft/final/' report_draft.txt
$ rename 's/draft/final/' report_draft.txt
$ ls
photo1.JPEG  photo2.JPEG  report_final.txt

Deu certo se o arquivo virou report_final.txt.

O Desafio 1 parou no -n, então os arquivos .JPEG continuam intactos. Aqui a regra "com o -n ligado nada muda" aparece de novo.

Desafio 3: Deixe em minúsculas todos os nomes de arquivo restantes.

Ver Dica 1 (Direcionamento)

Aqui você mapeia um caractere por vez, em vez de trocar um bloco de texto. A letra usada é diferente da do s///.

Confira o plano com -n antes e veja se aparece alguma linha not renamed.

Ver Dica 2 (Nome do comando)

Use y/A-Z/a-z/. Escreva depois de rename, entre aspas. O alvo é *.

Ver Resposta 
$ rename -n 'y/A-Z/a-z/' *
$ rename 'y/A-Z/a-z/' *

Uma linha not renamed: ... already exists significa que aquele arquivo ficou sem mudar. É o sinal de que o nome de destino já está ocupado.

9. Limpando o Diretório de Prática

10. Modelos para Copiar e Colar

Conclusão: Mantenha à mão as formas comuns para visualizar, substituir, prefixo/sufixo, converter para minúsculas e verificar a versão.

Formas comuns (versão Perl assumida)

# Visualizar o plano primeiro (mais importante)
rename -n 's/old/new/' *

# Executar de verdade apos verificar
rename 's/old/new/' *

# Mudar uma extensao
rename -n 's/jpeg/jpg/' *.jpeg

# Adicionar texto no inicio
rename -n 's/^/2026_/' *

# Adicionar texto no final
rename -n 's/$/.bak/' *

# Deletar uma string
rename -n 's/_copy//' *

# Normalizar maiusculas para minusculas
rename -n 'y/A-Z/a-z/' *

# Verificar qual rename voce tem
rename --version

11. Revisão

Lina: Vou resumir. Com o rename eu escrevo a regra uma vez e vários nomes mudam juntos.
Veterano Linny: Isso. E é justamente por isso que uma regra errada muda tudo de uma vez.
Lina: Então eu adiciono -n antes e leio o plano com os meus próprios olhos.
Veterano Linny: Boa memória. O acidente do File.txt com o file.txt também apareceria nesse plano.

Resumo em 3 Linhas

  1. O rename aplica uma regra a muitos nomes de arquivo de uma vez
  2. Sempre adicione -n antes da execução real. Ele mostra o plano e não muda nada
  3. s/antigo/novo/ troca um bloco de texto e y/A-Z/a-z/ mapeia um caractere por vez

Próximas Leituras