Git'teki birleştirme çakışmalarını nasıl çözerim?

Deneyin: git mergetool

Her çakışmada sizi yönlendiren bir GUI açar ve nasıl birleştirileceğini seçersiniz. Bazen daha sonra biraz el düzenlemesi gerekir, ancak genellikle tek başına yeterlidir. Her şeyi kesinlikle elle yapmaktan çok daha iyi.

@JoshGlover yorumuna göre:

Komuta

bir tane yüklemediğiniz sürece mutlaka bir GUI açmaz. git mergetoolBenim için koşmak vimdiffkullanıldı. Bunun yerine kullanmak için aşağıdaki araçlardan birini yükleyebilirsiniz: meld, opendiff, kdiff3, tkdiff, xxdiff, tortoisemerge, gvimdiff, diffuse, ecmerge, p4merge, araxis, vimdiff, emerge.

Aşağıda, vimdiffbirleştirme çakışmalarını çözümlemek için kullanılacak örnek yordam verilmiştir . Bu bağlantıya dayanarak

Adım 1 : Terminalinizde aşağıdaki komutları çalıştırın

git config merge.tool vimdiff
git config merge.conflictstyle diff3
git config mergetool.prompt false

Bu, vimdiff'i varsayılan birleştirme aracı olarak ayarlar.

Adım 2 : Terminalde aşağıdaki komutu çalıştırın

git mergetool

Adım 3 : Aşağıdaki formatta bir vimdiff ekranı göreceksiniz

  ╔═══════╦══════╦════════╗
  ║       ║      ║        ║
  ║ LOCAL ║ BASE ║ REMOTE ║
  ║       ║      ║        ║
  ╠═══════╩══════╩════════╣
  ║                       ║
  ║        MERGED         ║
  ║                       ║
  ╚═══════════════════════╝

Bu 4 görüntüleme

LOCAL - bu geçerli daldaki dosya

BASE - ortak ata, dosyanın her iki değişiklikten önce nasıl göründüğü

REMOTE - şubenize birleştirdiğiniz dosya

BİRLEŞTİRİLDİ - birleştirme sonucu, depoda kaydedilen şey budur

ctrl+ Kullanarak bu görünümler arasında gezinebilirsiniz w. MERGED görünümüne ctrl+ ve wardından tuşlarını kullanarak doğrudan ulaşabilirsiniz j.

Burada ve burada vimdiff navigasyon hakkında daha fazla bilgi

4. Adım . MERGED görünümünü aşağıdaki şekilde düzenleyebilirsiniz

UZAKTAN değişiklik almak istiyorsanız

:diffg RE  

BASE'ten değişiklik almak istiyorsanız

:diffg BA  

LOCAL'dan değişiklik almak istiyorsanız

:diffg LO 

Adım 5 . Kaydet, Çık, Tamamla ve Temizle

:wqa vi'dan kaydet ve çık

git commit -m "message"

git clean Diff aracı tarafından oluşturulan ek dosyaları (örn. * .Orig) kaldırın.

İşte üstten olası bir kullanım örneği:

Bazı değişiklikler yapacaksınız, ama ayy, güncel değilsiniz:

git fetch origin
git pull origin master

From ssh://gitosis@example.com:22/projectname
 * branch            master     -> FETCH_HEAD
Updating a030c3a..ee25213
error: Entry 'filename.c' not uptodate. Cannot merge.

Böylece güncelleşir ve tekrar denersiniz, ancak bir çatışma yaşarsınız:

git add filename.c
git commit -m "made some wild and crazy changes"
git pull origin master

From ssh://gitosis@example.com:22/projectname
 * branch            master     -> FETCH_HEAD
Auto-merging filename.c
CONFLICT (content): Merge conflict in filename.c
Automatic merge failed; fix conflicts and then commit the result.

Böylece değişikliklere bir göz atmaya karar veriyorsunuz:

git mergetool

Oh my, oh my, upstream bazı şeyleri değiştirdi, ama sadece değişikliklerimi kullanmak için ... hayır ... değişiklikleri ...

git checkout --ours filename.c
git checkout --theirs filename.c
git add filename.c
git commit -m "using theirs"

Ve sonra son kez deniyoruz

git pull origin master

From ssh://gitosis@example.com:22/projectname
 * branch            master     -> FETCH_HEAD
Already up-to-date.

Sürpriz!

Birleştirme araçlarının çatışmayı veya çözümü anlamama nadiren yardımcı olduğunu düşünüyorum. Genellikle bir metin düzenleyicideki çakışma işaretlerine bakıp git log'unu ek olarak kullanıyorum.

İşte birkaç ipucu:

Birinci İpucu

Bulduğum en iyi şey "diff3" birleştirme çakışması stilini kullanmaktır:

git config merge.conflictstyle diff3

Bu, aşağıdaki gibi çatışma işaretleri üretir:

<<<<<<<
Changes made on the branch that is being merged into. In most cases,
this is the branch that I have currently checked out (i.e. HEAD).
|||||||
The common ancestor version.
=======
Changes made on the branch that is being merged in. This is often a 
feature/topic branch.
>>>>>>>

