Comparer le contenu de deux répertoires

J'ai deux répertoires qui devraient contenir les mêmes fichiers et avoir la même structure de répertoires.

Je pense qu'il manque quelque chose dans l'un de ces répertoires.

À l'aide du shell bash, existe-t-il un moyen de comparer mes répertoires et de voir si l'un d'entre eux manque des fichiers présents dans l'autre?

Un bon moyen de faire cette comparaison est d'utiliser findavec md5sum, alors a diff.

Exemple

Utilisez find pour répertorier tous les fichiers du répertoire, puis calculez le hachage md5 pour chaque fichier et dirigez-le trié par nom de fichier vers un fichier:

find /dir1/ -type f -exec md5sum {} + | sort -k 2 > dir1.txt

Effectuez la même procédure dans un autre répertoire:

find /dir2/ -type f -exec md5sum {} + | sort -k 2 > dir2.txt

Comparez ensuite le résultat avec deux fichiers diff:

diff -u dir1.txt dir2.txt

Ou en tant que commande unique utilisant la substitution de processus:

diff <(find /dir1/ -type f -exec md5sum {} + | sort -k 2) <(find /dir2/ -type f -exec md5sum {} + | sort -k 2)

Si vous voulez voir uniquement les modifications:

diff <(find /dir1/ -type f -exec md5sum {} + | sort -k 2 | cut -f1 -d" ") <(find /dir2/ -type f -exec md5sum {} + | sort -k 2 | cut -f1 -d" ")

La commande cut n'imprime que le hachage (premier champ) à comparer par diff. Dans le cas contraire, diff imprimera chaque ligne car les chemins de répertoire diffèrent même lorsque le hachage est identique.

Mais vous ne saurez pas quel fichier a changé ...

Pour cela, vous pouvez essayer quelque chose comme

diff <(find /dir1/ -type f -exec md5sum {} + | sort -k 2 | sed 's/ .*\// /') <(find /dir2/ -type f -exec md5sum {} + | sort -k 2 | sed 's/ .*\// /')

Cette stratégie est très utile lorsque les deux répertoires à comparer ne se trouvent pas sur le même ordinateur et que vous devez vous assurer que les fichiers sont égaux dans les deux répertoires.

Un autre bon moyen de faire le travail est d'utiliser la diffcommande de Git (peut causer des problèmes lorsque les fichiers ont des autorisations différentes -> chaque fichier est alors répertorié dans la sortie):

git diff --no-index dir1/ dir2/

Vous pouvez utiliser la diffcommande comme vous le feriez pour des fichiers:

diff <directory1> <directory2>

Si vous souhaitez également voir les sous-dossiers et les fichiers, vous pouvez utiliser l' -roption suivante:

diff -r <directory1> <directory2>

Grâce à vous n'utilisez pas bash, vous pouvez le faire en utilisant diff avec --briefet --recursive:

$ diff -rq dir1 dir2 
Only in dir2: file2
Only in dir1: file1

Le man diffcomprend les deux options:

-q, --brief
signaler uniquement lorsque les fichiers diffèrent

-r, --recursive
comparez récursivement les sous-répertoires trouvés

Voici une alternative, pour comparer uniquement les noms de fichiers, et non leur contenu:

diff <(cd folder1 && find . | sort) <(cd folder2 && find . | sort)

C'est un moyen facile de lister les fichiers manquants, mais bien sûr, il ne détectera pas les fichiers portant le même nom mais un contenu différent!

(Personnellement, j'utilise mon propre diffdirsscript, mais cela fait partie d'une plus grande bibliothèque .)

Peut-être qu'une option consiste à exécuter rsync deux fois:

rsync -r -n -t -v -O --progress -c -s /dir1/ /dir2/

Avec la ligne précédente, vous obtiendrez des fichiers qui sont dans dir1 et qui sont différents (ou manquants) dans dir2.

rsync -r -n -t -v -O --progress -c -s /dir2/ /dir1/

Même chose pour dir2

#from the rsync --help :
-r, --recursive             recurse into directories
-n, --dry-run               perform a trial run with no changes made
-t, --times                 preserve modification times
-v, --verbose               increase verbosity
    --progress              show progress during transfer
-c, --checksum              skip based on checksum, not mod-time & size
-s, --protect-args          no space-splitting; only wildcard special-chars
-O, --omit-dir-times        omit directories from --times

Vous pouvez supprimer l' -noption permettant de subir les modifications. C'est copier la liste des fichiers dans le deuxième dossier.

Dans ce cas, une bonne option est peut-être d'utiliser -u, pour éviter d'écraser les fichiers les plus récents.

-u, --update                skip files that are newer on the receiver

Un one-liner:

rsync -rtvcsOu -n --progress /dir1/ /dir2/ && rsync -rtvcsOu -n --progress /dir2/ /dir1/

Si vous voulez rendre chaque fichier extensible et pliable, vous pouvez diriger la sortie de diff -rdans Vim.

D'abord, donnons à Vim une règle de pliage:

