Taahhütler arasındaki farkı göster

Git Ubuntu 10.04 (Lucid Lynx) üzerinde kullanıyorum .

Efendime bazı taahhütler verdim.

Ancak, bu taahhütler arasındaki farkı elde etmek istiyorum. Hepsi ana dalımda.

Örneğin:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

K73ud ve dj374 arasındaki farkı elde etmek istiyorum. Ancak, aşağıdakileri yaptığımda yaptığım değişiklikleri göremedim k73ud.

git diff k73ud..dj374 > master.patch

Deneyin

git diff k73ud^..dj374

k73udsonuçtaki tüm değişiklikleri eklediğinizden emin olun .

git diffiki bitiş noktasını karşılaştırır (kayıt aralığı yerine ). OP getirdiği değişiklikleri görmek istediğimiz için k73udaralarında, o / o farka ihtiyacı birinci ebeveyn ait taahhüt k73ud:k73ud^ (veya k73ud^1veyak73ud~ ).

Bu şekilde, diffsonuçlar o zamandan bu yana (en çok ) yapılan değişiklikler yerine k73udana öğeden beri olan değişiklikleri ( k73udkendisinden gelen değişiklikleri de içerir) içerecektir . k73uddj374

Ayrıca deneyebilirsiniz:

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

ve (1 boşluk, daha fazla değil):

git diff oldCommit newCommit
git diff k73ud dj374

Ve yalnızca dosya adlarını almanız gerekiyorsa (örn. Düzeltmeyi elle kopyalamak için):

git diff k73ud dj374 --name-only

Değişiklikleri başka bir şubeye uygulayabilirsiniz:

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

Arasındaki farkı görmek için:

Çalışma kopyanız ve hazırlama alanınız:

% git diff

Evreleme alanı ve son taahhüt:

% git diff --staged

Çalışma kopyanız ve taahhüdünüz 4ac0a6733:

% git diff 4ac0a6733

İşlem 4ac0a6733 ve en son işlem:

% git diff 4ac0a6733 HEAD

İşlem 4ac0a6733 ve işlem 826793951

% git diff 4ac0a6733 826793951

Daha fazla açıklama için resmi belgelere bakın .

Her bir taahhüdün getirdiği değişiklikleri görmek istiyorsanız, "git log -p" komutunu deneyin

1. gitk --all
2. İlk taahhüdü seçin
3. Diğerine sağ tıklayın , ardından seçili →

gitkFarkı görmek için kullanıyorum :

gitk k73ud..dj374

İncelemeyi kolaylaştırmak için bir GUI moduna sahiptir.

İki farklı kaydedilmesini arasındaki farkı görmek için (en diyelim ave b, kullanım)

git diff a..b

• Arasındaki fark Not ave bkarşısındaki bve a.

Son taahhüdünüz ile henüz taahhüt edilmemiş değişiklikleriniz arasındaki farkı görmek için şunu kullanın:

git diff

Farkı daha sonra geri gelmek istiyorsanız, bunu bir dosyaya kaydedebilirsiniz.

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

Çekmeden sonra son 2 işlemdeki değişiklikleri kontrol etmek için en basit:

git diff HEAD~2 

Ben iki taahhüt arasında fark görüntüler, Ubuntu iyi çalışır bir komut dosyası yazdı.

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)

Kabul edilen cevap iyidir.

Sadece buraya tekrar koymak, bu yüzden gelecekte anlaşılması ve denenmesi kolay

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

Yukarıdaki komutlar için aynı fark var.

Yukarıdaki
1. yardımcı c1 ve başka bir taahhüt c2
2. arasındaki farkı görmek 2. Ayrıca diff gösteren ve değişiklikleri başka bir şubeye uygulamak için kullanılabilir bir yama dosyası yapma

Farkı doğru göstermezse,
c1 & c2 yanlış alınabilir,
bu yüzden onları c1 ila c0 gibi bir tamamlamadan önce veya c2 ila c3 gibi bir taneye ayarlayın.

gitkTaahhütleri SHA'ları görmek için kullanın , ilk 8 karakter c0, c1, c2 veya c3 olarak kullanmak için yeterlidir. Ayrıca taahhüt kimlikleri Gitlab> Depo> İşlemler vb. Bölümünden de görebilirsiniz.

Umarım yardımcı olur.

Diyelim ki altta bir tane daha taahhüt var (en yaşlı), o zaman bu oldukça kolaylaşıyor:

commit dj374
made changes

commit y4746
made changes

commit k73ud
made changes

commit oldestCommit
made changes

Şimdi, aşağıda kullanmak amacı kolayca sunucu olacaktır.

git diff k73ud oldestCommit

Commit ve unstaged arasındaki fark için bu komutu kullanın:

git difftool --dir-diff