Orta bölüm, ortak ataların neye benzediğidir. Bu yararlıdır, çünkü her dalda neyin değiştiğini daha iyi anlamak için üst ve alt sürümlerle karşılaştırabilirsiniz, bu da her değişikliğin amacının ne olduğu hakkında daha iyi bir fikir verir.

Çatışma sadece birkaç satırsa, bu genellikle çatışmayı çok açık hale getirir. (Bir çatışmayı nasıl çözeceğinizi bilmek çok farklıdır; diğer insanların ne üzerinde çalıştığının farkında olmanız gerekir. Kafanız karıştıysa, o kişiyi odanıza çağırmanız en iyisidir, böylece aradığınızı görebilirler en.)

Çatışma daha uzunsa, üç bölümün her birini kesip "benim", "ortak" ve "onların" gibi üç ayrı dosyaya yapıştıracağım.

Sonra çatışmaya neden olan iki fark parçalarını görmek için aşağıdaki komutları çalıştırabilirim:

diff common mine
diff common theirs

Bu, bir birleştirme aracı kullanmakla aynı şey değildir, çünkü bir birleştirme aracı çakışan tüm farklı olmayan yığınları da içerecektir. Bunu dikkat dağıtıcı buluyorum.

İkinci İpucu

Birisi bundan daha önce bahsetti, ancak her farklı iri parçaların arkasındaki niyeti anlamak genellikle bir çatışmanın nereden geldiğini ve nasıl ele alınacağını anlamak için çok yararlıdır.

git log --merge -p <name of file>

Bu, ortak ata ile birleştirmekte olduğunuz iki kafa arasındaki dosyaya dokunan tüm taahhütleri gösterir. (Bu nedenle, birleştirilmeden önce her iki dalda da var olan taahhütleri içermez.) Bu, mevcut çatışmanızda açıkça bir faktör olmayan farklı iri parçaları görmezden gelmenize yardımcı olur.

Üçüncü İpucu

Otomatik araçlarla değişikliklerinizi doğrulayın.

Otomatik testleriniz varsa, bunları çalıştırın. Bir tiftik varsa , çalıştırın. Eğer oluşturulabilir bir proje ise, taahhütte bulunmadan önce oluşturun vb. Her durumda, değişikliklerinizin hiçbir şeyi bozmadığından emin olmak için biraz test yapmanız gerekir. (Heck, çatışmasız birleşme bile çalışma kodunu kırabilir.)

Dördüncü İpucu

Önceden planlamak; iş arkadaşları ile iletişim kurmak.

İleride planlama yapmak ve başkalarının neler üzerinde çalıştığının farkında olmak, birleştirme çatışmalarını önlemeye ve / veya daha önce çözülmesine yardımcı olabilir - ayrıntılar hala akılda tutulur.

Örneğin, siz ve başka bir kişinin her ikisinin de aynı dosya kümesini etkileyecek farklı yeniden düzenleme üzerinde çalıştığını biliyorsanız, birbirinizle önceden konuşmalı ve her birinizin ne tür değişiklikler olduğu konusunda daha iyi bir fikir edinmelisiniz. yapımı. Planlanan değişikliklerinizi paralel yerine seri olarak gerçekleştirirseniz önemli ölçüde zaman ve çaba tasarrufu yapabilirsiniz.

Büyük bir kod kesimini kesen büyük refactorings için, seri olarak çalışmayı kuvvetle düşünmelisiniz: bir kişi tam yeniden düzenleme gerçekleştirirken herkes kodun bu alanı üzerinde çalışmayı bırakır.

Seri olarak çalışamazsanız (zaman baskısı nedeniyle, belki), o zaman beklenen birleştirme çakışmaları hakkında iletişim kurmak, en azından ayrıntılar hala akılda tutulurken sorunları en kısa sürede çözmenize yardımcı olur. Örneğin, bir iş arkadaşınız bir haftalık bir süre zarfında yıkıcı bir dizi taahhütte bulunuyorsa, o iş arkadaşı şubesinde o hafta boyunca günde bir veya iki kez birleştirmeyi / yeniden birleştirmeyi seçebilirsiniz. Bu şekilde, birleştirme / rebase çakışmaları bulursanız, bunları her şeyi tek bir büyük topakta birleştirmek için birkaç hafta beklemenizden daha hızlı çözebilirsiniz.

Beşinci İpucu

Bir birleşmeden emin değilseniz zorlamayın.

Birleştirme, özellikle çok sayıda çakışan dosya olduğunda ve çakışma işaretleri yüzlerce satırı kapsadığında ezici olabilir. Çoğu zaman yazılım projelerini tahmin ederken, gnarly birleştirme gibi genel giderler için yeterli zaman içermiyoruz, bu nedenle her çatışmayı çözmek için birkaç saat harcamak gerçek bir sürükleme gibi geliyor.

