Trouver les fichiers existant dans un répertoire mais pas dans l'autre [fermé]

J'essaie de trouver les fichiers existants dans un répertoire mais pas dans l'autre, j'ai essayé d'utiliser cette commande:

diff -q dir1 dir2

Le problème avec la commande ci-dessus qui trouve les fichiers dans dir1mais pas dans dir2ainsi que les fichiers dans dir2mais pas dans dir1,

J'essaie de trouver les fichiers dir1mais pas dir2seulement.

Voici un petit échantillon de ce à quoi mes données ressemblent

dir1    dir2    dir3
1.txt   1.txt   1.txt
2.txt   3.txt   3.txt
5.txt   4.txt   5.txt
6.txt   7.txt   8.txt

Une autre question me vient à l'esprit: comment puis-je trouver les fichiers dans dir1mais pas dans dir2ou dir3dans une seule commande?

diff -r dir1 dir2 | grep dir1 | awk '{print $4}' > difference1.txt

Explication:

• diff -r dir1 dir2 montre quels fichiers sont uniquement dans dir1 et ceux uniquement dans dir2 et aussi les changements des fichiers présents dans les deux répertoires le cas échéant.

• diff -r dir1 dir2 | grep dir1 montre quels fichiers sont uniquement en dir1

• awk pour imprimer uniquement le nom de fichier.

Cela devrait faire le travail:

diff -rq dir1 dir2

Options expliquées (via la page de manuel diff (1) ):

• -r - Comparez récursivement tous les sous-répertoires trouvés.
• -q - Afficher uniquement si les fichiers diffèrent.

comm -23 <(ls dir1 |sort) <(ls dir2|sort)

Cette commande vous donnera des fichiers qui sont en dir1 et non en dir2.

À propos de <( )signe, vous pouvez le rechercher sur Google en tant que «substitution de processus».

Une bonne façon de faire cette comparaison consiste à utiliser findavec md5sum, puis undiff .

Exemple:

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

find /dir1/ -type f -exec md5sum {} \; > dir1.txt

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

find /dir2/ -type f -exec md5sum {} \; > dir2.txt

Ensuite, comparez le résultat deux fichiers avec "diff":

diff dir1.txt dir2.txt

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

Une autre bonne façon de faire le travail est d'utiliser git

git diff --no-index dir1/ dir2/

Meilleures salutations!

Meld ( http://meldmerge.org/ ) fait un excellent travail pour comparer les répertoires et les fichiers qu'il contient.

Le plugin DirDiff de vim est un autre outil très utile pour comparer les répertoires.

vim -c "DirDiff dir1 dir2"

Il répertorie non seulement les fichiers qui sont différents entre les répertoires, mais vous permet également d'inspecter / modifier avec vimdiff les fichiers qui sont différents.

Insatisfait de toutes les réponses, car la plupart d'entre elles fonctionnent très lentement et produisent une sortie inutilement longue pour les grands répertoires, j'ai écrit mon propre script Python pour comparer deux dossiers.

Contrairement à de nombreuses autres solutions, il ne compare pas le contenu des fichiers. De plus, il ne va pas dans les sous-répertoires qui manquent dans un autre répertoire. La sortie est donc assez concise et le script fonctionne rapidement.

#!/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])

Exemple d'utilisation:

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

Ou si vous souhaitez voir uniquement les fichiers du premier répertoire:

user@laptop:~$ python3 compare_dirs.py dir2/ dir1/ | grep dir1
DIR  dir1/out/flavor-domino added
DIR  dir1/target/vendor/flavor-domino added
FILE dir1/tmp/.kconfig-flavor_domino added

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

Une autre approche (peut-être plus rapide pour les grands répertoires):

$ find dir1 | sed 's,^[^/]*/,,' | sort > dir1.txt && find dir2 | sed 's,^[^/]*/,,' | sort > dir2.txt
$ diff dir1.txt dir2.txt

La sedcommande supprime le premier composant du répertoire grâce à la publication d'Erik )

C'est un peu tard mais ça peut aider quelqu'un. Je ne sais pas si diff ou rsync crachent uniquement des noms de fichiers dans un format nu comme celui-ci. Merci à plhn d'avoir donné cette belle solution que j'ai développée ci-dessous.

Si vous ne voulez que les noms de fichiers, il est donc facile de copier simplement les fichiers dont vous avez besoin dans un format propre, vous pouvez utiliser la commande find.

comm -23 <(find dir1 | sed 's/dir1/\//'| sort) <(find dir2 | sed 's/dir2/\//'| sort) | sed 's/^\//dir1/'

Cela suppose que dir1 et dir2 se trouvent dans le même dossier parent. sed supprime simplement le dossier parent afin que vous puissiez comparer les pommes avec les pommes. Le dernier sed remet juste le nom dir1.

Si vous voulez juste des fichiers:

comm -23 <(find dir1 -type f | sed 's/dir1/\//'| sort) <(find dir2 -type f | sed 's/dir2/\//'| sort) | sed 's/^\//dir1/'

De même pour les répertoires:

comm -23 <(find dir1 -type d | sed 's/dir1/\//'| sort) <(find dir2 -type d | sed 's/dir2/\//'| sort) | sed 's/^\//dir1/'

La réponse acceptée répertorie également les fichiers qui existent dans les deux répertoires, mais dont le contenu est différent. Pour répertorier UNIQUEMENT les fichiers qui existent dans dir1, vous pouvez utiliser:

diff -r dir1 dir2 | grep 'Only in' | grep dir1 | awk '{print $4}' > difference1.txt

Explication:

• diff -r dir1 dir2: comparer
• grep 'Only in': récupère les lignes qui contiennent 'Only in'
• grep dir1: récupère les lignes qui contiennent dir

Cette réponse optimise l'une des suggestions de @ Adail-Junior en ajoutant l' -Doption, qui est utile lorsqu'aucun des répertoires comparés n'est un référentiel git:

git diff -D --no-index dir1/ dir2/

Si vous utilisez, -Dvous ne verrez pas de comparaisons avec /dev/null: text Binary files a/whatever and /dev/null differ

Une façon simplifiée de comparer 2 répertoires à l'aide de la commande DIFF

diff filename.1 filename.2> filename.dat >> Entrée

ouvrir filename.dat une fois l'exécution terminée

et vous verrez: Uniquement dans filename.1: filename.2 Uniquement dans: directory_name: name_of_file1 Uniquement dans: directory_Name: name_of_file2

Ceci est le script bash pour imprimer les commandes de synchronisation de deux répertoires

dir1=/tmp/path_to_dir1
dir2=/tmp/path_to_dir2
diff -rq $dir1 $dir2 | sed -e "s|Only in $dir2\(.*\): \(.*\)|cp -r $dir2\1/\2 $dir1\1|" |  sed -e "s|Only in $dir1\(.*\): \(.*\)|cp -r $dir1\1/\2 $dir2\1|" 

GNU greppeut inverser la recherche avec l'option -v. Cela rend le grepsignalement des lignes qui ne correspondent pas. Par cela, vous pouvez supprimer les fichiers dir2de la liste des fichiers dir1.

grep -v -F -x -f <(find dir2 -type f -printf '%P\n') <(find dir1 -type f -printf '%P\n')

Les options -F -xindiquent grepd'effectuer une recherche de chaîne sur toute la ligne.