tipos - git ver archivos modificados

¿Cómo ver los cambios entre dos confirmaciones sin confirmaciones intermedias?

Question

¿Cómo hacer que git diff solo muestre la diferencia entre dos confirmaciones, excluyendo las otras confirmaciones intermedias?

Answer 1

¿Qué pasa con esto?

git diff abcdef 123456 | less

Es práctico simplemente canalizarlo a menos si desea comparar diferentes diferencias sobre la marcha.

Answer 2

Desde Git 2.19, simplemente puedes usar:

git range-diff <rev1>...<rev2>

Answer 3

Digamos que tienes esto

A
|
B    A0
|    |
C    D
/   /
  |
 ...

Y quieres asegurarte de que A sea ​​lo mismo que A0 .

Esto hará el truco:

$ git diff B A > B-A.diff
$ git diff D A0 > D-A0.diff
$ diff B-A.diff D-A0.diff

Answer 4

Escribí un script que muestra diff entre dos confirmaciones, funciona bien en 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)

Answer 5

Mis configuraciones de alias en el archivo ~/.bashrc para git diff :

alias gdca="git diff --cached" # diff between your staged file and the last commit
alias gdcc="git diff HEAD{,^}" # diff between your recent tow commits

El inglés no es mi idioma nativo, disculpe los errores tipográficos.

Answer 6

Para comparar dos git commit 12345 y abcdef como parches, se puede usar el comando diff como

diff <(git show 123456) <(git show abcdef)

Answer 7

Pedir la diferencia / entre / dos confirmaciones sin incluir las confirmaciones intermedias tiene poco sentido. Los compromisos son solo instantáneas de los contenidos del repositorio; Preguntar por la diferencia entre dos necesariamente los incluye. Entonces la pregunta es, ¿qué estás buscando realmente?

Como William sugirió, la selección de cerebros puede darte el delta de un solo compromiso basado en otro. Es decir:

$ git checkout 012345
$ git cherry-pick -n abcdef
$ git diff --cached

Esto toma la confirmación ''abcdef'', la compara con su antecesor inmediato, luego aplica esa diferencia sobre ''012345''. Luego se muestra esta nueva diferencia: el único cambio es que el contexto proviene de ''012345'' en lugar del ''ancestro inmediato de abcdef''. Por supuesto, puede tener conflictos y etc., por lo que no es un proceso muy útil en la mayoría de los casos.

Si solo estás interesado en abcdef, puedes hacer:

$ git log -u -1 abcdef

Esto compara abcdef con su antepasado inmediato, solo, y generalmente es lo que usted desea.

Y por supuesto

$ git diff 012345..abcdef

Te da todas las diferencias entre esos dos compromisos.

Ayudaría a tener una mejor idea de lo que está tratando de lograr, como mencioné, pedir la diferencia entre dos confirmaciones sin lo que está en medio no tiene sentido.

Answer 8

Supongamos que desea ver la diferencia entre confirmaciones 012345 y abcdef. Lo siguiente debe hacer lo que quieras:

$ git checkout 012345 $ git cherry-pick -n abcdef $ git diff --cached

Answer 9

simplemente puede pasar los 2 compromisos a git diff como:

-> git diff 0da94be  59ff30c > my.patch
-> git apply my.patch

Answer 10

git diff <a-commit> <another-commit> path

Ejemplo:

git diff commit1 commit2 config/routes.rb

Muestra la diferencia en ese archivo entre esas confirmaciones.