Uzun vadede, önceden planlama ve başkalarının ne üzerinde çalıştıklarının farkında olma, birleşme çatışmalarını tahmin etmek ve kendinizi daha kısa sürede doğru bir şekilde çözmeye hazırlanmak için en iyi araçlardır.

1. Hangi dosyaların çakıştığını belirleyin (Git size bunu söylemelidir).

2. Her dosyayı açın ve farkları inceleyin; Git onları sınırlar. Umarım her bloğun hangi versiyonunu saklayacağı açıktır. Kodu uygulayan diğer geliştiricilerle tartışmanız gerekebilir.

3. Bir dosyadaki çakışmayı çözdükten sonra git add the_file.

4. Tüm çakışmaları çözdükten sonra , git rebase --continueGit'i tamamladığınızda söylemesi gereken komutu verin.

Yığın Taşması sorusundaki yanıtlara göz atın Git'te bir birleşmeyi iptal etmek , özellikle Charles Bailey'nin dosyanın farklı sürümlerinin sorunlu olarak nasıl görüntüleneceğini gösteren cevabı , örneğin,

# Common base version of the file.
git show :1:some_file.cpp

# 'Ours' version of the file.
git show :2:some_file.cpp

# 'Theirs' version of the file.
git show :3:some_file.cpp

Birleştirme çakışmaları, bir dosyada aynı anda değişiklik yapıldığında ortaya çıkar. İşte nasıl çözeceğiniz.

git CLI

Çakışan duruma geçtiğinizde yapmanız gereken basit adımlar şunlardır:

1. İle çakışan dosyaların listesini not edin: git status( Unmerged pathsbölümün altında ).

2. Aşağıdaki yaklaşımlardan birini kullanarak her dosya için çakışmaları ayrı ayrı çözün:

   • Çatışmaları çözmek için GUI kullanın: git mergetool(en kolay yol).

   • Uzaktan / diğer versiyonu kullanımını kabul etmek için: git checkout --theirs path/file. Bu, söz konusu dosya için yaptığınız tüm yerel değişiklikleri reddeder.

   • Yerel / sürümümüzü kabul etmek için şunu kullanın: git checkout --ours path/file

     ^{Ancak, bazı nedenlerden dolayı çatışmaların yapıldığı uzaktan değişiklikler olarak dikkatli olmalısınız.}

     İlgili: Git'te "bizim" ve "onların" tam anlamı nedir?

   • Çakışan dosyaları manuel olarak düzenleyin ve <<<<</ arasında kod bloğunu arayın, >>>>>ardından yukarıdan veya aşağıdan sürümü seçin =====. Bakınız: Çatışmalar nasıl sunulur ?

   • Yol ve dosya adı çakışmaları git add/ ile çözülebilir git rm.

3. Son olarak, aşağıdakileri kullanarak çalışmaya hazır dosyaları inceleyin: git status .

   Hala altında herhangi bir dosya varsa Unmerged pathsve el ile çatışmayı çözmek verdin o zaman Git bunu aşağıdaki şekilde çözmüş olduğunu bildirmek: git add path/file.

4. Tüm çakışmalar başarıyla çözüldüyse, değişiklikleri şu şekilde yapın: git commit -ave her zamanki gibi uzaktan kumandaya itin.

Ayrıca bkz: Birleştirme çakışmasını komut satırından çözme GitHub'daki

Pratik eğitim için şunları kontrol edin: Senaryo 5 - Birleştirme Çakışmalarını Katacoda'dan Düzeltme .

DiffMerge

Windows, macOS ve Linux / Unix'teki dosyaları görsel olarak karşılaştırabilen ve birleştirebilen DiffMerge'i başarıyla kullandım .

Grafik olarak 3 dosya arasındaki değişiklikleri gösterebilir ve otomatik birleştirme (güvenli olduğunda) ve elde edilen dosyayı düzenleme üzerinde tam kontrol sağlar.

^{Görüntü kaynağı: DiffMerge (Linux ekran görüntüsü)}

Sadece indirin ve aşağıdaki gibi repo çalıştırın:

git mergetool -t diffmerge .

Mac os işletim sistemi

MacOS'ta şu yöntemle yükleyebilirsiniz:

brew install caskroom/cask/brew-cask
brew cask install diffmerge

Ve muhtemelen (sağlanmadıysa), PATH'inize yerleştirilmiş aşağıdaki ekstra basit sargıya ihtiyacınız vardır (örn. /usr/bin):

#!/bin/sh
DIFFMERGE_PATH=/Applications/DiffMerge.app
DIFFMERGE_EXE=${DIFFMERGE_PATH}/Contents/MacOS/DiffMerge
exec ${DIFFMERGE_EXE} --nosplash "$@"

Ardından aşağıdaki klavye kısayollarını kullanabilirsiniz:

• ⌘- Alt- Up/ Downönceki / sonraki değişikliklere atlamak için.
• ⌘- Alt- Left/ Rightsoldan veya sağdan değişikliği kabul etmek için

