Comment trouver des noms de fichiers doublons (de manière récursive) dans un répertoire donné? BASH

J'ai besoin de trouver tous les noms de fichiers doublons dans un dir arbre. Je ne sais pas, ce que dir de l'arborescence de l'utilisateur donnera un argument de script, donc je ne sais pas la hiérarchie des répertoires. J'ai essayé ceci:

#!/bin/sh
find -type f | while IFS= read vo
do
echo `basename "$vo"`
done

mais c'est pas vraiment ce que je veux. Il ne trouve qu'un seul doublon, puis se termine, même si il y a plus de noms de fichiers doublons, aussi il ne marche pas l'impression d'un chemin complet (imprime uniquement un nom de fichier) et en double comptage. Je voulais faire quelque chose de similaire à cette commande:

find DIRNAME | tr '[A-Z]' '[a-z]' | sort | uniq -c | grep -v " 1 "

mais il doenst travail pour moi, je ne sais pas pourquoi. Même si j'ai des doublons, il imprime rien.
J'utilise Xubuntu 12.04.

OriginalL'auteur yak | 2013-04-29

  1. 12

    Ici est une autre solution de (basé sur la suggestion de @jim-mcnamara) sans awk:

    Solution 1

    #!/bin/sh 
dirname=/path/to/directory
find $dirname -type f | sed 's_.*/__' | sort|  uniq -d| 
while read fileName
do
find $dirname -type f | grep "$fileName"
done

    Cependant, vous devez faire la même recherche à deux reprises. Cela peut devenir très lent si vous avez à la recherche de beaucoup de données. Enregistrement de la "trouver" des résultats dans un fichier temporaire, peut donner un meilleur rendement.

    Solution 2 (avec fichier temporaire)

    #!/bin/sh 
dirname=/path/to/directory
tempfile=myTempfileName
find $dirname -type f  > $tempfile
cat $tempfile | sed 's_.*/__' | sort |  uniq -d| 
while read fileName
do
 grep "$fileName" $tempfile
done
#rm -f tempfile

    Puisque vous ne voulez pas vous écrire un fichier temporaire sur le disque dur, dans certains cas, vous pouvez choisir la méthode qui s'adapte à vos besoins.
    Les deux exemples d'imprimer le chemin d'accès complet du fichier.

    Bonus de question ici: Est-il possible d'enregistrer la totalité de la sortie de la commande rechercher une liste à une variable?

    Vous pouvez utiliser grep -f pour se débarrasser de tout et de simplifier un peu: cat $tempfile | sed 's_.*/__' | sort | uniq -d| grep -f $tempfile
    Petite erreur dans la Solution 1 peut conduire à des faux positifs. Vous feriez mieux d'écrire la dernière recherche: trouver $dirname -type f | grep "^${fileName}$"
    Comment pourrais-je changer la solution 2, de sorte que le premier fichier trouvé n'est pas ajouté au fichier temporaire, uniquement les doublons sont trouvés seconde?
    MacOs : trouver: -printf: inconnu primaire ou de l'exploitant

    OriginalL'auteur psibar

  2. 8
    #!/bin/sh
dirname=/path/to/check
find $dirname -type f | 
while read vo
do
  echo `basename "$vo"`
