Unterschied zwischen Commits anzeigen

Ich benutze Git unter Ubuntu 10.04 (Lucid Lynx).

Ich habe einige Verpflichtungen gegenüber meinem Meister eingegangen.

Ich möchte jedoch den Unterschied zwischen diesen Commits herausfinden. Alle von ihnen sind in meiner Hauptniederlassung.

Beispielsweise:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

Ich möchte den Unterschied zwischen k73ud und dj374 herausfinden. Als ich jedoch Folgendes tat, konnte ich die vorgenommenen Änderungen nicht sehen k73ud.

git diff k73ud..dj374 > master.patch

Versuchen

git diff k73ud^..dj374

um sicherzustellen, dass alle Änderungen von k73udin das resultierende Diff aufgenommen werden.

git diffvergleicht zwei Endpunkte ( anstelle eines Festschreibungsbereichs ). Da das OP die durch eingeführten Änderungen sehen möchte, k73udmuss es zwischen dem ersten übergeordneten Commit von k73ud:k73ud^ (oder k73ud^1oderk73ud~ ) unterscheiden.

Auf diese Weise enthalten die diffErgebnisse Änderungen seit dem k73ud übergeordneten Element (dh Änderungen von sich k73udselbst) anstelle von Änderungen, die seit k73ud (bis zu dj374) eingeführt wurden.

Sie können auch versuchen:

git diff oldCommit..newCommit
git diff k73ud..dj374 

und (1 Leerzeichen, nicht mehr):

git diff oldCommit newCommit
git diff k73ud dj374

Und wenn Sie nur Dateinamen benötigen (z. B. um Hotfixes manuell zu kopieren):

git diff k73ud dj374 --name-only

Und Sie können Änderungen auf einen anderen Zweig anwenden lassen:

git diff k73ud dj374 > my.patch
git apply my.patch

Um den Unterschied zu sehen zwischen:

Ihre Arbeitskopie und Ihr Staging-Bereich:

% git diff

Staging-Bereich und das neueste Commit:

% git diff --staged

Ihre Arbeitskopie und Commit 4ac0a6733:

% git diff 4ac0a6733

Commit 4ac0a6733 und das neueste Commit:

% git diff 4ac0a6733 HEAD

Commit 4ac0a6733 und Commit 826793951

% git diff 4ac0a6733 826793951

Weitere Erläuterungen finden Sie in der offiziellen Dokumentation .

Wenn Sie die mit jedem Commit eingeführten Änderungen sehen möchten, versuchen Sie "git log -p".

1. gitk --all
2. Wählen Sie das erste Commit aus
3. Klicken Sie mit der rechten Maustaste auf die andere und wählen Sie dann → aus

Ich gitksehe den Unterschied:

gitk k73ud..dj374

Es verfügt über einen GUI-Modus, sodass die Überprüfung einfacher ist.

Verwenden Sie, um den Unterschied zwischen zwei verschiedenen Commits zu erkennen (nennen wir sie aund b)

git diff a..b

• Beachten Sie, dass der Unterschied zwischen aund bvon bund entgegengesetzt ist a.

Verwenden Sie, um den Unterschied zwischen Ihren letzten und noch nicht festgeschriebenen Änderungen festzustellen

git diff

Wenn Sie später auf den Unterschied zurückkommen möchten, können Sie ihn in einer Datei speichern.

git diff a..b > ../project.diff

Am einfachsten zum Überprüfen der Änderungen in den letzten 2 Commits nach dem Ziehen:

git diff HEAD~2 

Ich habe ein Skript geschrieben, das Unterschiede zwischen zwei Commits anzeigt und unter Ubuntu gut funktioniert.

https://gist.github.com/jacobabrahamb4/a60624d6274ece7a0bd2d141b53407bc

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

TOOLS = ['bcompare', 'meld']

def execute(command):
    return subprocess.check_output(command)

def getTool():
    for tool in TOOLS:
        try:
            out = execute(['which', tool]).strip()
            if tool in out:
                return tool
        except subprocess.CalledProcessError:
            pass
    return None

def printUsageAndExit():
    print 'Usage: python bdiff.py <project> <commit_one> <commit_two>'
    print 'Example: python bdiff.py <project> 0 1'
    print 'Example: python bdiff.py <project> fhejk7fe d78ewg9we'
    print 'Example: python bdiff.py <project> 0 d78ewg9we'
    sys.exit(0)

