Comment renommer tous les dossiers et fichiers en minuscules sous Linux?

Je dois renommer une arborescence de dossiers complète de manière récursive afin qu'aucune lettre majuscule n'apparaisse nulle part (c'est du code source C ++, mais cela ne devrait pas avoir d'importance).

Points bonus pour ignorer les fichiers / dossiers de contrôle de version CVS et Subversion. La méthode préférée serait un script shell, car un shell devrait être disponible sur n'importe quelle machine Linux.

Il y avait des arguments valables sur les détails du changement de nom de fichier.

1. Je pense que les fichiers avec les mêmes noms en minuscules devraient être écrasés; c'est le problème de l'utilisateur. Lorsqu'il est extrait sur un système de fichiers ignorant la casse, il écrase également le premier par ce dernier.

2. Je considérerais les caractères AZ et les transformerais en az, tout le reste n'appelle que des problèmes (au moins avec le code source).

3. Le script serait nécessaire pour exécuter une compilation sur un système Linux, donc je pense que les modifications apportées aux fichiers de contrôle de version CVS ou Subversion devraient être omises. Après tout, il ne s'agit que d'un paiement à zéro. Peut-être qu'une «exportation» est plus appropriée.

Une version concise utilisant la "rename"commande:

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

Cela évite les problèmes avec les répertoires renommés avant les fichiers et en essayant de déplacer des fichiers dans des répertoires non existants (par exemple "A/A"vers "a/a").

Ou, une version plus détaillée sans utiliser "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

Ce dernier permet plus de flexibilité avec la commande de déplacement (par exemple, "svn mv").

Plus petit encore j'aime bien:

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

Sur les systèmes de fichiers insensibles à la casse tels que HFS + d' OS X , vous voudrez ajouter l' -findicateur:

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

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

Essayez simplement ce qui suit si vous n'avez pas besoin de vous soucier de l'efficacité.

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

Mec, vous aimez trop compliquer les choses ... Utilisez:

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

La plupart des réponses ci-dessus sont dangereuses, car elles ne traitent pas de noms contenant des caractères impairs. Votre pari le plus sûr pour ce genre de chose est d'utiliser findl' -print0option de, qui terminera les noms de fichiers avec ASCII NUL au lieu de \ n.

Voici un script, qui ne modifie que les fichiers et non les noms de répertoires pour ne pas confondre 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"'

Je l'ai testé, et cela fonctionne avec des noms de fichiers contenant des espaces, toutes sortes de guillemets, etc. Ceci est important car si vous exécutez, en tant que root, l'un de ces autres scripts sur une arborescence qui inclut le fichier créé par

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

... bien devinez quoi ...

