É simples Não suporto quando as pessoas usam espaços ao nomear arquivos. Às vezes, destrói os comandos do console e torna a saída de ls feia.

O desafio é escrever um programa (apenas caracteres ascii) que

1. renomeia todos os arquivos (incluindo diretórios) no diretório atual para versões com espaços removidos ou substituídos por '_'
2. em caso de colisão, é necessário anexar um identificador exclusivo (até você)
3. desce recursivamente em todos os subdiretórios

Você pode assumir nomes de caminho no estilo UNIX. Quem precisaria desse programa em uma máquina Windows?

Isso é código de golfe, o programa mais curto vence (caracteres #ascii). Como eu odeio tanto os espaços, cada espaço deve ser contado duas vezes.

Forneça seu idioma, pontuação, programa e uma breve descrição de como executá-lo.

O programa deve compilar e executar com um esforço razoável na minha máquina Linux.

EDIT: Como Etan solicitou uma estrutura de arquivos para teste, eis o script que atualmente uso para criar uma árvore de arquivos adequada:

#!/bin/bash
rm -r TestDir

touchfiles()
{
    touch my_file
    touch my__file
    touch "my file"
    touch "my  file"
    touch " my_file  "
}

mkdir TestDir
cd TestDir

touchfiles

for dir in "Test Sub" Test_Sub "Te stSub" Te_stSub
do
    mkdir "$dir"
    cd "$dir"
    touchfiles
    cd ..
done

Coreutils Zsh + GNU - 48 bytes (1 espaço)

for x   (**/*(Dod))mv   -T  --b=t   $x  $x:h/${${x:t}// }

É estranho que você odeie espaços (ASCII), mas esteja bem com guias e novas linhas, mas acho que são necessários todos os tipos.

O zmv resolve muitos problemas de renomeação de arquivos de forma concisa (e apenas um pouco obscura). No entanto, insiste em que os alvos sejam únicos; embora você possa adicionar sufixos exclusivos com facilidade, adicionar um sufixo apenas se for necessário praticamente requer refazer todo o trabalho. Então, em vez disso, faço um loop manualmente e confio no GNU mv para anexar um identificador exclusivo em caso de colisão ( --backupopção, além disso --no-target-directory, caso um destino seja um diretório existente, caso contrário mv, moveria a fonte dentro desse diretório).

(od)é um qualificador global para classificar a saída com os diretórios que aparecem após o conteúdo (como os do find -depth). Dinclui arquivos de ponto na glob. :he :tsão modificadores de histórico semelhantes a dirnamee basename.

mvreclama que foi chamado para renomear arquivos para si próprios, porque a glob inclui nomes de arquivos sem espaços. É a vida.

Versão não destruída:

for x in **/*\ *(Dod); do
  mv --no-target-directory --backup=numbered $x ${x:h}/${${x:t}// /}
done

Bash 116 bytes, 16 espaços

find . -depth -exec bash -c 'B=${0##*/}
M="${0%/*}/${B// /_}"
while [ -e "$M" ]
do M=$M.
done
mv "$0" "$M"' {} \;

Não suprimi erros para obter mais alguns bytes. Isso não terá colisões.

Se um GNU não posix findpuder ser esperado, isso poderá ser reduzido ainda mais:

Bash 110 bytes, 15 espaços

find -d -exec bash -c 'B=${0##*/}
M="${0%/*}/${B// /_}"
while [ -e "$M" ]
do M=$M.
done
mv "$0" "$M"' {} \;

A remoção de espaços em vez de substituí-los usa dois bytes a menos:

Bash 108 bytes, 15 espaços

find -d -exec bash -c 'B=${0##*/}
M="${0%/*}/${B// }"
while [ -e "$M" ]
do M=$M.
done
mv "$0" "$M"' {} \;

Nota: se as guias puderem ser usadas em vez de espaços, será necessário apenas 1 espaço (aquele na regra de correspondência para substituição na linha 2).

Agradecimentos a Dennis por encontrar o erro entre aspas duplas (e fornecer a solução)

Python 180 bytes

from    os  import*
t,c,h='.',chdir,path
def g(p):
    c(p)
    for x   in  listdir(t):
        if h.isdir(x):g(x)
        n=x.replace(' ','')
        while h.exists(n):n+=t
        if' 'in x:rename(x,n)
    c(t*2)
g(t)

apenas 2 espaços se você usar tab para recuo :-)

Se a ordem dos sufixos de arquivo colidido não precisar dar precedentes ao arquivo preexistente, o seguinte funcionará para mim:

bash / find / mv 84 bytes, 16 espaços

find -depth -execdir bash -c '[ "${0//[^ ]}" ] && mv -{T,--b=t} "$0" "${0// }"' {} \;

bash / find / mv 82 bytes, 14 espaços

find -depth -execdir bash -c '[ "${0//[^ ]}" ]&&mv -{T,-b=t} "$0" "${0// }"' {} \;

Abraçado &&para salvar dois bytes de espaço.

bash / find / mv 60 bytes, 11 espaços

find -d -execdir bash -c 'mv -{T,-b=t} "$0" "${0// }"' {} \;

Abaixa a proteção contra erros para obter erros do mv em arquivos que não têm espaço para começar.

Edit: Soltou as aspas de {}como lembrado por Dennis. Também é permitido findgritar sobre portabilidade e reprovação na versão mais curta, onde mvjá está gritando sobre mover um arquivo por cima de si.

Editar 2: Adicionado -Tao mvcomando para evitar o aninhamento de diretórios em vez de renomear, conforme indicado pelo pqnet. Expansão de chave usada ao custo de um caractere, usando apenas um espaço.

NodeJS - 209 bytes, 3 espaços em branco

s=require('fs');function a(d){s.readdirSync(d).forEach(function(f){f=d+'/'+f;i=0;r=f;if(/ /.test(f)){r=f.replace(' ','');while(s.existsSync(r))r+=i++;s.renameSync(f,r)}s.statSync(r).isDirectory()&&a(r)})}a('.');

Bash - 86 bytes

find    .   -d|while    IFS=""  read    f;do    t=${f##*/};mv   --b=t   -T  "$f"    "${f%/*}"/${t// /};done

Bash + Perl rename64

( renameé o script Perl no Debian e derivados, não o comando util-linux.)

find . -depth -name "* *" -execdir rename 'y/ /_/' * \;

POSIX sh+ GNU find+ GNU mv67 bytes ASCII + um espaço (literal)

find    -d  -exec   sh  -cf 'IFS=\ ;IFS=_   set $0;mv   --b=t   "$0"    "$*"'   {}  \;

Não sei se ele se encaixa, mas com isso qualquer sequência de espaços é unida a um único _- eu gosto mesmo assim. Na verdade, qualquer sequência, exceto os espaços iniciais / finais que são - são automaticamente truncados (o que também é, penso eu, um comportamento benéfico) . Obrigado a Gilles por apontar isso.

Isso apenas usa o separador de campo interno para separar os campos.

É bastante ... falador ...

...Oh cara. Eu sabia que a coisa da guia era barata, mas achei que era pelo menos inteligente. Agora estou atrasado para a festa ...

PHP, 147 145 bytes, 2 1 espaço s -> 146

function    s(){foreach(glob("*")as$n){is_dir($n)&&chdir($n)&s()|chdir("..");if($n<$r=strtr($n," ",_)){while(file_exists($r))$r.=_;rename($n,$r);}}}

função recursiva. Correr coms(".");

Repita os globresultados para o caminho especificado:

• se diretório, recurs
• substituir espaços por sublinhado
• se as cordas diferirem
  • enquanto um novo nome de arquivo for obtido, acrescente sublinhado
  • renomear arquivo / diretório

Ruby 121

require 'find'

Find.find('.') do |file|
  if file.chomp.match(/ /)
    File.rename(file, file.gsub(/ /, '_'))
  end
end

Python, 187

165, mais 22 pontos de penalidade para os espaços.

from os import*
u='_';j=path.join
for t,d,f in walk('.',0):
 for z in f+d:
  n=z.replace(' ',u)
  if n!=z:
   while path.exists(j(t,n)):n+=u
   rename(j(t,z),j(t,n))

166, usando o truque de Emanuele :

Apenas um único espaço neste!

from    os  import*
u='_';j=path.join
for t,d,f   in  walk('.',0):
    for z   in  f+d:
        n=z.replace(' ',u)
        if  n!=z:
            while   path.exists(j(t,n)):n+=u
            rename(j(t,z),j(t,n))

LiveScript - 166

(Substitua espaços por tabulações.)

(a=->(s=require \fs)readdirSync(it)map (f)->f=it+'/'+f;r=f.replace /\s/g,i='';(while f!=r&&s.existsSync r=>r+=i++);s.statSync(f)isDirectory(s.renameSync f,r)&&a r) \.

Baseado no de nderscore versão otimizada da CPU1 's resposta .

Bash 4+ 111 bytes

shopt -s dotglob globstar
for f in **
do
n=${f// /}
while [[ $f != $n && -e $n ]]
do n+=1
done
mv "$f" $n
done

Groovy, 139 caracteres

def c
c={
f->
def g=new File(f.parent,f.name.replaceAll('\\s',''))
f.renameTo(g)
!g.directory ?: g.eachFile(c)
}
new File('.').eachFile(c)

de acordo com @ edc65 comment

Groovy, manipula colisões, 259 caracteres

def c
c={
p,l,f->
def g=new File(p,f.name.replaceAll('\\s',''))
f==g?:
(g.exists()?f.renameTo(g.toString()+l.indexOf(f.name)):f.renameTo(g))
!g.directory?:g.eachFile(c.curry(g,g.list().toList()))
}
def r=new File('.')
r.eachFile(c.curry(r,r.list().toList()))

POSIX (testado no zsh) + comandos básicos do Linux 151

export IFS='
'
for f in $(ls -R1);do export n=$(echo $f|tr ' ' '_');yes n|mv $f $n || yes n|mv $f `echo $n;echo $f|md5sum`
done