Alternatif olarak , üçüncü bir dosya veya dizin oluşturmak için iki dosyayı veya dizini bir araya getirmenizi sağlayan opendiff'i (Xcode Tools'un bir parçası) kullanabilirsiniz .

Sık sık küçük taahhütlerde bulunuyorsanız, taahhüt edilen yorumlara bakarak başlayın git log --merge. Sonra git diffsize anlaşmazlıkları göstereceğim.

Birkaç satırdan fazlasını içeren çakışmalar için, harici bir GUI aracında neler olup bittiğini görmek daha kolaydır. Ben opendiff severim - Git ayrıca vimdiff, gvimdiff, kdiff3, tkdiff, meld, xxdiff'i destekler, kutudan çıkar ve başkalarını yükleyebilirsiniz: git config merge.tool "your.tool"seçtiğiniz aracı kuracak ve sonragit mergetool başarısız bir birleştirme işleminden sonra farklı bağlamlarda size farklılıkları gösterecektir.

Bir çakışmayı çözmek için bir dosyayı her düzenlediğinizde git add filename, dizini güncelleyecek ve farkınız artık göstermeyecektir. Tüm çakışmalar ele alındığında ve dosyaları git adddüzeltildiğinde, git commitbirleştirme işleminizi tamamlar.

Bkz Çatışmalar nasıl sunulduğunu Git'te, ya git mergedokümantasyon birleştirme çatışma belirteçleri ne olduğunu anlamak için.

Ayrıca, Çatışmalar Nasıl Çözülür bölümü, çakışmaların nasıl çözüleceğini açıklar:

Bir çatışma gördükten sonra iki şey yapabilirsiniz:

• Birleştirmemeye karar verin. İhtiyacınız olan tek temizlik, dizin dosyasını HEADters 2 taahhüdüne sıfırlamak ve 2. ve 3 tarafından yapılan çalışma ağacı değişikliklerini temizlemek; git merge --abortbunun için kullanılabilir.

• Çatışmaları çözün. Git, çalışma ağacındaki çakışmaları işaretler. Dosyaları şekle git add, dizine göre düzenleyin. git commitAnlaşmayı kapatmak için kullanın .

Çatışmada birkaç araçla çalışabilirsiniz:

• Bir birleştirme aracı kullanın. git mergetoolbirleştirme boyunca size yardımcı olacak bir grafik birleştirme aracı başlatmak için.

• Farklara bakın. git diffhem HEADve hem de MERGE_HEADsürümlerdeki değişiklikleri vurgulayan üç yönlü bir fark gösterir .

• Her daldaki farklara bakın. git log --merge -p <path>önce HEADsürüm ve sonra sürüm için diffs gösterecektir MERGE_HEAD.

• Orijinallere bakın. git show :1:filenameortak atası git show :2:filenamegösterir, HEADsürümü git show :3:filenamegösterir ve MERGE_HEADsürümü gösterir .

Birleştirme çakışması işaretleyicilerini ve bunların nasıl çözüleceğini Pro Git kitap bölümü Temel Birleştirme Çakışmaları bölümünde okuyabilirsiniz .

Benim ya da sürümlerinin tamamını istiyorum ya da tek tek değişiklikleri gözden geçirmek ve her birine karar vermek istiyorum.

Benim veya onların sürümünü tamamen kabul et :

Sürümümü kabul et (yerel, bizimki):

git checkout --ours -- <filename>
git add <filename>              # Marks conflict as resolved
git commit -m "merged bla bla"  # An "empty" commit

Sürümlerini kabul et (uzak, onların):

git checkout --theirs -- <filename>
git add <filename>
git commit -m "merged bla bla"

Tüm çakışma dosyaları için yapmak istiyorsanız :

git merge --strategy-option ours

veya

git merge --strategy-option theirs

Tüm değişiklikleri inceleyin ve tek tek kabul edin

1. git mergetool
2. Değişiklikleri gözden geçirin ve her biri için her iki sürümü de kabul edin.
3. git add <filename>
4. git commit -m "merged bla bla"

Varsayılan komut satırındamergetool çalışır . Bir komut satırı birleştirme aracı nasıl kullanılır ayrı bir soru olmalıdır.

Ayrıca yükleyebilirsiniz görsel aracı örneğin, bunun için meldve çalıştırın

git mergetool -t meld

Yerel sürümü (bizimki), "temel" veya "birleştirilmiş" sürümü (birleştirmenin geçerli sonucu) ve uzak sürümü (onların) açar. Birleştirilen sürümü bitirdiğinizde kaydedin, git mergetool -t meld"Hiçbir dosya birleştirilmeye gerek yok" elde edene kadar tekrar çalıştırın ve 3. ve 4. Adımlara gidin.

İçin Emacs yarı manuel birleştirme çatışmaları çözmek isteyen kullanıcılar:

git diff --name-status --diff-filter=U

çakışma çözümü gerektiren tüm dosyaları gösterir.

Bu dosyaların her birini tek tek veya tümünü bir kerede açın:

emacs $(git diff --name-only --diff-filter=U)