Cela fonctionne si vous avez déjà configuré ou configuré la commande de changement de nom (par exemple via l' installation de brew sous Mac):

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

Cela fonctionne sur CentOS / Red Hat Linux ou d'autres distributions sans le renamescript Perl:

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

Source: Renommez tous les noms de fichiers de majuscules à minuscules

(Dans certaines distributions, la renamecommande par défaut provient de util-linux, et c'est un outil différent et incompatible.)

L'approche la plus simple que j'ai trouvée sur Mac OS X était d'utiliser le package de renommage de http://plasmasturm.org/code/rename/ :

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

--force Rename même lorsqu'un fichier avec le nom de destination existe déjà.

--lower-case Convertit les noms de fichiers en minuscules.

--nows Remplace toutes les séquences d'espaces dans le nom de fichier par des caractères de soulignement uniques.

Voici ma solution sous-optimale, en utilisant un 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

Les dossiers sont tous renommés correctement et mvne posent pas de questions lorsque les autorisations ne correspondent pas, et les dossiers CVS ne sont pas renommés (les fichiers de contrôle CVS à l'intérieur de ce dossier sont toujours renommés, malheureusement).

Puisque "find -depth" et "find | sort -r" renvoient tous deux la liste des dossiers dans un ordre utilisable pour le renommer, j'ai préféré utiliser "-depth" pour rechercher des dossiers.

La question d'origine demandait d'ignorer les répertoires SVN et CVS, ce qui peut être fait en ajoutant -prune à la commande find. Par exemple pour ignorer CVS:

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

[modifier] J'ai essayé cela, et intégrer la traduction en minuscules dans la recherche n'a pas fonctionné pour des raisons que je ne comprends pas vraiment. Alors, modifiez ceci pour:

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

Ian

Utilisation du fixateur de nom de fichier 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 $_;
}

C'est aussi simple que

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

(où fixest bien sûr le script ci-dessus)

Ceci est un petit script shell qui fait ce que vous avez demandé:

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

Notez l'action -depth dans la première recherche.

Pas portable, Zsh seulement, mais assez concis.

Tout d'abord, assurez-vous qu'il zmvest chargé.

autoload -U zmv

Assurez extendedglob- vous également qu'il est activé:

setopt extendedglob

Puis utilisez:

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

Pour récursivement des fichiers et des répertoires en minuscules dont le nom n'est pas CVS .

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

find -depthimprime chaque fichier et répertoire, avec le contenu d'un répertoire imprimé avant le répertoire lui-même. ${f,,}minuscule le nom du fichier.

Avec MacOS,

Installez le renamepackage,

brew install rename

Utilisation,

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

Cette commande trouve tous les fichiers avec une *.pyextension et convertit les noms de fichiers en minuscules.

`f` - forces a rename

Par exemple,

$ 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

Utilisez le type :

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

Sous Windows, les émulations, comme Git Bash , peuvent échouer car Windows n'est pas sensible à la casse sous le capot. Pour ceux-ci, ajoutez d'abord une étape qui mvest le fichier à un autre nom, comme "$ old.tmp", puis à $new.

Long mais "fonctionne sans surprise ni installation"

Ce script gère les noms de fichiers avec des espaces, des guillemets, d'autres caractères inhabituels et Unicode, fonctionne sur les systèmes de fichiers insensibles à la casse et la plupart des environnements Unix-y sur lesquels bash et awk sont installés (c'est-à-dire presque tous). Il signale également les collisions le cas échéant (en laissant le nom de fichier en majuscules) et renomme bien sûr les fichiers et les répertoires et fonctionne de manière récursive. Enfin, il est hautement adaptable: vous pouvez modifier la commande find pour cibler les fichiers / répertoires que vous souhaitez et vous pouvez modifier awk pour faire d'autres manipulations de nom. Notez que par "gère Unicode" je veux dire qu'il va effectivement convertir leur cas (ne pas les ignorer comme les réponses qui l'utilisent 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 {} +

Références

Mon script est basé sur ces excellentes réponses:

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

Comment convertir une chaîne en minuscules dans Bash?

Cela fonctionne aussi bien sur macOS:

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

J'avais besoin de le faire sur une configuration Cygwin sur Windows 7 et j'ai trouvé que j'avais des erreurs de syntaxe avec les suggestions ci-dessus que j'ai essayées (même si j'ai peut-être manqué une option de travail). Cependant, cette solution directement à partir des forums Ubuntu a fonctionné hors de la boîte :-)

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

(NB: j'avais précédemment remplacé les espaces par des traits de soulignement en utilisant:

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

)

Sous OS X, mv -faffiche l'erreur «même fichier», donc je renomme deux fois:

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

Je voudrais utiliser Python dans cette situation, pour éviter de supposer de manière optimiste des chemins sans espaces ni barres obliques. J'ai également constaté que cela a python2tendance à être installé dans plus d'endroits 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])

Si vous utilisez Arch Linux , vous pouvez installer rename) package à partir de AURqui fournit la renamexmcommande en tant /usr/bin/renamexmqu'exécutable et une page de manuel avec elle.

C'est un outil vraiment puissant pour renommer rapidement des fichiers et des répertoires.

Convertir en minuscules

rename -l Developers.mp3 # or --lowcase

