Como renomeio todas as pastas e arquivos para minúsculas no Linux?

Eu tenho que renomear uma árvore de pastas completa recursivamente para que nenhuma letra maiúscula apareça em qualquer lugar (é o código-fonte C ++, mas isso não deve importar).

Pontos de bônus por ignorar arquivos / pastas de controle de versão do CVS e Subversion. A maneira preferida seria um script de shell, já que um shell deve estar disponível em qualquer caixa do Linux.

Houve alguns argumentos válidos sobre os detalhes da renomeação do arquivo.

1. Eu acho que arquivos com os mesmos nomes em minúsculas devem ser substituídos; é problema do usuário. Quando feito check-out em um sistema de arquivos que ignora maiúsculas e minúsculas, ele substitui o primeiro pelo último também.

2. Eu consideraria os caracteres AZ e os transformaria em az; tudo o resto está apenas pedindo problemas (pelo menos com o código-fonte).

3. O script seria necessário para executar uma compilação em um sistema Linux, portanto, acho que as alterações nos arquivos de controle de versão do CVS ou Subversion devem ser omitidas. Afinal, é apenas uma verificação final. Talvez uma "exportação" seja mais apropriada.

Uma versão concisa usando o "rename"comando:

find my_root_dir -depth -exec rename 's/(.*)\/([^\/]*)/$1\/\L$2/' {} \;

Isso evita problemas com os diretórios sendo renomeados antes dos arquivos e tentando mover os arquivos para diretórios não existentes (por exemplo, "A/A"para "a/a").

Ou, uma versão mais detalhada sem usar "rename".

for SRC in `find my_root_dir -depth`
do
    DST=`dirname "${SRC}"`/`basename "${SRC}" | tr '[A-Z]' '[a-z]'`
    if [ "${SRC}" != "${DST}" ]
    then
        [ ! -e "${DST}" ] && mv -T "${SRC}" "${DST}" || echo "${SRC} was not renamed"
    fi
done

PS

Este último permite mais flexibilidade com o comando mover (por exemplo, "svn mv").

Menor ainda gosto bastante:

rename 'y/A-Z/a-z/' *

Em sistemas de arquivos que não diferenciam maiúsculas de minúsculas, como o HFS + do OS X , você deseja adicionar o -fsinalizador:

rename -f 'y/A-Z/a-z/' *

for f in `find`; do mv -v "$f" "`echo $f | tr '[A-Z]' '[a-z]'`"; done

Simplesmente tente o seguinte se não precisar se preocupar com eficiência.

