Es ist einfach. Ich kann es nicht ausstehen, wenn Leute Leerzeichen beim Benennen von Dateien verwenden. Es zerstört manchmal Konsolenbefehle und macht die Ausgabe von ls hässlich.

Die Herausforderung besteht darin, ein Programm (nur ASCII-Zeichen) zu schreiben, das

1. Benennt alle Dateien (einschließlich der Verzeichnisse) im aktuellen Verzeichnis in Versionen um, bei denen Leerzeichen entfernt oder durch "_" ersetzt wurden.
2. Bei einer Kollision müssen Sie eine eindeutige Kennung anhängen (ganz nach Ihren Wünschen).
3. rekursiv in alle Unterverzeichnisse absteigend

Sie können Pfadnamen im UNIX-Stil annehmen. Wer würde dieses Programm auf einem Windows-Computer benötigen?

Dies ist Codegolf, das kürzeste Programm gewinnt (#ascii Zeichen). Da ich Räume so sehr hasse, muss jeder Raum zweimal gezählt werden.

Bitte geben Sie Ihre Sprache, Partitur, Programm und eine kurze Beschreibung der Ausführung an.

Das Programm muss mit vertretbarem Aufwand auf meinem Linux-Rechner kompiliert und ausgeführt werden.

BEARBEITEN: Da Etan zum Testen eine Dateistruktur angefordert hat, verwende ich das folgende Skript, um einen geeigneten Dateibaum zu erstellen:

#!/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 Bytes (1 Leerzeichen)

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

Es ist seltsam, dass Sie (ASCII-) Leerzeichen hassen, aber Tabulatoren und Zeilenumbrüche in Ordnung sind, aber ich denke, es sind alle Arten von Leerzeichen erforderlich.

zmv löst viele Probleme beim Umbenennen von Dateien in Kürze (und nur geringfügig undeutlich). Es besteht jedoch darauf, dass die Ziele eindeutig sind. Sie können zwar problemlos eindeutige Suffixe hinzufügen, das Hinzufügen eines Suffixes ist jedoch nur dann erforderlich, wenn die gesamte Arbeit wiederholt werden muss. Stattdessen schleife ich manuell und verlasse mich bei Kollisionen auf GNU mv , um einen eindeutigen Bezeichner anzufügen ( --backupOption, plus, --no-target-directorywenn ein Ziel ein vorhandenes Verzeichnis ist, da sonst mvdie Quelle in dieses Verzeichnis verschoben würde).

(od)ist ein Glob-Qualifikationsmerkmal zum Sortieren der Ausgabe nach Verzeichnissen, die nach ihrem Inhalt angezeigt werden (wie bei Suchen -depth). DEnthält Punktdateien im Glob. :hund :tsind History-Modifikatoren ähnlich wie dirnameund basename.

mvbeschwert sich, dass es aufgerufen wird, um Dateien in sich selbst umzubenennen, da der Glob Dateinamen ohne Leerzeichen enthält. So ist das Leben.

Ungolfed-Version:

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

Bash 116 Bytes, 16 Leerzeichen

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

Ich habe Fehler nicht unterdrückt, um ein paar Bytes mehr zu gewinnen. Dies wird keine Kollisionen haben.

Wenn nicht posix GNU finderwartet werden kann, kann dies weiter verkürzt werden:

Bash 110 Bytes, 15 Leerzeichen

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

Das Entfernen statt Ersetzen von Leerzeichen benötigt zwei Bytes weniger:

Bash 108 Bytes, 15 Leerzeichen

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

Hinweis: Wenn Tabulatoren anstelle von Leerzeichen verwendet werden können, wird nur 1 Leerzeichen benötigt (das in der Übereinstimmungsregel für die Ersetzung in Zeile 2).

Vielen Dank an Dennis für das Auffinden des Fehlers in Anführungszeichen (und die Bereitstellung der Lösung)

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)

nur 2 Leerzeichen, wenn Sie die Tabulatortaste zum Einrücken verwenden :-)

Wenn die Reihenfolge der kollidierten Dateisuffixe der bereits vorhandenen Datei keinen Präzedenzfall geben muss, funktioniert für mich Folgendes:

bash / find / mv 84 Bytes, 16 Leerzeichen

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

bash / find / mv 82 Bytes, 14 Leerzeichen

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

Gekuschelt &&, um zwei Platzbytes zu sparen.

bash / find / mv 60 Bytes, 11 Leerzeichen

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

Lässt den Fehlerschutz fallen, sodass er Fehler von mv für Dateien erhält, die anfangs keine Leerzeichen enthalten.

Bearbeiten: Löschte die Anführungszeichen aus, {}wie von Dennis erinnert. Auch darf findüber Portabilität und Verfall in der kürzesten Version geschrien werden, wo mvschon über das Verschieben einer Datei auf sich geschrien wird.

Bearbeiten 2: -TZum mvBefehl hinzugefügt , um das Verschachteln von Verzeichnissen zu vermeiden, anstatt sie umzubenennen, wie von pqnet hervorgehoben. Verwendete Klammererweiterung zum Preis von einem Zeichen über nur ein Leerzeichen.

NodeJS - 209 Bytes, 3 Whitespaces

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

( renameIst das Perl-Skript auf Debian und Derivaten, nicht der Befehl util-linux.)

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

POSIX sh+ GNU find+ GNU mv67 ASCII-Bytes + ein (Literal-) Leerzeichen

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

Ich weiß nicht, ob es passt, aber damit wird jede Abfolge von Leerzeichen zu einem einzigen _- ich mag es trotzdem. Eigentlich jede Sequenz, außer führende / nachfolgende Leerzeichen - diese werden automatisch abgeschnitten (was auch, wie ich finde, ein nützliches Verhalten ist) . Vielen Dank an Gilles für diesen Hinweis.

Hierbei wird nur das interne Feldtrennzeichen zum Trennen von Feldern verwendet.

Es ist ziemlich ... gesprächig ...

...Oh Mann. Ich wusste, dass das Tab-Ding billig war, aber ich fand es zumindest klug. Jetzt bin ich nur zu spät zur Party ...

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

rekursive Funktion. Laufen Sie mits(".");

globErgebnisse für den angegebenen Pfad durchlaufen :

• Wenn Verzeichnis, rekursiv
• Ersetzen Sie Leerzeichen durch Unterstriche
• Wenn die Zeichenfolgen unterschiedlich sind
  • Fügen Sie einen Unterstrich hinzu, während der neue Dateiname verwendet wird
  • Datei / Verzeichnis umbenennen

Rubin 121

require 'find'

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

Python, 187

165, plus 22 Strafpunkte für die Räume.

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, mit Emanueles \ t Trick:

Nur ein einziger Platz in diesem!

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

(Ersetzen Sie Leerzeichen durch Tabulatoren.)

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

Basierend auf nderscore die optimierte Version der CPU1 ‚s Antwort .

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 Zeichen

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)

laut @ edc65 Kommentar

Groovig, mit Kollisionen umgehen, 259 Zeichen

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 (Getestet auf zsh) + grundlegende Linux-Befehle 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