Mostra diff tra commit

Sto usando Git su Ubuntu 10.04 (Lucid Lynx).

Ho fatto alcuni impegni con il mio padrone.

Tuttavia, voglio ottenere la differenza tra questi impegni. Sono tutti sul mio ramo principale.

Per esempio:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

Voglio ottenere la differenza tra k73ud e dj374. Tuttavia, quando ho fatto quanto segue non sono riuscito a vedere le modifiche apportate k73ud.

git diff k73ud..dj374 > master.patch

Provare

git diff k73ud^..dj374

per essere sicuro di includere tutte le modifiche k73udnella differenza risultante.

git diffconfronta due endpoint ( anziché un intervallo di commit ). Dato che l'OP vuole vedere le modifiche introdotte da k73ud, lui / lei deve fare la differenza tra il primo commit genitore di k73ud:k73ud^ (o k73ud^1ok73ud~ ).

In questo modo, i diffrisultati includeranno le modifiche rispetto al k73ud genitore (ovvero includendo le modifiche da k73udse stesso), anziché le modifiche introdotte da k73ud (fino a dj374).

Inoltre puoi provare:

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

e (1 spazio, non di più):

git diff oldCommit newCommit
git diff k73ud dj374

E se hai bisogno di ottenere solo i nomi dei file (ad es. Per copiarli manualmente):

git diff k73ud dj374 --name-only

E puoi applicare le modifiche a un altro ramo:

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

Per vedere la differenza tra:

La tua copia di lavoro e l'area di gestione temporanea:

% git diff

Area di gestione temporanea e commit più recente:

% git diff --staged

Copia di lavoro e commit 4ac0a6733:

% git diff 4ac0a6733

Commettere 4ac0a6733 e l'ultimo commit:

% git diff 4ac0a6733 HEAD

Commettere 4ac0a6733 e 826793951

% git diff 4ac0a6733 826793951

Per ulteriori spiegazioni consultare la documentazione ufficiale .

Se vuoi vedere le modifiche introdotte con ogni commit, prova "git log -p"

1. gitk --all
2. Seleziona il primo commit
3. Fare clic con il tasto destro sull'altro, quindi selezionare Diff → questo

Uso gitkper vedere la differenza:

gitk k73ud..dj374

Ha una modalità GUI che semplifica la revisione.

Per vedere la differenza tra due diversi commit (chiamiamoli ae b), usa

git diff a..b

• Si noti che la differenza tra ae bè opposta da be a.

Per vedere la differenza tra le ultime modifiche del commit e le modifiche non ancora impegnate, utilizzare

git diff

Se vuoi poter tornare alla differenza in un secondo momento, puoi salvarla in un file.

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

Più semplice per controllare le modifiche negli ultimi 2 commit dopo pull:

git diff HEAD~2 

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 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)

La risposta accettata è buona.

Mettilo di nuovo qui, quindi è facile da capire e provare in futuro

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

Ho avuto la stessa diff per tutti i comandi sopra.

Sopra aiuta a
1. vedere la differenza tra commit c1 e un altro commit c2
2. anche facendo un file patch che mostra diff e può essere usato per applicare le modifiche a un altro ramo

Se non mostra correttamente la differenza,
allora c1 e c2 potrebbero essere sbagliati
quindi regolali su un commit prima come c1 su c0 o su uno dopo come c2 su c3

Uso gitk per visualizzare gli SHA di commit, i primi 8 caratteri sono sufficienti per usarli come c0, c1, c2 o c3. Puoi anche vedere gli ID di commit da Gitlab> Repository> Commit, ecc.

Spero che aiuti.

Diciamo che hai un altro commit in fondo (più vecchio), quindi questo diventa abbastanza facile:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

commit oldestCommit
made changes

Ora, usando di seguito sarà facilmente server lo scopo.

git diff k73ud oldestCommit

Utilizzare questo comando per la differenza tra commit e non stage:

git difftool --dir-diff