Emacs'da düzenleme gerektiren bir arabelleği ziyaret ederken yazın

ALT+x vc-resolve-conflicts

Bu üç tampon açacaktır (benimki, onlarınki ve çıktı tamponu). 'N' (sonraki bölge), 'p' (ön bölge) tuşlarına basarak gezinin. Mine veya bölgelerini sırasıyla çıkış arabelleğine kopyalamak için 'a' ve 'b' tuşlarına basın. Ve / veya çıktı arabelleğini doğrudan düzenleyin.

Tamamlandığında: 'q' tuşuna basın. Emacs, bu arabelleği kaydetmek isteyip istemediğinizi sorar: Evet. Bir tamponu bitirdikten sonra, terminalden çalışarak çözülmüş olarak işaretleyin:

git add FILENAME

Tüm tampon tipleri ile işiniz bittiğinde

git commit

birleştirmeyi bitirmek için.

Bonus:

Yukarıdaki cevaplarda çekme / getirme / birleştirme konusundan bahsetmişken, ilginç ve üretken bir hile paylaşmak istiyorum,

git pull --rebase

Bu yukarıdaki komut git hayatımda çok zaman kazandıran en kullanışlı komuttur.

Yeni yaptığınız değişikliği uzak sunucuya aktarmadan önce, git pull --rebaseoldukça git pullve manuel olarak deneyinmerge en son uzak sunucu değişikliklerini (getirme + birleştirme ile) otomatik olarak senkronize eder ve yerel son taahhüdünüzü git günlüğünde en üste koyar. Manuel çekme / birleştirme konusunda endişelenmenize gerek yok.

Çatışma durumunda, sadece

git mergetool
git add conflict_file
git rebase --continue

Ayrıntıları şu adreste bulabilirsiniz: http://gitolite.com/git-pull--rebase

Basitçe, depolardan birindeki değişikliklerin önemli olmadığını ve diğer değişikliklerin lehine tüm değişiklikleri çözmek istiyorsanız, şunu kullanın:

git checkout . --ours

deponuzun lehine değişiklikleri çözmek için veya

git checkout . --theirs

diğeri veya ana depo lehindeki değişiklikleri çözmek .

Veya dosyaları tek tek incelemek, birleştirme aracının olduğunu söylemek p4mergeveya önceden yüklediğiniz herhangi birinin adını yazmak için bir GUI birleştirme aracı kullanmanız gerekecektir.

git mergetool -t p4merge

ve bir dosyayı bitirdikten sonra, kaydetmeniz ve kapatmanız gerekir, böylece bir sonraki dosya açılır.

Git'teki birleştirme çakışmalarını düzeltmek için lütfen aşağıdaki adımları izleyin:

1. Git durumunu kontrol etme: git durumu

2. Yama setini alın: git fetchYama (Git taahhüdünüzden doğru yamayı kontrol edin)

3. Yerel bir şubeyi kullanıma alma (buradaki örneğimde temp1 ): git checkout -b temp1

4. Son içerikleri master'dan çekin : git pull --rebase origin master

5. Birleştirme aracını başlatın ve çakışmaları kontrol edin ve düzeltin ... ve uzak daldaki değişiklikleri geçerli dalınızla kontrol edin: git mergetool

6. Durumu tekrar kontrol edin: git status

7. Birleştirme aracı tarafından yerel olarak oluşturulan istenmeyen dosyaları silin, genellikle birleştirme aracı * .orig uzantılı ek dosya oluşturur. Lütfen bu dosyayı, yalnızca yinelenen şekilde silin ve değişiklikleri yerel olarak düzeltin ve dosyalarınızın doğru sürümünü ekleyin. git add #your_changed_correct_files

8. Durumu tekrar kontrol edin: git status

9. Değişiklikleri aynı taahhüt kimliğine kaydedin (bu, yeni bir ayrı düzeltme eki kümesini önler): git commit --amend

10. Ana şubeye itme : git push (Git deponuza)

3 adım vardır:

1. Hangi dosyaların komutla çakışmalara neden olduğunu bulma

   git status
   

2. İşaretlenmiş çakışmaları bulacağınız dosyaları kontrol edin

   <<<<<<<<head
   blablabla
   

3. İstediğiniz şekilde değiştirin, ardından komutları uygulayın

   git add solved_conflicts_files
   git commit -m 'merge msg'
   

Birleştirme çakışmalarını, diğerleri ayrıntılı olarak açıklandığı gibi birkaç şekilde düzeltebilirsiniz.

Bence gerçek anahtar, değişikliklerin yerel ve uzak depolarda nasıl aktığını bilmek. Bunun anahtarı izleme dallarını anlamaktır. İzleme şubesini, aradaki yerel, gerçek dosya dizinim ve kökeni olarak tanımlanan uzaktan kumanda arasındaki 'ortadaki eksik parça' olarak düşündüğümü buldum.

Kişisel olarak bundan kaçınmak için 2 şey alışkanlığına girdim.

Onun yerine:

git add .
git commit -m"some msg"