zip -r foo.zip foo/*
unzip -LL foo.zip

Cara, vocês / moças gostam de complicar demais as coisas ...

rename 'y/A-Z/a-z/' *

A maioria das respostas acima é perigosa porque não lida com nomes contendo caracteres estranhos. Sua aposta mais segura para esse tipo de coisa é usar finda -print0opção '' , que encerrará os nomes de arquivos com ASCII NUL em vez de \ n.

Aqui está um script, que apenas altera arquivos e não nomes de diretório, para não confundir find:

find .  -type f -print0 | xargs -0n 1 bash -c \
's=$(dirname "$0")/$(basename "$0");
d=$(dirname "$0")/$(basename "$0"|tr "[A-Z]" "[a-z]"); mv -f "$s" "$d"'

Eu testei e funciona com nomes de arquivos que contêm espaços, todos os tipos de aspas, etc. Isso é importante porque se você executar, como root, um desses outros scripts em uma árvore que inclua o arquivo criado por

touch \;\ echo\ hacker::0:0:hacker:\$\'\057\'root:\$\'\057\'bin\$\'\057\'bash

... bem, adivinhe ...

Isso funciona se você já possui ou configurou o comando renomear (por exemplo, através da instalação do brew no Mac):

rename --lower-case --force somedir/*

Isso funciona no CentOS / Red Hat Linux ou em outras distribuições sem o renamescript Perl:

for i in $( ls | grep [A-Z] ); do mv -i "$i" "`echo $i | tr 'A-Z' 'a-z'`"; done

Origem: renomeie todos os nomes de arquivo de caracteres maiúsculos para minúsculos

(Em algumas distribuições, o renamecomando padrão vem do util-linux, e essa é uma ferramenta diferente e incompatível.)

A abordagem mais simples que encontrei no Mac OS X foi usar o pacote de renomeação em http://plasmasturm.org/code/rename/ :

brew install rename
rename --force --lower-case --nows *

--force Renomeie mesmo quando um arquivo com o nome de destino já exista.

--long-case - Converte nomes de arquivos em minúsculas.

--nows Substitua todas as seqüências de espaço em branco no nome do arquivo por caracteres sublinhados únicos.

Aqui está minha solução abaixo do ideal, usando um script de shell Bash:

#!/bin/bash
# First, rename all folders
for f in `find . -depth ! -name CVS -type d`; do
   g=`dirname "$f"`/`basename "$f" | tr '[A-Z]' '[a-z]'`
   if [ "xxx$f" != "xxx$g" ]; then
      echo "Renaming folder $f"
      mv -f "$f" "$g"
   fi
done

# Now, rename all files
for f in `find . ! -type d`; do
   g=`dirname "$f"`/`basename "$f" | tr '[A-Z]' '[a-z]'`
   if [ "xxx$f" != "xxx$g" ]; then
      echo "Renaming file $f"
      mv -f "$f" "$g"
   fi
done

Todas as pastas são renomeadas corretamente e mvnão fazem perguntas quando as permissões não coincidem, e as pastas CVS não são renomeadas (os arquivos de controle CVS nessa pasta ainda são renomeados, infelizmente).

Como "find-profundidade" e "find | sort -r" retornam a lista de pastas em uma ordem utilizável para renomear, eu preferi usar "-profundidade" para pesquisar pastas.

A pergunta original solicitava ignorar os diretórios SVN e CVS, o que pode ser feito adicionando -prune ao comando find. Por exemplo, para ignorar o CVS:

find . -name CVS -prune -o -exec mv '{}' `echo {} | tr '[A-Z]' '[a-z]'` \; -print

[edit] Eu tentei isso, e incorporar a tradução em letras minúsculas dentro da descoberta não funcionou por razões que eu realmente não entendo. Portanto, altere isso para:

$> cat > tolower
#!/bin/bash
mv $1 `echo $1 | tr '[:upper:]' '[:lower:]'`
^D
$> chmod u+x tolower 
$> find . -name CVS -prune -o -exec tolower '{}'  \;

Ian

Usando o fixador de nome de arquivo de Larry Wall:

$op = shift or die $help;
chomp(@ARGV = <STDIN>) unless @ARGV;
for (@ARGV) {
    $was = $_;
    eval $op;
    die $@ if $@;
    rename($was,$_) unless $was eq $_;
}

É tão simples quanto

find | fix 'tr/A-Z/a-z/'

(onde fixé claro o script acima)

Este é um pequeno script de shell que faz o que você solicitou:

root_directory="${1?-please specify parent directory}"
do_it () {
    awk '{ lc= tolower($0); if (lc != $0) print "mv \""  $0 "\" \"" lc "\"" }' | sh
}
# first the folders
find "$root_directory" -depth -type d | do_it
find "$root_directory" ! -type d | do_it

Observe a ação -thpth na primeira localização.

Não é portátil, apenas Zsh, mas bastante conciso.

Primeiro, verifique se zmvestá carregado.

autoload -U zmv

Além disso, verifique se extendedglobestá ativado:

setopt extendedglob

Então use:

zmv '(**/)(*)~CVS~**/CVS' '${1}${(L)2}'

Arquivos e diretórios em letras minúsculas recursivamente em que o nome não é CVS .

for f in `find -depth`; do mv ${f} ${f,,} ; done

find -depthimprime cada arquivo e diretório, com o conteúdo de um diretório impresso antes do próprio diretório. ${f,,}minúsculas o nome do arquivo.

Com o MacOS,

Instale o renamepacote,

brew install rename

Usar,

find . -iname "*.py" -type f | xargs -I% rename -c -f  "%"                       

Este comando encontra todos os arquivos com uma *.pyextensão e converte os nomes de arquivos em minúsculas.

`f` - forces a rename

Por exemplo,

$ find . -iname "*.py" -type f
./sample/Sample_File.py
./sample_file.py
$ find . -iname "*.py" -type f | xargs -I% rename -c -f  "%"
$ find . -iname "*.py" -type f
./sample/sample_file.py
./sample_file.py

Use typeset :

