Wie kann man die Änderungen zwischen zwei Commits ohne Commits dazwischen sehen?
Wie machen Sie, dass git diff nur den Unterschied zwischen zwei Commits zeigt, ausgenommen die anderen Commits dazwischen?
sie können die 2 Commits einfach an git diff übergeben:
-> git diff 0da94be 59ff30c > my.patch
-> git apply my.patch
Nach dem Unterschied zu fragen/zwischen/zwei Commits, ohne die Commits dazwischen einzubeziehen, macht wenig Sinn. Commits sind lediglich Momentaufnahmen des Inhalts des Repositorys. Nach dem Unterschied zwischen zwei zu fragen, schließt sie zwangsläufig ein. Die Frage ist also: Wonach suchen Sie wirklich?
Wie William angedeutet hat, kann die Kirschpflückung Ihnen das Delta eines einzelnen Commits geben, das auf einem anderen basiert. Das ist:
$ git checkout 012345
$ git cherry-pick -n abcdef
$ git diff --cached
Dies erfordert das Festschreiben von 'abcdef', vergleicht es mit seinem direkten Vorfahren und wendet dann diese Differenz auf '012345' an. Dieser neue Unterschied wird dann angezeigt. Die einzige Änderung besteht darin, dass der Kontext von '012345' und nicht von 'abcdefs direktem Vorfahren stammt. Natürlich kann es zu Konflikten usw. kommen, daher ist dies in den meisten Fällen kein sehr nützlicher Prozess.
Wenn Sie nur an abcdef interessiert sind, können Sie Folgendes tun:
$ git log -u -1 abcdef
Dies vergleicht abcdef mit seinem unmittelbaren Vorfahren allein und ist normalerweise das, was Sie wollen.
Und natürlich
$ git diff 012345..abcdef
gibt Ihnen alle Unterschiede zwischen diesen beiden Commits.
Es würde helfen, eine bessere Vorstellung davon zu bekommen, was Sie erreichen wollen. Wie ich bereits erwähnte, ist es nicht sinnvoll, nach dem Unterschied zwischen zwei Commits zu fragen, ohne dass dazwischen etwas dazwischen liegt.
Um zwei git-Commits 12345 und abcdef als Patches zu vergleichen, kann der Befehl diff als verwendet werden
diff <(git show 123456) <(git show abcdef)
git diff <a-commit> <another-commit> path
Beispiel:
git diff commit1 commit2 config/routes.rb
Es zeigt den Unterschied zwischen diesen Commits in dieser Datei.
Nehmen wir an, Sie haben das hier
A
|
B A0
| |
C D
\ /
|
...
Und Sie möchten sicherstellen, dass A mit A0 identisch ist.
Dies wird den Trick tun:
$ git diff B A > B-A.diff
$ git diff D A0 > D-A0.diff
$ diff B-A.diff D-A0.diff
Angenommen, Sie möchten den Unterschied zwischen den Commits 012345 und abcdef sehen. Folgendes sollte tun, was Sie wollen:
$ git Kasse 012345 $ git Kirschpick -n abcdef $ git diff --cached
Was ist mit diesem:
git diff abcdef 123456 | less
Es ist praktisch, es einfach auf weniger zu reduzieren, wenn Sie viele verschiedene Unterschiede im laufenden Betrieb vergleichen möchten.
Zum Überprüfen der vollständigen Änderungen:
git diff <commit_Id_1> <commit_Id_2>
Zum Überprüfen nur der geänderten/hinzugefügten/gelöschten Dateien:
git diff <commit_Id_1> <commit_Id_2> --name-only
NOTE: Zur Überprüfung von diff ohne ein Commit dazwischen müssen Sie die Commit-IDs nicht eingeben.
Meine alias-Einstellungen in ~/.bashrc-Datei für git diff:
alias gdca='git diff --cached' # diff between your staged file and the last commit
alias gdcc='git diff HEAD{,^}' # diff between your recent tow commits
Englisch ist nicht meine Muttersprache. Bitte entschuldigen Sie Tippfehler
Seit Git 2.19 können Sie einfach Folgendes verwenden:
git range-diff <rev1>...<rev2>
Ich habe ein Skript geschrieben, das den Unterschied zwischen zwei Commits anzeigt. Das funktioniert gut auf Ubuntu.
https://Gist.github.com/jacobabrahamb4/a60624d6274ece7a0bd2d141b53407bc
#!/usr/bin/env python
import sys, subprocess, os
TOOLS = ['bcompare', 'meld']
def getTool():
for tool in TOOLS:
try:
out = subprocess.check_output(['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 = subprocess.check_output(['git', '-C', name, 'log', '--oneline', '--reverse']).split('\n')
if first_index >= 0:
commit1 = logs[first_index].split(' ')[0]
if second_index >= 0:
commit2 = logs[second_index].split(' ')[0]
except ValueError:
if first != '0':
commit1 = first
if second != '0':
commit2 = second
return commit1, commit2
def validateCommitIds(name, commit1, commit2):
if commit1 == None and commit2 == None:
print "Nothing to do, exit!"
return False
try:
if commit1 != None:
subprocess.check_output(['git', '-C', name, 'cat-file', '-t', commit1]).strip()
if commit2 != None:
subprocess.check_output(['git', '-C', name, 'cat-file', '-t', commit2]).strip()
except subprocess.CalledProcessError:
return False
return True
def cleanup(commit1, commit2):
subprocess.check_output(['rm', '-rf', '/tmp/'+(commit1 if commit1 != None else '0'), '/tmp/'+(commit2 if commit2 != None else '0')])
def checkoutCommit(name, commit):
if commit != None:
subprocess.check_output(['git', 'clone', name, '/tmp/'+commit])
subprocess.check_output(['git', '-C', '/tmp/'+commit, 'checkout', commit])
else:
subprocess.check_output(['mkdir', '/tmp/0'])
def compare(tool, commit1, commit2):
subprocess.check_output([tool, '/tmp/'+(commit1 if commit1 != None else '0'), '/tmp/'+(commit2 if commit2 != None else '0')])
if __name__=='__main__':
tool = getTool()
if tool == None:
print "No GUI diff tools"
sys.exit(0)
if len(sys.argv) != 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 not validateCommitIds(name, commit1, commit2):
sys.exit(0)
cleanup(commit1, commit2)
checkoutCommit(name, commit1)
checkoutCommit(name, commit2)
try:
compare(tool, commit1, commit2)
except KeyboardInterrupt:
pass
finally:
cleanup(commit1, commit2)
sys.exit(0)