Mostrar diferenças entre confirmações

Estou usando o Git no Ubuntu 10.04 (Lucid Lynx).

Fiz alguns comprometimentos com meu mestre.

No entanto, quero obter a diferença entre esses commits. Todos eles estão no meu ramo principal.

Por exemplo:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

Quero obter a diferença entre k73ud e dj374. No entanto, quando fiz o seguinte, não consegui ver as alterações feitas k73ud.

git diff k73ud..dj374 > master.patch

Experimentar

git diff k73ud^..dj374

certifique-se de incluir todas as alterações de k73udno diff resultante.

git diffcompara dois pontos de extremidade (em vez de um intervalo de confirmação ). Como o OP deseja ver as alterações introduzidas por k73ud, ele / ela precisa diferenciar o primeiro commit pai de k73ud:k73ud^ (ou k73ud^1ouk73ud~ ).

Dessa forma, os diffresultados incluirão alterações desde o k73ud pai (ou seja, incluindo alterações a partir de k73udsi), em vez de alterações introduzidas desde k73ud (até dj374).

Além disso, você pode tentar:

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

e (1 espaço, não mais):

git diff oldCommit newCommit
git diff k73ud dj374

E se você precisar obter apenas nomes de arquivos (por exemplo, para copiá-los manualmente):

git diff k73ud dj374 --name-only

E você pode obter as alterações aplicadas a outro ramo:

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

Para ver a diferença entre:

Sua cópia de trabalho e área de preparação:

% git diff

Área de preparação e a confirmação mais recente:

% git diff --staged

Sua cópia de trabalho e confirmar 4ac0a6733:

% git diff 4ac0a6733

Confirme 4ac0a6733 e a confirmação mais recente:

% git diff 4ac0a6733 HEAD

Confirme 4ac0a6733 e confirme 826793951

% git diff 4ac0a6733 826793951

Para mais explicações, consulte a documentação oficial .

Se você quiser ver as alterações introduzidas em cada confirmação, tente "git log -p"

1. gitk --all
2. Selecione o primeiro commit
3. Clique com o botão direito do mouse no outro e selecione diff → this

Eu uso gitkpara ver a diferença:

gitk k73ud..dj374

Possui um modo GUI para facilitar a revisão.

Para ver a diferença entre dois commits diferentes (vamos chamá-los ae b), use

git diff a..b

• Observe que a diferença entre ae bé oposta a be a.

Para ver a diferença entre suas últimas alterações confirmadas e ainda não confirmadas, use

git diff

Se você quiser voltar à diferença posteriormente, salve-a em um arquivo.

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

Mais simples para verificar as alterações nos últimos 2 commit após pull:

git diff HEAD~2 

Eu escrevi um script que exibe diff entre dois commits, funciona bem no 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)

Resposta aceita é boa.

Basta colocá-lo novamente aqui, para que seja fácil de entender e tentar no futuro

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

Eu tenho o mesmo diff para todos os comandos acima.

Acima ajuda em
1. vendo a diferença entre commit c1 e outro commit c2
2. também criando um arquivo de patch que mostra diff e pode ser usado para aplicar alterações em outro branch

Se não mostrar a diferença corretamente,
então c1 e c2 podem estar errados;
portanto, ajuste-os para um antes de confirmar como c1 a c0 ou para um depois como c2 a c3

Usar gitk para ver os SHAs confirmados, os primeiros 8 caracteres são suficientes para usá-los como c0, c1, c2 ou c3. Você também pode ver os IDs de commit em Gitlab> Repository> Commits, etc.

Espero que ajude.

Digamos que você tenha mais um commit na parte inferior (mais antigo), então isso se torna bastante fácil:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

commit oldestCommit
made changes

Agora, o uso abaixo servirá facilmente o objetivo.

git diff k73ud oldestCommit

Use este comando para a diferença entre commit e unstaged:

git difftool --dir-diff