Come fai a git diff
mostrare solo la differenza tra due commit, esclusi gli altri commit nel mezzo?
Come fai a git diff
mostrare solo la differenza tra due commit, esclusi gli altri commit nel mezzo?
Risposte:
puoi semplicemente passare i 2 commit a git diff come:
-> git diff 0da94be 59ff30c > my.patch
-> git apply my.patch
my.patch
per un altro ramo?
Chiedere la differenza / tra / due commit senza includere i commit tra i due ha poco senso. I commit sono solo istantanee del contenuto del repository; chiedere la differenza tra due li include necessariamente. Quindi la domanda è: cosa stai davvero cercando?
Come ha suggerito William, la raccolta delle ciliegie può darti il delta di un singolo commit riproposto su un altro. Questo è:
$ git checkout 012345
$ git cherry-pick -n abcdef
$ git diff --cached
Questo prende commit 'abcdef', lo confronta con il suo antenato immediato, quindi applica quella differenza sopra '012345'. Questa nuova differenza viene quindi mostrata: l'unico cambiamento è che il contesto deriva da "012345" anziché dall'antenato immediato di "abcdef". Certo, potresti avere conflitti ed ecc., Quindi nella maggior parte dei casi non è un processo molto utile.
Se sei solo interessato a abcdef stesso, puoi fare:
$ git log -u -1 abcdef
Questo confronta abcdef al suo antenato immediato, da solo, ed è di solito quello che vuoi.
E naturalmente
$ git diff 012345..abcdef
ti dà tutte le differenze tra questi due commit.
Sarebbe utile avere un'idea migliore di ciò che stai cercando di ottenere - come ho già detto, chiedere la differenza tra due commit senza ciò che sta nel mezzo non ha senso.
origin/featurebranch#HEAD
con local/featurebranch#HEAD
può aiutarti a garantire di non aver rovinato nulla durante la risoluzione dei conflitti.
Per confrontare due commit git 12345 e abcdef come patch si può usare il comando diff as
diff <(git show 123456) <(git show abcdef)
git diff <(git show 123456) <(git show abcdef)
non funziona; diff <(...) <(...)
lo fa. (L'ho appena provato).
git diff 123456 abcdef
.
diff
l'output da due diff
secondi. Ciò comporta la lettura e il confronto di due flussi di input. diff
(GNU o Unix diff
) possono farlo, mentre git diff
non possono. Alcuni potrebbero chiedersi perché si vorrebbe farlo. Sono nel mezzo di farlo proprio ora, ripulendo un'unione che è andata male.
Per verificare le modifiche complete:
git diff <commit_Id_1> <commit_Id_2>
Per controllare solo i file modificati / aggiunti / eliminati:
git diff <commit_Id_1> <commit_Id_2> --name-only
NOTA : per controllare la differenza senza commit in mezzo, non è necessario inserire gli ID di commit.
Diciamo che hai questo
A
|
B A0
| |
C D
\ /
|
...
E vuoi assicurarti che A
sia lo stesso di A0
.
Questo farà il trucco:
$ git diff B A > B-A.diff
$ git diff D A0 > D-A0.diff
$ diff B-A.diff D-A0.diff
Supponiamo di voler vedere la differenza tra commit 012345 e abcdef. Quanto segue dovrebbe fare quello che vuoi:
$ git verifica 012345 $ git cherry-pick -n abcdef $ git diff - cache
Che dire di questo:
git diff abcdef 123456 | less
È utile collegarlo a meno se si desidera confrontare al volo molte differenze diverse.
Da Git 2.19, puoi semplicemente usare:
git range-diff rev1...rev2
- confronta due alberi di commit, a partire dal loro antenato comune
oppure
git range-diff rev1~..rev1 rev2~..rev2
- confrontare le modifiche introdotte da 2 commit determinati
Le mie alias
impostazioni nel ~/.bashrc
file per git diff
:
alias gdca='git diff --cached' # diff between your staged file and the last commit
alias gdcc='git diff HEAD{,^}' # diff between your latest two commits
Ho scritto uno script che mostra diff tra due commit, funziona bene su 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)