İki dezavantajı var -

a) Tüm yeni / değiştirilmiş dosyalar eklenir ve istenmeyen bazı değişiklikler içerebilir.
b) Önce dosya listesini gözden geçiremezsiniz.

Bunun yerine şunu yapıyorum:

git add file,file2,file3...
git commit # Then type the files in the editor and save-quit.

Bu şekilde, hangi dosyaların ekleneceği konusunda daha kasıtlı olursunuz ve ayrıca mesaj için düzenleyiciyi kullanırken listeyi gözden geçirir ve biraz daha düşünürsünüz. -mSeçenek yerine tam ekran düzenleyici kullandığımda işlem mesajımı da iyileştirdiğini görüyorum .

[Güncelleme - zaman geçtikçe daha çok şeye geçtim:

git status # Make sure I know whats going on
git add .
git commit # Then use the editor

]

Ayrıca (ve durumunuzla daha alakalı), bundan kaçınmaya çalışıyorum:

git pull

veya

git pull origin master.

çünkü çekme bir birleştirme anlamına gelir ve yerel olarak birleştirilmesini istemediğiniz değişiklikleriniz varsa, birleştirilmiş kodla birleştirilebilir ve / veya birleştirilmemesi gereken kod için birleştirme çakışmaları yapabilirsiniz.

Bunun yerine yapmaya çalışıyorum

git checkout master
git fetch   
git rebase --hard origin/master # or whatever branch I want.

Bunu yararlı bulabilirsiniz:

git şube, çatal, getirme, birleştirme, rebase ve klon, farkları nelerdir?

CoolAJ86'nın yanıtı hemen hemen her şeyi özetliyor. Her iki dalda da aynı kod parçasında değişiklik olması durumunda manuel birleştirme yapmanız gerekecektir. Dosyayı çakışan herhangi bir metin düzenleyicisinde açın, aşağıdaki yapıyı görmelisiniz.

(Code not in Conflict)
>>>>>>>>>>>
(first alternative for conflict starts here)
Multiple code lines here
===========
(second alternative for conflict starts here)
Multiple code lines here too    
<<<<<<<<<<<
(Code not in conflict here)

Eşit işaretleri ve açılı parantezleri kaldırırken alternatiflerden birini veya her ikisinin bir kombinasyonunu yeni kod olmasını istediğiniz şekilde seçin.

git commit -a -m "commit message"
git push origin master

git log --merge -p [[--] path]

Her zaman benim için çalışmıyor gibi görünüyor ve genellikle iki dal arasında farklı olan her taahhüdü gösteriyor, bu bile kullanırken olur -- yolu komuttan ayırmak için .

Bu soruna geçici bir çözüm bulmak için iki komut satırı ve bir çalıştırmada açmak

git log ..$MERGED_IN_BRANCH --pretty=full -p [path]

ve diğerinde

git log $MERGED_IN_BRANCH.. --pretty=full -p [path]

$MERGED_IN_BRANCHBirleştirdiğim şube ve [path]çakışan dosya ile değiştiriyorum . Bu komut, ( ..) iki komisyon arasında yamaların tümünü kaydeder. Yukarıdaki komutlarda olduğu gibi bir tarafı boş bırakırsanız git otomatik olarak kullanılır HEAD(bu durumda birleştirdiğiniz dal).

Bu, iki dalda hangi taahhütlerin ayrıldıktan sonra dosyaya girdiğini görmenizi sağlayacaktır. Çatışmaları çözmeyi genellikle kolaylaştırır.

kullanma patience

Başka hiç kimsenin patiencebirleştirme özyinelemeli stratejisini kullanarak çatışmayı çözmekten bahsetmediğine şaşırdım . Büyük bir birleşme çatışması için, kullanmak patiencebenim için iyi sonuçlar verdi. Fikir, bireysel çizgilerden ziyade blokları eşleştirmeye çalışmasıdır.

