Come rinominare tutte le cartelle e i file in minuscolo su Linux?

Devo rinominare un albero di cartelle completo in modo ricorsivo in modo che nessuna lettera maiuscola appaia ovunque (è il codice sorgente C ++, ma non dovrebbe importare).

Punti bonus per ignorare i file / le cartelle di controllo versione CVS e Subversion. Il modo preferito sarebbe uno script di shell, poiché una shell dovrebbe essere disponibile su qualsiasi box Linux.

Vi erano alcuni argomenti validi sui dettagli della ridenominazione del file.

1. Penso che i file con gli stessi nomi minuscoli debbano essere sovrascritti; è il problema dell'utente. Se estratto su un file system che ignora i casi, sovrascriverà anche il primo con quest'ultimo.

2. Considererei i personaggi AZ e li trasformerei in az, tutto il resto richiede solo problemi (almeno con il codice sorgente).

3. Lo script sarebbe necessario per eseguire una build su un sistema Linux, quindi penso che le modifiche ai file di controllo versione CVS o Subversion debbano essere omesse. Dopotutto, è solo un checkout. Forse un "esportazione" è più appropriato.

Una versione sintetica usando il "rename"comando:

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

Questo consente di evitare problemi con le directory di essere rinominato prima dei file e cercando di spostare i file in directory non-esistenti (ad esempio "A/A"in "a/a").

Oppure, una versione più dettagliata senza usare "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

Quest'ultimo consente una maggiore flessibilità con il comando sposta (ad esempio, "svn mv").

Ancora più piccolo mi piace abbastanza:

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

Su filesystem senza distinzione tra maiuscole e minuscole come HFS + di OS X , ti consigliamo di aggiungere il -fflag:

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

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

Prova semplicemente quanto segue se non hai bisogno di preoccuparti dell'efficienza.

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

Amico, ragazzi / ragazze, volete complicare troppo le cose ...

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

La maggior parte delle risposte di cui sopra sono pericolose, perché non trattano nomi che contengono caratteri dispari. La tua scommessa più sicura per questo tipo di cose è usare findl' -print0opzione, che terminerà i nomi dei file con ASCII NUL anziché \ n.

Ecco uno script, che altera solo i file e non i nomi delle directory per non confondere 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"'

L'ho provato e funziona con nomi di file contenenti spazi, tutti i tipi di virgolette, ecc. Questo è importante perché se si esegue, come root, uno di quegli altri script su un albero che include il file creato da

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

... indovina un po '...

Funziona se hai già o impostato il comando rename (ad es. Tramite brew install in Mac):

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

Funziona su CentOS / Red Hat Linux o altre distribuzioni senza lo renamescript Perl:

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

Fonte: rinominare tutti i nomi di file da caratteri maiuscoli a minuscoli

(In alcune distribuzioni il renamecomando predefinito proviene da util-linux, e questo è uno strumento diverso e incompatibile.)

L'approccio più semplice che ho trovato su Mac OS X è stato quello di utilizzare il pacchetto di rinomina da http://plasmasturm.org/code/rename/ :

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

--force Rinomina anche quando esiste già un file con il nome della destinazione.

--lower-case Converte i nomi dei file in tutte le lettere minuscole.

--nows Sostituisce tutte le sequenze di spazi bianchi nel nome file con singoli caratteri di sottolineatura.

Ecco la mia soluzione non ottimale, usando uno script 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

