Mostrar diferencias entre confirmaciones

Estoy usando Git en Ubuntu 10.04 (Lucid Lynx).

He hecho algunos compromisos con mi maestro.

Sin embargo, quiero obtener la diferencia entre estos commits. Todos ellos están en mi rama maestra.

Por ejemplo:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

Quiero obtener la diferencia entre k73ud y dj374. Sin embargo, cuando hice lo siguiente no pude ver los cambios que hice k73ud.

git diff k73ud..dj374 > master.patch

Tratar

git diff k73ud^..dj374

para asegurarse de incluir todos los cambios de k73uden el diff resultante.

git diffcompara dos puntos finales (en lugar de un rango de compromiso ). Dado que el OP quiere ver los cambios introducidos por k73ud, él / ella necesita diferenciar entre el primer compromiso principal de k73ud:k73ud^ (o k73ud^1ok73ud~ ).

De esa manera, los diffresultados incluirán cambios desde el k73ud padre (es decir, incluyendo cambios de k73udsí mismo), en lugar de cambios introducidos desde k73ud (hasta dj374).

También puedes probar:

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

y (1 espacio, no más):

git diff oldCommit newCommit
git diff k73ud dj374

Y si necesita obtener solo los nombres de los archivos (por ejemplo, copiarlos, corregirlos manualmente):

git diff k73ud dj374 --name-only

Y puede aplicar los cambios a otra rama:

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

Para ver la diferencia entre:

Su copia de trabajo y área de preparación:

% git diff

Área de ensayo y la última confirmación:

% git diff --staged

Su copia de trabajo y confirme 4ac0a6733:

% git diff 4ac0a6733

Commit 4ac0a6733 y la última confirmación:

% git diff 4ac0a6733 HEAD

Comprometer 4ac0a6733 y cometer 826793951

% git diff 4ac0a6733 826793951

Para más explicaciones ver la documentación oficial .

Si desea ver los cambios introducidos con cada confirmación, intente "git log -p"

1. gitk --all
2. Seleccione la primera confirmación
3. Haga clic derecho sobre el otro, luego seleccione diff → esto

Solía gitkver la diferencia:

gitk k73ud..dj374

Tiene un modo GUI para que la revisión sea más fácil.

Para ver la diferencia entre dos confirmaciones diferentes (llamémoslas ay b), use

git diff a..b

• Tenga en cuenta que la diferencia entre ay bes opuesta a by a.

Para ver la diferencia entre su último compromiso y los cambios aún no comprometidos, use

git diff

Si desea volver a la diferencia más adelante, puede guardarla en un archivo.

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

Más simple para verificar los cambios en los últimos 2 commits después del pull:

git diff HEAD~2 

Escribí un script que muestra diff entre dos commits, funciona bien en 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 respuesta aceptada es buena.

Simplemente ponlo de nuevo aquí, por lo que es fácil de entender y probar en el futuro

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

Obtuve la misma diferencia para todos los comandos anteriores.

Lo anterior ayuda en
1. ver la diferencia de entre commit c1 y otro commit c2
2. también hacer un archivo de parche que muestre diff y se pueda usar para aplicar cambios a otra rama

Si no muestra la diferencia correctamente,
entonces c1 y c2 pueden tomarse incorrectamente
así que ajústelos a un antes de confirmar como c1 a c0, o a uno después como c2 a c3

Utilizar gitk para ver los SHA de confirmaciones, los primeros 8 caracteres son suficientes para usarlos como c0, c1, c2 o c3. También puede ver los ID de commits desde Gitlab> Repository> Commits, etc.

Espero que ayude.

Digamos que tiene una confirmación más en la parte inferior (la más antigua), entonces esto se vuelve bastante fácil:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

commit oldestCommit
made changes

Ahora, usar a continuación servirá fácilmente el propósito.

git diff k73ud oldestCommit

Use este comando para la diferencia entre commit y no en escena:

git difftool --dir-diff