Afficher les différences entre les validations

J'utilise Git sur Ubuntu 10.04 (Lucid Lynx).

J'ai fait quelques commits à mon maître.

Cependant, je veux faire la différence entre ces commits. Tous sont sur ma branche principale.

Par exemple:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

Je veux faire la différence entre k73ud et dj374. Cependant, lorsque j'ai fait ce qui suit, je n'ai pas pu voir les modifications que j'ai apportées k73ud.

git diff k73ud..dj374 > master.patch

Essayer

git diff k73ud^..dj374

pour vous assurer d'inclure toutes les modifications de k73uddans le diff résultant.

git diffcompare deux points de terminaison ( au lieu d'une plage de validation ). Puisque l'OP veut voir les changements introduits par k73ud, il / elle doit faire la différence entre le premier commit parent de k73ud:k73ud^ (ou k73ud^1ouk73ud~ ).

De cette façon, les diffrésultats incluront les changements depuis le k73ud parent (c'est-à-dire y compris les changements de k73udlui-même), au lieu des changements introduits depuis k73ud (jusqu'à dj374).

Vous pouvez également essayer:

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

et (1 espace, pas plus):

git diff oldCommit newCommit
git diff k73ud dj374

Et si vous avez besoin d'obtenir uniquement les noms de fichiers (par exemple, pour les copier manuellement):

git diff k73ud dj374 --name-only

Et vous pouvez appliquer les modifications à une autre branche:

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

Pour voir la différence entre:

Votre espace de travail et de copie:

% git diff

Zone de transit et dernier commit:

% git diff --staged

Votre copie de travail et commit 4ac0a6733:

% git diff 4ac0a6733

Validez 4ac0a6733 et la dernière validation:

% git diff 4ac0a6733 HEAD

Validez 4ac0a6733 et validez 826793951

% git diff 4ac0a6733 826793951

Pour plus d'explications, voir la documentation officielle .

Si vous voulez voir les changements introduits avec chaque commit, essayez "git log -p"

1. gitk --all
2. Sélectionnez le premier commit
3. Faites un clic droit sur l'autre, puis sélectionnez diff → ce

J'utilise gitkpour voir la différence:

gitk k73ud..dj374

Il a un mode GUI pour que la revue soit plus facile.

Pour voir la différence entre deux validations différentes (appelons-les aet b), utilisez

git diff a..b

• Notez que la différence entre aet best opposée à bet a.

Pour voir la différence entre votre dernière validation et les modifications non encore validées, utilisez

git diff

Si vous voulez pouvoir revenir à la différence plus tard, vous pouvez l'enregistrer dans un fichier.

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

Le plus simple pour vérifier les changements dans les 2 derniers commits après pull:

git diff HEAD~2 

J'ai écrit un script qui affiche les différences entre deux commits, fonctionne bien sur 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 réponse acceptée est bonne.

Il suffit de le remettre ici, donc c'est facile à comprendre et à essayer à l'avenir

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

J'ai le même diff pour toutes les commandes ci-dessus.

Ci-dessus aide à
1. voir la différence entre le commit c1 et un autre commit c2
2. également faire un fichier de patch qui montre diff et peut être utilisé pour appliquer des changements à une autre branche

S'il ne montre pas la différence correctement,
alors c1 et c2 peuvent être mal choisis
manière alors ajustez-les à un avant commit comme c1 à c0, ou à un après comme c2 à c3

Utilisation gitk pour voir les commits SHA, les 8 premiers caractères suffisent pour les utiliser comme c0, c1, c2 ou c3. Vous pouvez également voir les identifiants de validation depuis Gitlab> Référentiel> Validation, etc.

J'espère que cela pourra aider.

Disons que vous avez un autre commit en bas (le plus ancien), alors cela devient assez facile:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

commit oldestCommit
made changes

Maintenant, l'utilisation ci-dessous servira facilement le but.

git diff k73ud oldestCommit

Utilisez cette commande pour faire la différence entre commit et unstaged:

git difftool --dir-diff