C'est simple. Je ne peux pas rester debout lorsque des personnes utilisent des espaces pour nommer des fichiers. Cela détruit parfois les commandes de la console et rend la sortie de ls moche.

Le défi consiste à écrire un programme (uniquement des caractères ascii) qui

1. renomme tous les fichiers (y compris les répertoires) du répertoire en cours en versions avec espaces supprimés ou remplacés par '_'
2. en cas de collision, vous devez ajouter un identifiant unique (à vous de choisir)
3. descend de manière récursive dans tous les sous-répertoires

Vous pouvez assumer des chemins d'accès de style UNIX. Qui aurait besoin de ce programme sur une machine Windows de toute façon?

C'est le code golf, le programme le plus court gagne (#ascii caractères). Comme je déteste tellement les espaces, chaque espace doit être compté deux fois.

Veuillez indiquer votre langue, votre score, votre programme et une brève description de son exécution.

Le programme doit compiler et exécuter avec un effort raisonnable sur ma machine Linux.

EDIT: Etan ayant demandé une structure de fichier pour les tests, voici le script que j’utilise actuellement pour créer une arborescence de fichiers appropriée:

#!/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

Zsh + GNU coreutils - 48 octets (1 espace)

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

C'est bizarre que vous détestiez les espaces (ASCII), mais que vous utilisiez des tabulations et des nouvelles lignes, mais je suppose que cela prend toutes sortes de choses.

zmv résout un grand nombre de problèmes de changement de nom de fichier de manière concise (et de manière légèrement obscure). Cependant, il insiste sur le fait que les cibles sont uniques; Bien que vous puissiez facilement ajouter des suffixes uniques, ajouter un suffixe uniquement si cela est nécessaire nécessite pratiquement de refaire tout le travail. Donc, au lieu de cela, je boucle manuellement et je fais confiance à GNU mv pour ajouter un identifiant unique en cas de collision ( --backupoption, plus --no-target-directorysi la cible est un répertoire existant, sinon mv, la source serait déplacée à l'intérieur de ce répertoire).

(od)est un qualificatif glob pour trier la sortie avec des répertoires apparaissant après leur contenu (comme dans find -depth). Dinclut les fichiers de points dans le glob. :het :tsont des modificateurs d’histoire similaires à dirnameet basename.

mvse plaint qu'il est appelé à renommer les fichiers eux-mêmes, parce que le glob comprend des noms de fichiers sans espaces. C'est la vie.

Version non-golfée:

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

Bash 116 octets, 16 espaces

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

Je n'ai pas supprimé les erreurs pour gagner quelques octets supplémentaires. Cela n'aura aucune collision.

Si un GNU non posix findpeut être attendu, cela peut être raccourci davantage:

Bash 110 octets, 15 espaces

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

Supprimer des espaces au lieu de les remplacer utilise deux octets de moins:

Bash 108 octets, 15 espaces

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

Remarque: si des tabulations peuvent être utilisées à la place d'espaces, un seul espace est nécessaire (celui de la règle de correspondance pour la substitution à la ligne 2).

Merci à Dennis d'avoir trouvé un bogue sur les guillemets doubles (et d'avoir fourni une solution)

Python 180 octets

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)

seulement 2 espaces si vous utilisez la tabulation pour l'indentation :-)

Si l'ordre des suffixes de fichiers entrés en collision n'a pas besoin de donner la priorité au fichier pré-existant, les opérations suivantes fonctionnent pour moi:

bash / find / mv 84 octets, 16 espaces

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

bash / find / mv 82 octets, 14 espaces

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

Cuddled &&pour économiser deux octets d'espace.

bash / find / mv 60 octets, 11 espaces

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

Supprime la protection contre les erreurs afin que mv obtienne des erreurs sur les fichiers ne disposant pas d'espaces.

Edit: Supprimé les citations de {}comme rappelé par Dennis. Aussi autorisé findà crier sur la portabilité et la dépréciation dans la version la plus courte où mvcrie déjà au sujet de déplacer un fichier sur lui-même.

Edit 2: Ajouté -Tà la mvcommande pour éviter les répertoires imbriqués au lieu de renommer comme indiqué par pqnet. Expansion d'accolade utilisée au coût d'un caractère sur seulement un espace.

NodeJS - 209 octets, 3 espaces blancs

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 octets

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

Bash + Perl rename64

( renameest le script Perl sur Debian et ses dérivés, pas la commande util-linux.)

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

POSIX sh+ GNU find+ GNU mv67 octets ASCII + un espace (littéral)

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

Je ne sais pas si cela convient, mais avec cette séquence d'espaces est élidé pour un seul _- j'aime bien quand même. En fait, toute séquence, à l' exception des espaces de début / fin, est automatiquement tronquée (ce qui est également, je pense, un comportement bénéfique) . Merci à Gilles de l'avoir signalé.

Cela utilise simplement le séparateur de champs interne pour séparer les champs.

C'est assez ... bavard ...

... oh mec. Je savais que la tabulation n'était pas chère, mais je pensais que c'était au moins intelligent. Maintenant je suis juste en retard à la fête ...

PHP, 147 145 octets, 2 1 espace 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);}}}

fonction récursive. Courir avecs(".");

Boucle à travers les globrésultats pour le chemin donné:

• si répertoire, recurse
• remplacer les espaces par un trait de soulignement
• si les chaînes diffèrent
  • pendant que le nouveau nom de fichier est pris, ajoutez un trait de soulignement
  • renommer le fichier / répertoire

Ruby 121

require 'find'

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

Python, 187

165, plus 22 points de pénalité pour les espaces.

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, en utilisant le truc d' Emanuele :

Un seul espace dans celui-ci!

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

(Remplacez les espaces par des tabulations.)

(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) \.

Basé sur la version optimisée de nderscore de la réponse de cPu1 .

Bash 4+ 111 octets

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 caractères

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)

selon @ edc65 comment

Groovy, gérer les collisions, 259 caractères

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 (testé sur zsh) + commandes Linux de base 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