typeset -l new        # Always lowercase
find $topPoint |      # Not using xargs to make this more readable
  while read old
  do new="$old"       # $new is a lowercase version of $old
     mv "$old" "$new" # Quotes for those annoying embedded spaces
  done

No Windows, emulações, como Git Bash , podem falhar porque o Windows não diferencia maiúsculas de minúsculas. Para aqueles, adicione uma etapa que seja mvo arquivo com outro nome primeiro, como "$ old.tmp" e depois para $new.

Longo, mas "funciona sem surpresas e sem instalações"

Esse script lida com nomes de arquivos com espaços, aspas, outros caracteres incomuns e Unicode, funciona em sistemas de arquivos que não diferenciam maiúsculas de minúsculas e na maioria dos ambientes Unix-y que possuem bash e awk instalados (ou seja, quase todos). Ele também relata colisões, se houver (deixando o nome do arquivo em maiúsculas) e, é claro, renomeia os arquivos e diretórios e funciona recursivamente. Finalmente, é altamente adaptável: você pode ajustar o comando find para direcionar os arquivos / diretórios desejados e pode alterar o awk para fazer outras manipulações de nomes. Observe que, por "manipula Unicode", quero dizer que ele realmente converterá o caso deles (não os ignorará como respostas usadas tr).

# adapt the following command _IF_ you want to deal with specific files/dirs
find . -depth -mindepth 1 -exec bash -c '
  for file do
    # adapt the awk command if you wish to rename to something other than lowercase
    newname=$(dirname "$file")/$(basename "$file" | awk "{print tolower(\$0)}")
    if [ "$file" != "$newname" ] ; then
        # the extra step with the temp filename is for case-insensitive filesystems
        if [ ! -e "$newname" ] && [ ! -e "$newname.lcrnm.tmp" ] ; then
           mv -T "$file" "$newname.lcrnm.tmp" && mv -T "$newname.lcrnm.tmp" "$newname" 
        else
           echo "ERROR: Name already exists: $newname"
        fi
    fi    
  done
' sh {} +

Referências

Meu script é baseado nessas excelentes respostas:

/unix/9496/looping-through-files-with-spaces-in-the-names

Como converter uma string para minúsculas no Bash?

Isso também funciona bem no macOS:

ruby -e "Dir['*'].each { |p| File.rename(p, p.downcase) }"

Eu precisava fazer isso em uma configuração do Cygwin no Windows 7 e descobri que havia erros de sintaxe com as sugestões acima que eu tentei (embora eu possa ter perdido uma opção de trabalho). No entanto, esta solução diretamente dos fóruns do Ubuntu funcionou fora da lata :-)

ls | while read upName; do loName=`echo "${upName}" | tr '[:upper:]' '[:lower:]'`; mv "$upName" "$loName"; done

(NB: eu substituí anteriormente espaços em branco por sublinhados usando:

for f in *\ *; do mv "$f" "${f// /_}"; done

)

No OS X, mv -fmostra o erro "mesmo arquivo", então renomeio duas vezes:

for i in `find . -name "*" -type f |grep -e "[A-Z]"`; do j=`echo $i | tr '[A-Z]' '[a-z]' | sed s/\-1$//`; mv $i $i-1; mv $i-1 $j; done

Eu procuraria o Python nessa situação, para evitar a otimização de caminhos sem espaços ou barras. Eu também descobri que python2tende a ser instalado em mais lugares do que rename.

#!/usr/bin/env python2
import sys, os

def rename_dir(directory):
  print('DEBUG: rename('+directory+')')

  # Rename current directory if needed
  os.rename(directory, directory.lower())
  directory = directory.lower()

  # Rename children
  for fn in os.listdir(directory):
    path = os.path.join(directory, fn)
    os.rename(path, path.lower())
    path = path.lower()

    # Rename children within, if this child is a directory
    if os.path.isdir(path):
        rename_dir(path)

# Run program, using the first argument passed to this Python script as the name of the folder
rename_dir(sys.argv[1])

Se você usa o Arch Linux , pode instalar o renamepacote) a partir do AURqual fornece o renamexmcomando como /usr/bin/renamexmexecutável e uma página de manual junto com ele.

É uma ferramenta realmente poderosa para renomear rapidamente arquivos e diretórios.

Converter em minúsculas

rename -l Developers.mp3 # or --lowcase

Converter em maiúsculas e minúsculas

rename -u developers.mp3 # or --upcase, long option