def getCommitIds(name, first, second):
    commit1 = None
    commit2 = None
    try:
        first_index = int(first) - 1
        second_index = int(second) - 1
        if int(first) < 0 or int(second) < 0:
            print "Cannot handle negative values: "
            sys.exit(0)
        logs = execute(['git', '-C', name, 'log', '--oneline', '--reverse']).splitlines()
        if first_index >= 0:
            commit1 = logs[first_index].split(' ')[0]
        if second_index >= 0:
            commit2 = logs[second_index].split(' ')[0]
    except ValueError:
        if first is not '0':
            commit1 = first
        if second is not '0':
            commit2 = second
    return commit1, commit2

def validateCommitIds(name, commit1, commit2):
    if not commit1 and not commit2:
        print "Nothing to do, exit!"
        return False
    try:
        if commit1:
            execute(['git', '-C', name, 'cat-file', '-t', commit1])
        if commit2:
            execute(['git', '-C', name, 'cat-file', '-t', commit2])
    except subprocess.CalledProcessError:
        return False
    return True

def cleanup(commit1, commit2):
        execute(['rm', '-rf', '/tmp/'+(commit1 if commit1 else '0'), '/tmp/'+(commit2 if commit2 else '0')])

def checkoutCommit(name, commit):
    if commit:
        execute(['git', 'clone', name, '/tmp/'+commit])
        execute(['git', '-C', '/tmp/'+commit, 'checkout', commit])
    else:
        execute(['mkdir', '/tmp/0'])

def compare(tool, commit1, commit2):
        execute([tool, '/tmp/'+(commit1 if commit1 else '0'), '/tmp/'+(commit2 if commit2 else '0')])

if __name__=='__main__':
    tool = getTool()
    if not tool:
        print "No GUI diff tools, install bcompare or meld"
        sys.exit(0)
    if len(sys.argv) is not 4:
        printUsageAndExit()

    name, first, second = None, 0, 0
    try:
        name, first, second = sys.argv[1], sys.argv[2], sys.argv[3]
    except IndexError:
        printUsageAndExit()

    commit1, commit2 = getCommitIds(name, first, second)

    if validateCommitIds(name, commit1, commit2) is False:
        sys.exit(0)

    cleanup(commit1, commit2)

    try:
        checkoutCommit(name, commit1)
        checkoutCommit(name, commit2)
        compare(tool, commit1, commit2)
    except KeyboardInterrupt:
        pass
    finally:
        cleanup(commit1, commit2)
    sys.exit(0)

Akzeptierte Antwort ist gut.

Setzen Sie es einfach noch einmal hier ein, damit es in Zukunft leicht zu verstehen und zu versuchen ist

git diff c1...c2 > mypatch_1.patch  
git diff c1..c2  > mypatch_2.patch  
git diff c1^..c2 > mypatch_3.patch  

Ich habe den gleichen Unterschied für alle oben genannten Befehle.

Oben hilft,
1. den Unterschied zwischen Commit c1 und einem anderen Commit c2 zu erkennen.
2. Außerdem eine Patch-Datei zu erstellen, die diff anzeigt und zum Anwenden von Änderungen auf einen anderen Zweig verwendet werden kann

Wenn der Unterschied nicht korrekt
angezeigt wird, können c1 und c2 falsch verstanden
werden. Passen Sie sie daher an ein Vor-Commit wie c1 an c0 oder an ein Nach-Commit wie c2 an c3 an

Verwenden Sie gitkdiese Option, um die Commits-SHAs anzuzeigen. Die ersten 8 Zeichen reichen aus, um sie als c0, c1, c2 oder c3 zu verwenden. Sie können die Commit-IDs auch unter Gitlab> Repository> Commits usw. anzeigen.

Hoffentlich hilft das.

Angenommen, Sie haben unten noch ein Commit (ältestes), dann wird dies ziemlich einfach:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

commit oldestCommit
made changes

Die Verwendung von unten wird den Zweck leicht bedienen.

git diff k73ud oldestCommit

Verwenden Sie diesen Befehl für den Unterschied zwischen Festschreiben und Nicht-Bereitstellen:

git difftool --dir-diff