Mostrar diferencias entre confirmaciones


236

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

Respuestas:


275

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

55
¿Estás seguro? git diff 275e8922ab4e995f47a753b88b75c3027444a54c..a8d9d944c32e945cbb9f60b3f724ecc580da86ae obras, pero git diff 275e8922ab4e995f47a753b88b75c3027444a54c ^ .. a8d9d944c32e945cbb9f60b3f724ecc580da86ae mensaje de error get - "revisión desconocida o la ruta no en el árbol de trabajo"
demas

@demas: funciona en mi máquina;) también puedes usarlo git diff 275e8^ a8d9d9ya que es lo mismo ' ..'.
VonC

44
@VonC En mi máquina, no hay necesidad de usar ^
xi.lin

55
@VonC Ubuntu 14.04. Solo git diff k73ud..dj374está bien
xi.lin

1
@BradyDowling De acuerdo. Y si desea ver una diferencia de relaciones públicas, puede hacerlo en línea de comandos con la nueva ghCLI: stackoverflow.com/a/62031065/6309
VonC

126

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 .


77
Además, si realmente solo desea ver las diferencias de un archivo en esas confirmaciones, git diff {x} {y} -- filenamedónde {x}y cuáles {y}son algunos de los ejemplos dados. Ver también, git log -pya que hay cierta superposición.
Michael

54

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


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

Estoy empezando a confiar en gitk un poco menos porque muestra un autor de compromiso diferente al actual.
Ciasto piekarz

10

Solía gitkver la diferencia:

gitk k73ud..dj374

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


7

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

6

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

git diff HEAD~2 

3

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)

1
Guión interesante +1
VonC

2

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.


0

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

-2

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

git difftool --dir-diff
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.