Örneğin, programınızın girintisini değiştirirseniz, varsayılan Git birleştirme stratejisi bazen {farklı işlevlere ait olan tekli parantezlerle eşleşir . Bundan kaçınmak patience:

git merge -s recursive -X patience other-branch

Belgelerden:

With this option, merge-recursive spends a little extra time to avoid 
mismerges that sometimes occur due to unimportant matching lines 
(e.g., braces from distinct functions). Use this when the branches to 
be merged have diverged wildly.

Ortak ata ile karşılaştırma

Birleştirme çatışmanız varsa ve dallarını değiştirirken başkalarının aklından geçenleri görmek istiyorsanız, bazen dallarını doğrudan ortak ata ile (şubemiz yerine) karşılaştırmak daha kolaydır. Bunun için şunları kullanabilirsiniz merge-base:

git diff $(git merge-base <our-branch> <their-branch>) <their-branch>

Genellikle, yalnızca belirli bir dosyadaki değişiklikleri görmek istersiniz:

git diff $(git merge-base <our-branch> <their-branch>) <their-branch> <file>

12 Aralık 2016 itibarıyla, şubeleri birleştirebilir ve çatışmaları github.com'da çözebilirsiniz.

Bu nedenle, burada daha eski yanıtlardan sunulan komut satırını veya herhangi bir 3. taraf aracını kullanmak istemiyorsanız , GitHub'ın yerel aracına gidin.

Bu blog gönderisi ayrıntılı olarak açıklanmaktadır, ancak temel bilgiler, iki şubeyi kullanıcı arayüzü aracılığıyla 'birleştirdikten sonra, artık sizi bu birleştirme çakışmalarıyla başa çıkmanıza olanak tanıyan bir düzenleyiciye götürecek bir' anlaşmazlıkları çöz 'seçeneği göreceksiniz.

Daldan (test) master'a birleştirmek istiyorsanız, şu adımları takip edebilirsiniz:

Adım 1 : Şubeye git

git checkout test

2. Adım :

git pull --rebase origin master

Adım 3 : Bazı çakışmalar varsa, değiştirmek için bu dosyalara gidin.

4. Adım : Bu değişiklikleri ekleyin

git add #your_changes_files

5. Adım :

git rebase --continue

Adım 6 : Hala çakışma varsa tekrar 3. adıma geçin. Çakışma yoksa aşağıdakileri yapın:

git push origin +test

Adım 7 : Ve sonra test ve usta arasında bir çatışma yoktur. Birleştirmeyi doğrudan kullanabilirsiniz.

Çatışmalardan kaçınmak için her zaman aşağıdaki adımları izlerim.

• git checkout master (Ana şubeye gelin)
• git pull (En son kodu almak için ustanızı güncelleyin)
• git checkout -b mybranch (Yeni bir şubeye göz atın ve o dalda çalışmaya başlayın, böylece ustanız her zaman bagajın üstünde kalır.)
• git ekleyin. AND git commit AND git push (değişikliklerinizden sonra yerel şubenizde)
• git checkout master (Efendinize geri dönün.)

Şimdi aynı şeyi yapabilir ve istediğiniz kadar yerel şubeyi koruyabilir ve aynı anda çalışabilir ve gerektiğinde şubenize git çıkış yapıyorum.

Farklı durumlarda birleştirme çakışmaları olabilir:

• "Git fetch" ve ardından "git merge" çalıştırıldığında
• "Git getirme" ve ardından "git rebase" çalıştırıldığında
• "Git pull" çalıştırırken (aslında yukarıda belirtilen koşullardan birine eşittir)
• "Git stash pop" çalıştırılırken
• Git yamalarını uygularken (aktarılacak dosyalara aktarılan taahhütler, örneğin e-posta ile)

Çakışmaları gidermek için Git ile uyumlu bir birleştirme aracı yüklemeniz gerekir. Şahsen KDiff3 kullanıyorum ve güzel ve kullanışlı buldum. Windows sürümünü buradan indirebilirsiniz:

https://sourceforge.net/projects/kdiff3/files/

BTW Git Uzantıları'nı yüklerseniz kurulum sihirbazında Kdiff3'ü kurmak için bir seçenek vardır.

Daha sonra kurulum git, Kdiff'i birleştirme aracı olarak kullanacak şekilde yapılandırır:

$ git config --global --add merge.tool kdiff3
$ git config --global --add mergetool.kdiff3.path "C:/Program Files/KDiff3/kdiff3.exe"
$ git config --global --add mergetool.kdiff3.trustExitCode false

$ git config --global --add diff.guitool kdiff3
$ git config --global --add difftool.kdiff3.path "C:/Program Files/KDiff3/kdiff3.exe"
$ git config --global --add difftool.kdiff3.trustExitCode false

(Yolu, Kdiff exe dosyasının gerçek yolu ile değiştirmeyi unutmayın.)

Daha sonra bir birleştirme çatışmasıyla her karşılaştığınızda bu komutu çalıştırmanız yeterlidir:

$git mergetool

Sonra Kdiff3'ü açar ve önce birleştirme çakışmalarını otomatik olarak çözmeye çalışır. Çatışmaların çoğu kendiliğinden çözülecek ve gerisini elle düzeltmeniz gerekiyor.

Kdiff3 şöyle görünüyor:

Ardından, dosyayı kaydedin ve bir sonraki dosyaya çakışmalı olarak gidin ve tüm çakışmalar çözülene kadar aynı şeyi tekrarlayın.

Her şeyin başarıyla birleştirilip birleştirilmediğini kontrol etmek için, mergetool komutunu tekrar çalıştırın, bu sonucu almalısınız:

$git mergetool
No files need merging

Bu cevaplar, editör içindeki her şeyi yapmayı tercih eden benim gibi VIM kullanıcıları için bir alternatif eklemektir.

TL; DR

Tpope, kaçak denilen VIM için bu harika eklentiyi buldu . Yüklendikten sonra :Gstatusçakışan dosyaları kontrol etmek ve:Gdiff Git'i 3 yolla birleştirmek için çalıştırabilirsiniz.

Üçlü birleştirme işleminden sonra, kaçak aşağıdaki şekilde birleştirdiğiniz dallardan herhangi birinde değişiklik yapmanıza izin verir:

• :diffget //2, orijinal ( HEAD ) şubesinden değişiklik alın :
• :diffget //3, birleştirme şubesinden değişiklikler alın:

Dosyayı birleştirmeyi tamamladığınızda :Gwrite, birleştirilmiş arabelleği yazın. Vimcasts , bu adımları ayrıntılı olarak açıklayan harika bir video yayınladı .

VS Kodu İçin Gitlense

Gitlense'yi deneyebilirsiniz VS Kodu için , bunlar temel özellikler:

3. Çatışmaları Kolayca Çöz.

Bu özelliği zaten beğendim:

2. Mevcut Hat Suçlama.

3. Oluk Suçu

4. Durum Çubuğu Suçu

Ve burada kontrol edebileceğiniz birçok özellik var .

git getir
git checkout şubeniz
git git rebase master

Bu adımda tercih ettiğiniz IDE'yi kullanarak çakışmayı düzeltmeye çalışacaksınız

Https://help.github.com/articles/resolving-a-merge-conflict-using-the-command-line/ dosyasındaki çakışmayı gidermek için bu bağlantıyı takip
edebilirsiniz.

git add
git rebase --continue
git commit --amend
git push origin HEAD: refs / taslaklar / master (taslaklar gibi it)

Şimdi her şey yolunda ve gerrit taahhüdünüzü bulacaksınız

Umarım bu konu ile ilgili herkese yardımcı olur.

Henüz yapmadıysanız Visual Studio Code'u düzenlemek için deneyin. Birleştirmeyi denedikten sonra (ve birleştirme çakışmalarına düştüğünüz) .VS kodu birleştirme çakışmalarını otomatik olarak algılar.

Orijinalinde yapılan değişikliklerin neler olduğunu göstererek size çok yardımcı olabilir ve kabul etmelisiniz incoming veya

current change(birleşmeden önce orijinal olan anlamına gelir) '?

Bana yardımcı oldu ve sizin için de işe yarayabilir!

Not: Git'i kodunuz ve Visual Studio Code ile yapılandırdıysanız çalışır.

Çatışmaları çözmenin daha güvenli bir yolu git-mediate kullanmaktır (burada önerilen ortak çözümler oldukça hata eğilimli imho'dur).

Nasıl kullanılacağı hakkında hızlı bir giriş için bu gönderiye bakın .

Visual Studio kullananlar için (benim durumumda 2015)

1. Projenizi VS'de kapatın. Özellikle büyük projelerde VS, UI kullanarak birleştirilirken korkma eğilimindedir.

2. Komut isteminde birleştirmeyi yapın.

   git checkout Instagram Hesabındaki Resim ve Videoları target_branch

   git merge Instagram Hesabındaki Resim ve Videoları source_branch

3. Ardından projeyi VS'de açın ve Team Explorer -> Branch'e gidin. Şimdi Birleştirme işleminin beklemede olduğunu ve çakışan dosyaların iletinin hemen altında listelendiğini belirten bir ileti var.

4. Çakışan dosyayı tıkladığınızda Birleştirme, Karşılaştırma, Kaynak Alma, Hedef Alma seçeneklerine sahip olursunuz. VS'deki birleştirme aracının kullanımı çok kolaydır.

İntelliJ'yi IDE olarak kullanıyorsanız, üst öğeyi şubenizle birleştirmeye çalışın.

git checkout <localbranch>
git merge origin/<remotebranch>

Bunun gibi tüm çatışmaları gösterecek

A_MBPro: test anu $ git birleştirme başlangıç ​​noktası / Otomatik birleştirme src / test / java / com /.../ TestClass.java CONFLICT (içerik): src / test / java / com /.../ TestClass.java'da çakışmayı birleştir

Şimdi TestClass.java dosyasının intelliJ'de kırmızı renkte gösterildiğine dikkat edin.

Unmerged paths:
(use "git add <file>..." to mark resolution)
both modified:   src/test/java/com/.../TestClass.java

Dosyayı intelliJ ile açın, bölümleri

  <<<<<<< HEAD
    public void testMethod() {
    }
    =======
    public void testMethod() { ...
    }
    >>>>>>> origin/<remotebranch>

Burada KAFA yerel dalınızdaki ve başlangıç ​​noktanız / uzaktaki daldaki değişikliklerdir. Burada ihtiyacınız olan şeyleri saklayın ve ihtiyacınız olmayan şeyleri kaldırın.Ardından normal adımlar gerekir. Yani

   git add TestClass.java
   git commit -m "commit message"
   git push

Çakışmaları çözmek için Microsoft'un Görsel Kodunu kullanıyorum. Kullanımı çok basit. Projemi çalışma alanında açık tutuyorum. Çatışmaları algılar ve vurgular, ayrıca HEAD'den veya gelenlerden korumak istediğim değişikliği seçmek için GUI seçenekleri sunar.