Znajdź pliki istniejące w jednym katalogu, ale nie w drugim [zamknięte]

Próbuję znaleźć pliki istniejące w jednym katalogu, ale nie w drugim, próbowałem użyć tego polecenia:

diff -q dir1 dir2

Problem z powyższym poleceniem polegającym na tym, że znajduje on zarówno pliki w, dir1ale nie w, dir2jak również pliki w, dir2ale nie w dir1,

Próbuję znaleźć pliki, dir1ale nie dir2tylko.

Oto mała próbka tego, jak wyglądają moje dane

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

Kolejne pytanie, jakie mam na myśli, to w jaki sposób mogę znaleźć pliki w jednym poleceniu, dir1ale nie w nim dir2lub dir3w jednym poleceniu?

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

Wyjaśnienie:

• diff -r dir1 dir2 pokazuje, które pliki są tylko w katalogu 1, a tylko w katalogu 2, a także zmiany plików obecnych w obu katalogach, jeśli takie istnieją.

• diff -r dir1 dir2 | grep dir1 pokazuje, które pliki znajdują się tylko w katalogu 1

• awk aby wydrukować tylko nazwę pliku.

To powinno wykonać zadanie:

diff -rq dir1 dir2

Opcje wyjaśnione (przez diff (1) strony man ):

• -r - Rekurencyjnie porównaj wszystkie znalezione podkatalogi.
• -q - Wyprowadzaj tylko, czy pliki się różnią.

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

To polecenie da ci pliki, które znajdują się w katalogu 1, a nie w katalogu 2.

O <( )znaku możesz google jako „proces podstawienia”.

Dobrym sposobem na dokonanie tego porównania jest użycie findz md5sum, a następnie a diff.

Przykład:

Użyj, findaby wyświetlić listę wszystkich plików w katalogu, a następnie obliczyć skrót md5 dla każdego pliku i potokować go do pliku:

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

Wykonaj tę samą procedurę w innym katalogu:

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

Następnie porównaj wynik dwóch plików z „diff”:

diff dir1.txt dir2.txt

Ta strategia jest bardzo przydatna, gdy dwa katalogi, które mają być porównywane, nie znajdują się na tej samej maszynie i musisz upewnić się, że pliki są równe w obu katalogach.

Innym dobrym sposobem na wykonanie tej pracy jest użycie git

git diff --no-index dir1/ dir2/

Z poważaniem!

Meld ( http://meldmerge.org/ ) świetnie sobie radzi w porównywaniu katalogów i plików w nich zawartych.

Wtyczka DirDiff vima to kolejne bardzo przydatne narzędzie do porównywania katalogów.

vim -c "DirDiff dir1 dir2"

Nie tylko wyświetla listę plików, które różnią się między katalogami, ale pozwala także na inspekcję / modyfikację za pomocą vimdiff różnych plików.

Niezadowolony ze wszystkich odpowiedzi, ponieważ większość z nich działa bardzo wolno i generuje niepotrzebnie długie dane wyjściowe dla dużych katalogów, napisałem własny skrypt Pythona, aby porównać dwa foldery.

W przeciwieństwie do wielu innych rozwiązań, nie porównuje zawartości plików. Nie wchodzi też do podkatalogów, których brakuje w innym katalogu. Wynik jest więc dość zwięzły, a skrypt działa szybko.

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

Przykładowe użycie:

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

Lub jeśli chcesz zobaczyć tylko pliki z pierwszego katalogu:

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 Jeśli chcesz porównać rozmiary plików i skróty plików pod kątem potencjalnych zmian, opublikowałem zaktualizowany skrypt tutaj: https://gist.github.com/amakukha/f489cbde2afd32817f8e866cf4abe779

Inne podejście (być może szybsze w przypadku dużych katalogów):

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

sedPolecenie usuwa pierwszy składnik katalog dzięki Erik`s postu )

Jest trochę późno, ale może komuś pomóc. Nie jestem pewien, czy diff lub rsync wyrzucają tylko nazwy plików w takim formacie. Dzięki plhn za udostępnienie tego fajnego rozwiązania, które rozwinąłem poniżej.

Jeśli chcesz tylko nazwy plików, aby łatwo było skopiować potrzebne pliki w czystym formacie, możesz użyć polecenia find.

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

Zakłada się, że zarówno katalog 1, jak i katalog 2 znajdują się w tym samym folderze nadrzędnym. sed po prostu usuwa folder nadrzędny, aby można było porównać jabłka z jabłkami. Ostatni sed po prostu przywraca nazwę katalogu 1.

Jeśli chcesz tylko pliki:

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

Podobnie w przypadku katalogów:

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

Akceptowana odpowiedź wyświetli również listę plików, które istnieją w obu katalogach, ale mają inną zawartość. Aby wyświetlić WYŁĄCZNIE pliki istniejące w katalogu 1, możesz użyć:

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

Wyjaśnienie:

• diff -r dir1 dir2: porównaj
• grep „Only in”: pobierz wiersze zawierające „Only in”
• grep dir1: pobierz linie zawierające katalog

Ta odpowiedź optymalizuje jedną z sugestii @ Adail-Junior, dodając -Dopcję, która jest przydatna, gdy żaden z porównywanych katalogów nie jest repozytoriami git:

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

Jeśli użyjesz -D, nie zobaczysz porównań z /dev/null: text Binary files a/whatever and /dev/null differ

Uproszczony sposób porównywania 2 katalogów za pomocą polecenia DIFF

diff nazwa_pliku.1 nazwa_pliku.2> nazwa_pliku.dat >> Enter

otwórz filename.dat po zakończeniu uruchomienia

i zobaczysz: Tylko w nazwie pliku 1: Nazwa pliku 2 Tylko w: nazwa_katalogu: nazwa_pliku1 Tylko w: nazwa_katalogu: nazwa_pliku2

To jest skrypt bash do drukowania poleceń do synchronizacji dwóch katalogów

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 grepmoże odwrócić wyszukiwanie z opcją -v. To sprawia, że grepzgłaszanie wierszy, które nie pasują. W ten sposób możesz usunąć pliki dir2z listy plików w dir1.

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

Opcje -F -xpowiedzieć grep, aby przeprowadzić wyszukiwanie tekstu na całej linii.