done | awk '{arr[$0]++; next} END{for (i in arr){if(arr[i]>1){print i}}}
    Est-il possible de le faire sans awk? Merci quand même 🙂
    Vous pouvez le faire avec n'importe quel langage qui prend en charge les tableaux associatifs (ou le hachage est un autre nom) - perl est un exemple. bash 4 support pour les tableaux associatifs.
    Donc, vous dites que seul le bash solution n'est pas possible? Je veux dire, sans sed, awk, perl, python, etc. juste pur bash?
    par ailleurs, cette solution ne vous raconte pas le nom du fichier sans le chemin d'accès où ils sont. Je pensais que c'était une exigence
    ops, merci, vous avez raison. J'ai besoin d'un chemin d'accès complet. La Question est de nouveau ouvert.

    OriginalL'auteur jim mcnamara

  3. 6

    Oui c'est une très vieille question.
    Mais toutes ces boucles et les fichiers temporaires semblent un peu lourd.

    Voici mon 1 ligne de réponse:

    find /PATH/TO/FILES -type f -printf '%p/%f\n' | sort -k2 | uniq -f1 --all-repeated=separate

    Il a ses limites en raison de uniq et sort:

    • pas d'espace blanc (espace, tabulation) de nom de fichier (sera interprétée comme un nouveau champ par uniq et sort)
    • besoins de nom de fichier imprimé en dernier champ délimité par l'espace (uniq ne supporte pas la comparaison 1 champ et est inflexible avec délimiteurs de champ)

    Mais il est assez souple en ce qui concerne sa sortie grâce à find -printf et fonctionne bien pour moi. Aussi semble être ce que @yak essayé de parvenir à l'origine.

    Illustrant certaines des options que vous avez avec cette:

    find  /PATH/TO/FILES -type f -printf 'size: %s bytes, modified at: %t, path: %h/, file name: %f\n' | sort -k15 | uniq -f14 --all-repeated=prepend

    Aussi il y a des options dans sort et uniq pour ignorer la casse (comme le sujet de l'ouvreur destiné à atteindre par la tuyauterie à travers tr). Rechercher à l'aide de man uniq ou man sort.

    /usr/share/fslint/fslint/findsn /path/to/files , Mais j'aime votre one-liner mieux pour sa souplesse.

    OriginalL'auteur trs

  4. 2
    #!/bin/bash

file=`mktemp /tmp/duplicates.XXXXX` || { echo "Error creating tmp file"; exit 1; }
find $1 -type f |sort >  $file
awk -F/ '{print tolower($NF)}' $file |
        uniq -c|
        awk '$1>1 { sub(/^[[:space:]]+[[:digit:]]+[[:space:]]+/,""); print }'| 
        while read line;
                do grep -i "$line" $file;
        done

rm $file

    Et il fonctionne aussi avec les espaces dans les noms de fichiers. Voici un test simple (le premier argument est le répertoire):

    ./duplicates.sh ./test
./test/2/INC 255286
./test/INC 255286

    OriginalL'auteur Elisiano Petrini

  5. 1

    Une commande "find" seulement:

    lst=$( find . -type f )
echo "$lst" | rev | cut -f 1 -d/ | rev | sort -f | uniq -i | while read f; do
   names=$( echo "$lst" | grep -i -- "/$f$" )
   n=$( echo "$names" | wc -l )
   [ $n -gt 1 ] && echo -e "Duplicates found ($n):\n$names"
done

    OriginalL'auteur Fabien Bouleau

  6. 0

    Cette solution a écrit un fichier temporaire dans un répertoire temporaire pour chaque nom de fichier unique trouvés. Dans le fichier temporaire, j'écris le chemin où j'ai d'abord trouvé le nom de fichier unique, afin que je puisse de sortie plus tard. Donc, j'ai créer beaucoup plus de fichiers que d'autres posté des solutions. Mais, c'était quelque chose que je pouvais comprendre.

    Voici le script, nommé fndupe. 

    #!/bin/bash

# Create a temp directory to contain placeholder files.
tmp_dir=`mktemp -d`

# Get paths of files to test from standard input.
while read p; do
  fname=$(basename "$p")
  tmp_path=$tmp_dir/$fname
  if [[ -e $tmp_path ]]; then
    q=`cat "$tmp_path"`
    echo "duplicate: $p"
    echo "    first: $q"
  else
    echo $p > "$tmp_path" 
  fi
done

exit

    Qui suit est un exemple d'utilisation du script.

    $ find . -name '*.tif' | fndupe

    Suivant est un exemple de sortie lorsque le script trouve les noms de fichiers en double.

    duplicate: a/b/extra/gobble.tif
    first: a/b/gobble.tif

    Testé avec Bash version: GNU bash, version 4.1.2(1)-release (x86_64-redhat-linux-gnu)

    OriginalL'auteur Mike Finch

  7. 0

    Voici ma contribution (ce juste des recherches pour un type de fichier spécifique, les fichiers pdf sont dans ce cas) mais il le fait de manière récursive:

    #!/usr/bin/env bash

find . -type f | while read filename; do
    filename=$(basename -- "$filename")
    extension="${filename##*.}"
    if [[ $extension == "pdf" ]]; then
        fileNameCount=`find . -iname "$filename" | wc -l`
        if [[ $fileNameCount -gt 1 ]]; then
            echo "File Name: $filename, count: $fileNameCount"
        fi
    fi
done

    OriginalL'auteur Benjamin Frazier