Le cartelle sono tutte rinominate correttamente e mvnon fanno domande quando le autorizzazioni non corrispondono e le cartelle CVS non vengono rinominate (purtroppo i file di controllo CVS all'interno di quella cartella vengono ancora rinominati).

Poiché "find -depth" e "find | sort -r" restituiscono entrambi l'elenco delle cartelle in un ordine utilizzabile per rinominare, ho preferito usare "-depth" per cercare le cartelle.

La domanda originale chiedeva di ignorare le directory SVN e CVS, cosa che può essere fatta aggiungendo -prune al comando find. Ad esempio per ignorare CVS:

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

[modifica] L'ho provato e l'incorporamento della traduzione minuscola all'interno della ricerca non ha funzionato per motivi che in realtà non capisco. Quindi, modifica questo per:

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

Ian

Utilizzando il fissatore di nomi di file di Larry Wall:

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

È semplice come

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

(dov'è fixovviamente lo script sopra)

Questo è un piccolo script shell che fa quello che hai richiesto:

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

Nota l'azione -depth nella prima ricerca.

Non portatile, solo Zsh, ma piuttosto conciso.

Innanzitutto, assicurati che zmvsia caricato.

autoload -U zmv

Inoltre, assicurati che extendedglobsia attivo:

setopt extendedglob

Quindi utilizzare:

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

Per ricorrere in modo minuscolo ai file e alle directory in cui il nome non è CVS .

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

find -depthstampa ogni file e directory, con i contenuti di una directory stampati prima della directory stessa. ${f,,}minuscolo il nome del file.

Con MacOS,

Installa il renamepacchetto,

brew install rename

Uso,

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

Questo comando trova tutti i file con *.pyestensione e converte i nomi dei file in lettere minuscole.

`f` - forces a rename

Per esempio,

$ 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

Usa il set :

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

Su Windows, le emulazioni, come Git Bash , potrebbero non riuscire perché Windows non è sensibile al maiuscolo / minuscolo. Per quelli, aggiungi prima un passaggio che mvè il file ad un altro nome, come "$ old.tmp", e poi a $new.

Lungo ma "Funziona senza sorprese e senza installazioni"

Questo script gestisce nomi di file con spazi, virgolette, altri caratteri insoliti e Unicode, funziona con filesystem insensibili alle maiuscole e minuscole e con la maggior parte degli ambienti Unix-y su cui è installato bash e awk (ovvero quasi tutti). Segnala anche eventuali collisioni (lasciando il nome del file in maiuscolo) e ovviamente rinomina sia i file che le directory e funziona in modo ricorsivo. Infine è altamente adattabile: puoi modificare il comando find per scegliere come target i file / le directory che desideri e puoi modificare awk per fare altre manipolazioni del nome. Nota che per "gestisce Unicode" intendo che convertirà effettivamente il loro caso (non ignorarli come le risposte che usano 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 {} +

Riferimenti

La mia sceneggiatura si basa su queste eccellenti risposte:

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

Come convertire una stringa in minuscolo in Bash?

Funziona bene anche su macOS:

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

Avevo bisogno di farlo su una configurazione Cygwin su Windows 7 e ho scoperto di avere errori di sintassi con i suggerimenti di cui sopra che ho provato (anche se potrei aver perso un'opzione funzionante). Tuttavia, questa soluzione direttamente dai forum di Ubuntu ha funzionato senza problemi :-)

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

(NB: in precedenza avevo sostituito gli spazi bianchi con caratteri di sottolineatura usando:

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

)

In OS X, mv -fmostra l'errore "stesso file", quindi rinominerò due volte:

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

Vorrei raggiungere Python in questa situazione, per evitare di assumere in modo ottimistico percorsi senza spazi o barre. Ho anche scoperto che python2tende ad essere installato in più luoghi di 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 si utilizza Arch Linux , è possibile installare rename) un pacchetto AURche fornisce il renamexmcomando come /usr/bin/renamexmeseguibile e una pagina di manuale con esso.

È uno strumento davvero potente per rinominare rapidamente file e directory.

Converti in minuscolo

rename -l Developers.mp3 # or --lowcase

Converti in custodia UPPER

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

Altre opzioni

-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

Puoi recuperare il file Developers.mp3 di esempio da qui , se necessario;)

( 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

Prima rinominare le directory dal basso verso l'alto sort -r (dove -depth non è disponibile), quindi i file. Quindi grep -v / CVS invece di trovare ...- pota perché è più semplice. Per le directory di grandi dimensioni, per f in ... può overflow alcuni buffer della shell. Usa trova ... | mentre leggi per evitarlo.

E sì, questo bloccherà i file che differiscono solo nel caso ...

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

Non ho provato gli script più elaborati menzionati qui, ma nessuna delle singole versioni a riga di comando ha funzionato per me sul mio Synology NAS. renamenon è disponibile e molte delle varianti di findfail perché sembrano aderire al nome precedente del percorso già rinominato (ad esempio, se trova ./FOOseguito da ./FOO/BAR, la ridenominazione ./FOOin ./foocontinuerà comunque a elencare./FOO/BAR , anche se quel percorso non è più valida è) . Il comando sopra ha funzionato per me senza problemi.

Quella che segue è una spiegazione di ogni parte del comando:

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

Questo troverà qualsiasi file dalla directory corrente ( .passa alla directory che vuoi elaborare), usando una ricerca approfondita (ad es., Elencherà ./foo/barprima ./foo), ma solo per i file che contengono un carattere maiuscolo. Il -namefiltro si applica solo al nome del file di base, non al percorso completo. Quindi questo elencherà ./FOO/BARma non ./FOO/bar. Va bene, non vogliamo rinominare ./FOO/bar. Vogliamo rinominare ./FOOperò, ma quello è elencato più avanti (ecco perché -depthè importante).

Questo comando in sé è particolarmente utile per trovare i file che si desidera rinominare in primo luogo. Utilizzare questo dopo il comando di ridenominazione completo per cercare file che non sono stati ancora sostituiti a causa di collisioni o errori di nomi di file.

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

Questa parte legge i file generati da finde li formatta in un mvcomando usando un'espressione regolare. L' -nopzione interrompe la sedstampa dell'input e il pcomando nel regex cerca e sostituisci restituisce il testo sostituito.

La regex stessa consiste di due acquisizioni: la parte fino all'ultima / (che è la directory del file) e il nome stesso. La directory viene lasciata intatta, ma il nome file viene trasformato in minuscolo. Quindi, se finduscite ./FOO/BAR, diventerà mv -n -v -T ./FOO/BAR ./FOO/bar. L' -nopzione mvassicura che i file minuscoli esistenti non vengano sovrascritti. L' -vopzione apporta in mvoutput tutte le modifiche apportate (o non effettua - se ./FOO/bargià esiste, genera qualcosa di simile ./FOO/BAR -> ./FOO/BAR, rilevando che non è stata apportata alcuna modifica). Il -Tè molto importante - si tratta di file di destinazione come una directory. Questo farà in modo che ./FOO/BARnon venga spostato ./FOO/barse esiste quella directory.

Usalo insieme a findper generare un elenco di comandi che verranno eseguiti (utile per verificare cosa verrà fatto senza farlo effettivamente)

sh

Questo piuttosto autoesplicativo. Instrada tutti i mvcomandi generati all'interprete della shell. Puoi sostituirlo con basho con qualsiasi shell di tuo gradimento.

Slugify Rename (regex)

Non è esattamente quello che l'OP ha richiesto, ma quello che speravo di trovare in questa pagina:

Una versione "slugify" per rinominare i file in modo che siano simili agli URL (ovvero includono solo caratteri alfanumerici, punti e trattini):

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