mkdir -p ~/.vim/ftplugin
echo "set foldexpr=getline(v:lnum)=~'^diff.*'?'>1':1 foldmethod=expr fdc=2" >> ~/.vim/ftplugin/diff.vim

Maintenant juste:

diff -r dir1 dir2 | vim -

Vous pouvez frapper zoet zcpour ouvrir et fermer les plis. Pour sortir de Vim, appuyez sur:q<Enter>

Tâche assez facile à réaliser en python:

python -c 'import os,sys;d1=os.listdir(sys.argv[1]);d2=os.listdir(sys.argv[2]);d1.sort();d2.sort();x="SAME" if d1 == d2 else "DIFF";print x' DIR1 DIR2

Remplacez les valeurs réelles par DIR1et DIR2.

Voici un exemple de parcours:

$ python -c 'import os,sys;d1=os.listdir(sys.argv[1]);d2=os.listdir(sys.argv[2]);d1.sort();d2.sort();x="SAME" if d1 == d2 else "DIFF";print x' Desktop/ Desktop
SAME
$ python -c 'import os,sys;d1=os.listdir(sys.argv[1]);d2=os.listdir(sys.argv[2]);d1.sort();d2.sort();x="SAME" if d1 == d2 else "DIFF";print x' Desktop/ Pictures/
DIFF

Pour la lisibilité, voici un script réel au lieu de one-liner:

#!/usr/bin/env python
import os, sys

d1 = os.listdir(sys.argv[1])
d2 = os.listdir(sys.argv[2])
d1.sort()
d2.sort()

if d1 == d2:
    print("SAME")
else:
    print("DIFF")

Inspiré par la réponse de Sergiy, j'ai écrit mon propre script Python pour comparer deux répertoires.

Contrairement à beaucoup d'autres solutions, il ne compare pas le contenu des fichiers. De plus, il n’entre pas dans les sous-répertoires qui manquent dans l’un des répertoires. La sortie est donc assez concise et le script fonctionne rapidement avec les grands répertoires.

#!/usr/bin/env python3

import os, sys

def compare_dirs(d1: "old directory name", d2: "new directory name"):
    def print_local(a, msg):
        print('DIR ' if a[2] else 'FILE', a[1], msg)
    # ensure validity
    for d in [d1,d2]:
        if not os.path.isdir(d):
            raise ValueError("not a directory: " + d)
    # get relative path
    l1 = [(x,os.path.join(d1,x)) for x in os.listdir(d1)]
    l2 = [(x,os.path.join(d2,x)) for x in os.listdir(d2)]
    # determine type: directory or file?
    l1 = sorted([(x,y,os.path.isdir(y)) for x,y in l1])
    l2 = sorted([(x,y,os.path.isdir(y)) for x,y in l2])
    i1 = i2 = 0
    common_dirs = []
    while i1<len(l1) and i2<len(l2):
        if l1[i1][0] == l2[i2][0]:      # same name
            if l1[i1][2] == l2[i2][2]:  # same type
                if l1[i1][2]:           # remember this folder for recursion
                    common_dirs.append((l1[i1][1], l2[i2][1]))
            else:
                print_local(l1[i1],'type changed')
            i1 += 1
            i2 += 1
        elif l1[i1][0]<l2[i2][0]:
            print_local(l1[i1],'removed')
            i1 += 1
        elif l1[i1][0]>l2[i2][0]:
            print_local(l2[i2],'added')
            i2 += 1
    while i1<len(l1):
        print_local(l1[i1],'removed')
        i1 += 1
    while i2<len(l2):
        print_local(l2[i2],'added')
        i2 += 1
    # compare subfolders recursively
    for sd1,sd2 in common_dirs:
        compare_dirs(sd1, sd2)

if __name__=="__main__":
    compare_dirs(sys.argv[1], sys.argv[2])

Si vous enregistrez dans un fichier nommé compare_dirs.py, vous pouvez l'exécuter avec Python3.x:

python3 compare_dirs.py dir1 dir2

Exemple de sortie:

user@laptop:~$ python3 compare_dirs.py old/ new/
DIR  old/out/flavor-domino removed
DIR  new/out/flavor-maxim2 added
DIR  old/target/vendor/flavor-domino removed
DIR  new/target/vendor/flavor-maxim2 added
FILE old/tmp/.kconfig-flavor_domino removed
FILE new/tmp/.kconfig-flavor_maxim2 added
DIR  new/tools/tools/LiveSuit_For_Linux64 added

PS Si vous avez besoin de comparer la taille des fichiers et les hachages de fichiers pour les modifications éventuelles, j’ai publié un script mis à jour ici: https://gist.github.com/amakukha/f489cbde2afd32817f8e866cf4abe779

J'ajouterai à cette liste une alternative à NodeJs que j'ai écrite il y a quelque temps.

dir-compare

npm install dir-compare -g
dircompare dir1 dir2

Je voudrais suggérer un excellent outil que je viens de découvrir: MELD .

Cela fonctionne correctement et tout ce que vous pouvez faire avec la commande diffsur un système basé sur Linux peut être reproduit avec une belle interface graphique! Prendre plaisir