Convertir en cas supérieur

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

Autres options

-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

Vous pouvez récupérer l'exemple de fichier Developers.mp3 à partir d' ici , si nécessaire;)

( 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

Renommez d'abord les répertoires de bas en haut sort -r (où -depth n'est pas disponible), puis les fichiers. Ensuite, grep -v / CVS au lieu de find ...- élague parce que c'est plus simple. Pour les grands répertoires, for f in ... peut déborder de certains tampons du shell. Utilisez find ... | tout en lisant pour éviter cela.

Et oui, cela écrasera les fichiers qui ne diffèrent que dans le cas où ...

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

Je n'ai pas essayé les scripts plus élaborés mentionnés ici, mais aucune des versions de ligne de commande n'a fonctionné pour moi sur mon Synology NAS. renamen'est pas disponible, et de nombreuses variantes findéchouent car il semble s'en tenir à l'ancien nom du chemin déjà renommé (par exemple, s'il trouve ./FOOsuivi de ./FOO/BAR, renommer ./FOOen ./foocontinuera à être répertorié ./FOO/BARmême si ce chemin n'est plus valide) . La commande ci-dessus a fonctionné pour moi sans aucun problème.

Ce qui suit est une explication de chaque partie de la commande:

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

Cela trouvera n'importe quel fichier du répertoire courant (changez .pour le répertoire que vous voulez traiter), en utilisant une recherche en profondeur d'abord (par exemple, il listera ./foo/baravant ./foo), mais seulement pour les fichiers qui contiennent un caractère majuscule. Le -namefiltre s'applique uniquement au nom du fichier de base, pas au chemin complet. Donc, cela listera ./FOO/BARmais pas ./FOO/bar. C'est correct, car nous ne voulons pas renommer ./FOO/bar. Nous voulons cependant renommer ./FOO, mais celui-ci est répertorié plus tard (c'est pourquoi il -depthest important).

Cette commande en elle-même est particulièrement utile pour trouver les fichiers que vous souhaitez renommer en premier lieu. Utilisez-le après la commande de changement de nom complète pour rechercher des fichiers qui n'ont toujours pas été remplacés en raison de collisions de noms de fichiers ou d'erreurs.

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

Cette partie lit les fichiers produits par findet les formate dans une mvcommande à l'aide d'une expression régulière. L' -noption arrête sedd'imprimer l'entrée et la pcommande de l'expression régulière de recherche et de remplacement génère le texte remplacé.

Le regex lui-même se compose de deux captures: la partie jusqu'au dernier / (qui est le répertoire du fichier), et le nom du fichier lui-même. Le répertoire est laissé intact, mais le nom de fichier est transformé en minuscules. Donc, si les findsorties ./FOO/BAR, il deviendra mv -n -v -T ./FOO/BAR ./FOO/bar. L' -noption de mvgarantit que les fichiers minuscules existants ne sont pas écrasés. L' -voption rend mvsortie chaque changement qu'elle fait (ou ne fait pas - si elle ./FOO/barexiste déjà, elle produit quelque chose comme ./FOO/BAR -> ./FOO/BAR, en notant qu'aucun changement n'a été effectué). Le -Test très important ici - il traite le fichier cible comme un répertoire. Cela garantira que ce répertoire ./FOO/BARn'est pas déplacé ./FOO/barsi ce répertoire existe.

Utilisez-le avec findpour générer une liste de commandes qui seront exécutées (pratique pour vérifier ce qui sera fait sans le faire réellement)

sh

C'est assez explicite. Il achemine toutes les mvcommandes générées vers l'interpréteur shell. Vous pouvez le remplacer par bashou n'importe quelle coque de votre choix.

Renommer Slugify (regex)

Ce n'est pas exactement ce que l'OP a demandé, mais ce que j'espérais trouver sur cette page:

Une version "slugify" pour renommer les fichiers afin qu'ils soient similaires aux URL (c'est-à-dire n'incluent que des caractères alphanumériques, des points et des tirets):

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