Outras opções

-R --recursive # directory and its children

-t --test # Dry run, output but don't rename

-o --owner # Change file owner as well to user specified

-v --verbose # Output what file is renamed and its new name

-s/str/str2 # Substitute string on pattern

--yes # Confirm all actions

Você pode buscar o arquivo Developers.mp3 de exemplo aqui , se necessário;)

( find YOURDIR -type d | sort -r;
  find yourdir -type f ) |
grep -v /CVS | grep -v /SVN |
while read f; do mv -v $f `echo $f | tr '[A-Z]' '[a-z]'`; done

Primeiro, renomeie os diretórios de baixo para cima, classifique -r (onde -depth não está disponível), depois os arquivos. Então grep -v / CVS em vez de find ...- podar porque é mais simples. Para diretórios grandes, para f in ... pode estourar alguns buffers de shell. Use find ... | enquanto lê para evitar isso.

E sim, isso estraga arquivos que diferem apenas no caso de ...

find . -depth -name '*[A-Z]*'|sed -n 's/\(.*\/\)\(.*\)/mv -n -v -T \1\2 \1\L\2/p'|sh

Não tentei os scripts mais elaborados mencionados aqui, mas nenhuma das versões de linha de comando funcionou para mim no meu Synology NAS. renamenão está disponível e muitas das variações de findfalha porque parece aderir ao nome antigo do caminho já renomeado (por exemplo, se encontrar ./FOOseguido por ./FOO/BAR, renomear ./FOOpara ./foocontinuará a ser listado, ./FOO/BARmesmo que esse caminho não seja mais válido) . O comando acima funcionou para mim sem problemas.

A seguir, é apresentada uma explicação de cada parte do comando:

find . -depth -name '*[A-Z]*'

Ele encontrará qualquer arquivo do diretório atual (mude .para o diretório que você deseja processar), usando uma pesquisa aprofundada (por exemplo, listará ./foo/barantes ./foo), mas apenas para arquivos que contenham caracteres maiúsculos. O -namefiltro se aplica apenas ao nome do arquivo base, não ao caminho completo. Portanto, isso listará, ./FOO/BARmas não ./FOO/bar. Tudo bem, pois não queremos renomear ./FOO/bar. ./FOOPorém, queremos renomear , mas esse será listado mais tarde (é por isso que -depthé importante).

Esse comando por si só é particularmente útil para localizar os arquivos que você deseja renomear em primeiro lugar. Use isso após o comando rename completo para procurar arquivos que ainda não foram substituídos devido a erros ou colisões de nomes de arquivos.

sed -n 's/\(.*\/\)\(.*\)/mv -n -v -T \1\2 \1\L\2/p'

Esta parte lê os arquivos gerados por finde os formata em um mvcomando usando uma expressão regular. A -nopção para sedde imprimir a entrada e o pcomando na regex de pesquisa e substituição gera o texto substituído.

O regex em si consiste em duas capturas: a parte até o último / (que é o diretório do arquivo) e o próprio nome do arquivo. O diretório é deixado intacto, mas o nome do arquivo é transformado em minúsculas. Então, se findsaídas ./FOO/BAR, ele se tornará mv -n -v -T ./FOO/BAR ./FOO/bar. A -nopção de mvgarantir que os arquivos em minúsculas existentes não sejam substituídos. A -vopção produz a mvsaída a cada alteração que faz (ou não faz - se ./FOO/barjá existe, produz algo como ./FOO/BAR -> ./FOO/BAR, observando que nenhuma alteração foi feita). O -Té muito importante aqui - trata o arquivo de destino como um diretório. Isso garantirá que ./FOO/BARnão seja movido para ./FOO/baro diretório existente.

Use isso junto com findpara gerar uma lista de comandos que serão executados (útil para verificar o que será feito sem realmente fazê-lo)

sh

Isso é bastante auto-explicativo. Ele roteia todos os mvcomandos gerados para o interpretador de shell. Você pode substituí-lo por bashqualquer concha que desejar .

Renomear Slugify (regex)

Não é exatamente o que o OP solicitou, mas o que eu esperava encontrar nesta página:

Uma versão "slugify" para renomear arquivos para que sejam semelhantes aos URLs (ou seja, incluem apenas alfanuméricos, pontos e traços):

rename "s/[^a-zA-Z0-9\.]+/-/g" filename