Git Merge Nedir? Branch Birleştirme ve Merge Conflict Çözümü

Git Merge Nedir? Branch Birleştirme ve Merge Conflict Çözümü

Git ile yazılım geliştirirken farklı branch'ler üzerinde çalışmak oldukça yaygındır. Bir geliştirici yeni bir özellik hazırlarken başka bir geliştirici mevcut hataları düzeltebilir. Ancak bu çalışmalar tamamlandığında farklı branch'lerde bulunan değişikliklerin birleştirilmesi gerekir.

Git, farklı geliştirme hatlarını birleştirmek için git merge komutunu sunar.

Peki Git Merge tam olarak nedir? Branch'ler nasıl birleştirilir? Merge conflict neden oluşur ve nasıl çözülür?

Bu kapsamlı rehberde Git Merge komutunu, Fast-Forward Merge ve Three-Way Merge yöntemlerini, merge conflict çözümünü ve profesyonel projelerde güvenli birleştirme işlemlerini uygulamalı olarak öğreneceksiniz.

1. Git Merge Nedir?

Git Merge, farklı branch'lerde bulunan geliştirme geçmişlerini bir araya getirmek için kullanılan Git işlemidir.

Örneğin bir web sitesi geliştirdiğinizi düşünelim. Projenizin ana geliştirme branch'i main olsun.

Yeni bir kullanıcı giriş sistemi geliştirmek istediğinizde feature/login isimli bir branch oluşturabilirsiniz.

Bu branch üzerinde çalışarak kullanıcı giriş ekranını hazırlayabilir, gerekli kodları yazabilir ve değişikliklerinizi commit olarak kaydedebilirsiniz.

Geliştirme tamamlandığında feature/login branch'inde bulunan çalışmaları main branch'ine dahil etmek isteyebilirsiniz.

İşte bu noktada git merge kullanılır.

Temel kullanım:

git merge feature/login

Bu komut, feature/login branch'inin geçmişini o anda aktif olan branch'e birleştirmeye çalışır.

Önemli: Git merge komutunda belirtilen branch, değişikliklerin alınacağı branch'tir. Birleştirme işleminin hedefi ise mevcut aktif branch'tir.

2. Git Merge Neden Kullanılır?

Modern yazılım projelerinde birden fazla özelliğin aynı anda geliştirilmesi gerekebilir.

Örneğin bir e-ticaret uygulamasında aşağıdaki çalışmalar yürütülüyor olabilir:

• Kullanıcı giriş sisteminin geliştirilmesi
• Ödeme sayfasının hazırlanması
• Ürün arama özelliğinin eklenmesi
• Mobil görünüm hatalarının düzeltilmesi
• Veritabanı sorgularının iyileştirilmesi

Bu işlemlerin tamamını doğrudan main üzerinde gerçekleştirmek, geliştirme sürecinin kontrolünü zorlaştırabilir.

Bunun yerine ayrı feature branch'ler oluşturulabilir.

main
 |
 |--- feature/login
 |
 |--- feature/payment
 |
 |--- feature/search
 |
 |--- fix/mobile-menu

Her çalışma tamamlandıktan sonra uygun test ve kod inceleme süreçlerinden geçirilerek ana geliştirme hattına birleştirilebilir.

Git Merge bu çalışmaların aynı Git geçmişi içerisinde bir araya getirilmesini sağlar.

3. Git Merge Nasıl Çalışır?

Git Merge mantığını anlamak için basit bir commit geçmişi inceleyelim.

Örneğin başlangıçta projemizde üç commit bulunduğunu düşünelim:

A --- B --- C
            |
           main

Şimdi feature/login isminde yeni bir branch oluşturalım.

git switch -c feature/login

Bu branch üzerinde iki commit oluşturduğumuzu varsayalım.

A --- B --- C
             \
              D --- E
                    |
               feature/login

Bu aşamada main hâlâ C commit'ini göstermektedir. Feature/login ise E commit'ine ilerlemiştir.

Yeni geliştirmeyi main branch'ine dahil etmek için önce main'e geçeriz:

git switch main

Ardından:

git merge feature/login

Komutunu çalıştırırız.

Git, commit geçmişlerinin durumuna göre uygun bir birleştirme gerçekleştirir.

Git Merge işleminin nasıl sonuçlandığını anlamak için iki önemli kavramı öğrenmemiz gerekir: Fast-Forward Merge ve Three-Way Merge.

4. Fast-Forward Merge Nedir?

Fast-Forward Merge, hedef branch'in mevcut commit'i birleştirilecek branch'in geçmişinde bulunduğunda gerçekleşebilen birleştirme türüdür.

Bu durumda Git, yeni bir merge commit oluşturmadan hedef branch işaretçisini ileri taşıyabilir.

Örneğin:

A --- B --- C
             \
              D --- E
                    |
               feature/login

main = C

Main branch, feature/login oluşturulduktan sonra yeni bir commit almamıştır.

Bu nedenle Git uygun koşullarda main işaretçisini E commit'ine taşıyabilir.

Sonuç:

A --- B --- C --- D --- E
                        |
                       main
                        |
                   feature/login

Bu işlem sırasında zorunlu olarak yeni bir merge commit oluşturulmaz.

Fast-Forward Merge, commit geçmişinin doğrusal görünmesini sağlayabilir.

Fast-Forward Merge Komutu

Normal koşullarda aşağıdaki komut uygun olduğunda fast-forward birleştirme gerçekleştirebilir:

git merge feature/login

Yalnızca fast-forward mümkünse birleştirme yapılmasını istiyorsanız:

git merge --ff-only feature/login

Komutunu kullanabilirsiniz.

Bu komut fast-forward mümkün değilse merge işlemini reddeder.

5. Three-Way Merge Nedir?

Three-Way Merge, farklı branch'lerin ortak atalarını ve ayrı ayrı geliştirilmiş commit geçmişlerini dikkate alarak birleştirme yapılmasıdır.

Örneğin aşağıdaki yapıyı düşünelim:

          D --- E   feature/login
         /
A --- B --- C --- F   main

Bu örnekte branch'ler B commit'inden sonra ayrılmıştır.

Main üzerinde C ve F commit'leri oluşturulmuştur.

Feature/login üzerinde ise D ve E commit'leri bulunmaktadır.

Artık yalnızca main işaretçisini ileri taşımak yeterli değildir.

Git, ortak atayı ve iki geliştirme hattındaki değişiklikleri değerlendirerek birleştirme sonucu oluşturabilir.

Birleştirme başarılı olduğunda yeni bir merge commit oluşabilir.

          D --- E --------
         /                \
A --- B --- C --- F ------- M
                           |
                          main

Buradaki M yeni merge commit kaydını temsil eder.

Bu commit normal bir commit'ten farklı olarak iki ebeveyn commit'e sahiptir.

Böylece Git, hangi geliştirme hatlarının hangi noktada birleştiğini geçmiş içerisinde saklayabilir.

6. Fast-Forward ve Three-Way Merge Arasındaki Farklar

Özellik	Fast-Forward Merge	Three-Way Merge
Branch geçmişi	Hedef commit diğer branch'in atasıdır	Branch'ler farklı yönlerde ilerlemiştir
Yeni merge commit	Normalde oluşturulmaz	Genellikle oluşturulur
Commit grafiği	Doğrusal kalabilir	Birleşen geliştirme hatları görülebilir
Conflict ihtimali	Fast-forward işleminde içerik birleştirme çakışması oluşmaz	Çakışma oluşabilir
Kullanım	Doğrudan ilerletilebilen geçmişlerde	Ayrılmış geliştirme geçmişlerinde

Her iki yöntem de geçerli Git birleştirme yaklaşımlarıdır.

Hangi yöntemin tercih edileceği projenin ihtiyaçlarına ve ekibin çalışma düzenine bağlıdır.

7. Uygulama: İlk Git Merge İşlemimizi Yapalım

Şimdi öğrendiğimiz bilgileri gerçek bir Git projesinde uygulayacağız.

Serimizin dördüncü bölümünde feature/iletisim-sayfasi isimli bir branch oluşturmuş ve contact.html dosyasını bu branch üzerinde geliştirmiştik.

Bu bölümde o çalışmayı main branch'ine birleştireceğiz.

Adım 1: Proje Klasörünü Açın

Terminalinizi açın ve proje klasörünüze geçin:

cd ilk-git-projem

Ardından Git durumunu kontrol edin:

git status

Birleştirme işlemine başlamadan önce çalışma alanınızda kaydedilmemiş önemli değişiklikler bulunmadığından emin olun.

Gerekirse mevcut değişiklikleri uygun bir commit ile kaydedin veya güvenli şekilde stash kullanarak saklayın.

Adım 2: Branch'leri Listeleyin

git branch

Örnek çıktı:

* feature/iletisim-sayfasi
  main

Bu örnekte iletişim sayfasını geliştirdiğimiz feature branch aktif durumda.

Adım 3: Main Branch'e Geçin

Değişiklikleri main branch'ine birleştirmek istediğimiz için önce main'e geçmeliyiz.

git switch main

Ardından aktif branch'i kontrol edelim:

git branch --show-current

Beklenen çıktı:

main

Adım 4: Git Merge Komutunu Çalıştırın

Artık iletişim sayfası branch'ini main ile birleştirebiliriz.

git merge feature/iletisim-sayfasi

Main branch üzerinde başka commit oluşturulmadıysa birleştirme işlemi fast-forward yöntemiyle tamamlanabilir.

Bu durumda Git, feature branch'inde bulunan commit kayıtlarını main geçmişine dahil eder.

Başarılı birleştirme sonucunda contact.html dosyamız main branch üzerinde de bulunur.

Adım 5: Birleştirme Sonucunu Kontrol Edin

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

git status

Ardından commit geçmişini inceleyin:

git log --oneline --graph --all

Bu komut, commit geçmişini ve branch ilişkilerini terminal üzerinde görüntüler.

Fast-forward gerçekleştiyse yeni bir merge commit oluşmadan main işaretçisinin ileri taşındığını görebilirsiniz.

Adım 6: Değişiklikleri GitHub'a Gönderin

Main branch'iniz GitHub üzerindeki origin/main ile uygun şekilde yapılandırılmışsa:

git push origin main

Komutuyla yerel commit kayıtlarını GitHub'a gönderebilirsiniz.

İşlem başarılı olduğunda GitHub repository'nizdeki main branch güncellenir.

Tebrikler! İlk Git Merge işleminizi gerçekleştirdiniz.

8. Git Merge --no-ff Nedir?

Bazen fast-forward mümkün olsa bile ayrı bir merge commit oluşturmak isteyebilirsiniz.

Bu durumda Git'in --no-ff seçeneğini kullanabilirsiniz.

git merge --no-ff feature/login

Bu komut, normalde fast-forward yapılabilecek koşullarda bile merge commit oluşturulmasını sağlar.

Örneğin:

A --- B -------- M   main
       \        /
        C --- D     feature/login

Bu yaklaşım, belirli özelliklerin hangi birleştirme işlemiyle ana geliştirme hattına dahil edildiğini geçmiş üzerinde göstermeyi kolaylaştırabilir.

Ancak her özellik için ayrı merge commit oluşturmak zorunlu değildir.

Projeler, commit geçmişini düzenlemek için farklı stratejiler benimseyebilir.

9. Git Merge Conflict Nedir?

Git Merge sırasında karşılaşılabilecek en önemli durumlardan biri Merge Conflict yani birleştirme çakışmasıdır.

Merge conflict, Git'in farklı geliştirme hatlarındaki değişiklikleri otomatik olarak güvenli biçimde birleştiremediği durumlarda ortaya çıkar.

Örneğin iki geliştiricinin aynı dosyanın aynı satırını farklı biçimde değiştirdiğini düşünelim.

Main branch üzerinde:

Merhaba Nizokka Akademi!

Feature branch üzerinde:

Merhaba GitHub!

Her iki değişiklik de aynı başlangıç satırından geliştirilmişse Git hangi metnin korunması gerektiğine otomatik olarak karar veremeyebilir.

Bu durumda merge işlemi durur ve geliştiricinin çakışmayı çözmesi beklenir.

Merge conflict oluşması, Git deposunun bozulduğu anlamına gelmez.

Bu, birleştirme işleminin tamamlanabilmesi için kullanıcı kararına ihtiyaç duyulduğunu gösterir.

10. Merge Conflict Neden Oluşur?

Merge conflict farklı nedenlerle ortaya çıkabilir.

Aynı Satırın Farklı Şekilde Değiştirilmesi

En yaygın nedenlerden biri iki branch üzerinde aynı satırın farklı biçimlerde değiştirilmesidir.

Dosyanın Bir Branch'te Silinmesi

Bir geliştirici dosyayı silerken başka bir geliştirici aynı dosyanın içeriğini değiştirebilir.

Bu durumda Git, dosyanın korunması mı yoksa silinmesi mi gerektiğini belirlemek için kullanıcı müdahalesine ihtiyaç duyabilir.

Dosyaların Yeniden Adlandırılması

Farklı branch'lerde yapılan yeniden adlandırma ve içerik değiştirme işlemleri bazı koşullarda çakışma oluşturabilir.

Birbirine Bağımlı Değişiklikler

Git bazı değişiklikleri teknik olarak otomatik birleştirebilir. Ancak ortaya çıkan kod mantıksal olarak hatalı olabilir.

Bu nedenle merge işleminin çakışmasız tamamlanması, yazılımın mutlaka doğru çalıştığı anlamına gelmez.

Birleştirme sonrasında testlerin çalıştırılması önemlidir.

11. Uygulama: Bilerek Merge Conflict Oluşturalım

Merge conflict çözümünü öğrenmenin en etkili yollarından biri kontrollü bir çakışma oluşturmaktır.

Bu uygulamayı önceki projemizi etkilememek için tamamen ayrı bir eğitim klasöründe gerçekleştireceğiz.

Adım 1: Yeni Eğitim Projesi Oluşturun

Terminalde aşağıdaki komutları çalıştırın:

mkdir git-merge-deneme

cd git-merge-deneme

git init -b main

Bu komutlar yeni bir klasör ve main başlangıç branch'ine sahip Git deposu oluşturur.

Örneğimizde Git'in güncel bir sürümünü kullandığımızı varsayıyoruz.

Adım 2: İlk Dosyamızı Oluşturalım

Proje klasörünün içerisinde mesaj.txt isimli bir dosya oluşturun.

Dosyanın içerisine yalnızca şu satırı yazın:

Merhaba Dunya!

Dosyayı kaydedin.

Ardından terminalde:

git add mesaj.txt

git commit -m "İlk mesaj dosyası eklendi"

Komutlarını çalıştırın.

Artık main branch üzerinde ilk commit kaydımız bulunuyor.

Adım 3: Yeni Feature Branch Oluşturun

Şimdi ayrı bir geliştirme dalı oluşturalım:

git switch -c feature/selamlama

Bu komut feature/selamlama branch'ini oluşturur ve o branch'e geçer.

Adım 4: Feature Branch'teki Mesajı Değiştirin

mesaj.txt dosyasını açın.

Mevcut satırı silip aşağıdaki metni yazın:

Merhaba GitHub!

Dosyayı kaydedin.

Ardından:

git add mesaj.txt

git commit -m "GitHub selamlama mesajı eklendi"

Komutlarını çalıştırın.

Artık feature/selamlama branch üzerinde yeni bir commit oluşturduk.

Adım 5: Main Branch'e Geri Dönün

Terminale:

git switch main

Yazın.

Main branch'e döndüğünüzde mesaj.txt dosyasında başlangıçtaki içerik bulunacaktır.

Merhaba Dunya!

Çünkü feature branch üzerinde yapılan değişiklik henüz main branch'e birleştirilmemiştir.

Adım 6: Main Branch Üzerinde Aynı Satırı Değiştirin

Şimdi mesaj.txt dosyasını yeniden açın.

İçeriğini aşağıdaki metinle değiştirin:

Merhaba Nizokka Akademi!

Dosyayı kaydedin.

Ardından:

git add mesaj.txt

git commit -m "Akademi selamlama mesajı eklendi"

Komutlarını çalıştırın.

Artık iki branch, ortak başlangıç commit'inden sonra aynı satırı farklı biçimde değiştirmiştir.

Commit geçmişimiz kavramsal olarak şu şekildedir:

                  D   feature/selamlama
                 /
A --------------
                 \
                  B   main

D commit'i GitHub mesajını, B commit'i ise Nizokka Akademi mesajını içermektedir.

Adım 7: Merge İşlemini Başlatın

Main branch üzerinde olduğumuzdan emin olduktan sonra:

git merge feature/selamlama

Komutunu çalıştırın.

Git aşağıdakine benzer bir hata mesajı gösterecektir:

Auto-merging mesaj.txt

CONFLICT (content): Merge conflict in mesaj.txt

Automatic merge failed;
fix conflicts and then commit the result.

Tebrikler! İlk kontrollü merge conflict örneğimizi oluşturduk.

Şimdi bu çakışmayı çözeceğiz.

12. Merge Conflict Nasıl Çözülür?

Bir merge conflict meydana geldiğinde ilk yapılması gereken işlem hangi dosyaların çakıştığını belirlemektir.

Adım 1: Git Status Komutunu Çalıştırın

git status

Git aşağıdakine benzer bir bilgi gösterebilir:

Unmerged paths:

    both modified: mesaj.txt

Bu çıktı, mesaj.txt dosyasının her iki branch üzerinde değiştirildiğini ve birleştirme çakışması bulunduğunu gösterir.

Adım 2: Çakışan Dosyayı Açın

Şimdi mesaj.txt dosyasını Visual Studio Code veya kullandığınız başka bir metin düzenleyiciyle açın.

Dosyanın içerisinde aşağıdakine benzer işaretler görebilirsiniz:

<<<<<<< HEAD
Merhaba Nizokka Akademi!
=======
Merhaba GitHub!
>>>>>>> feature/selamlama

Bu işaretlere Conflict Markers adı verilir.

Git, hangi metnin hangi geliştirme hattından geldiğini göstermek için bu işaretleri kullanır.

Conflict Marker İşaretlerinin Anlamı

Birinci bölüm:

<<<<<<< HEAD
Merhaba Nizokka Akademi!

HEAD, bu örnekte mevcut aktif branch olan main'in sürümünü temsil eder.

İkinci işaret:

=======

Bu satır iki farklı değişiklik bölümünü birbirinden ayırır.

Üçüncü bölüm:

Merhaba GitHub!
>>>>>>> feature/selamlama

Bu bölüm birleştirmeye çalıştığımız feature/selamlama branch'inden gelen değişikliği gösterir.

Git bu iki değişiklikten hangisinin korunması gerektiğini belirleyemediği için karar vermemizi beklemektedir.

Adım 3: Hangi Değişikliğin Korunacağına Karar Verin

Merge conflict çözümünde birkaç farklı seçenek bulunur:

• Yalnızca mevcut branch'in değişikliğini korumak.
• Yalnızca diğer branch'in değişikliğini korumak.
• İki değişikliği birlikte kullanmak.
• Her iki değişiklikten farklı yeni bir çözüm hazırlamak.

Bu eğitimde iki değişikliği bir araya getireceğiz.

mesaj.txt dosyasındaki bütün conflict marker işaretlerini kaldırın.

Dosyanın son içeriğini aşağıdaki şekilde düzenleyin:

Merhaba GitHub ve Nizokka Akademi!

Dosyayı kaydedin.

Artık Git'in otomatik çözemediği çakışmayı manuel olarak çözmüş olduk.

Adım 4: Çözümü Staging Alanına Ekleyin

Terminalde:

git add mesaj.txt

Komutunu çalıştırın.

Bu işlemle Git'e mesaj.txt dosyasındaki çakışmanın çözüldüğünü bildirirsiniz.

Ardından durumu kontrol edin:

git status

Git artık bu dosya için çözülmemiş çakışma göstermemelidir.

Adım 5: Merge İşlemini Tamamlayın

Çakışmaları çözüp staging alanına ekledikten sonra:

git merge --continue

Komutunu çalıştırın.

Bu komut devam eden merge işlemini tamamlayarak merge commit oluşturulmasını sağlar.

Git commit mesajını düzenlemeniz için bir metin editörü açabilir.

Alternatif olarak çözüm tamamlandıktan sonra:

git commit -m "Selamlama branch çakışması çözüldü"

Komutunu kullanabilirsiniz.

Ancak aynı merge işlemi için her iki komutu art arda çalıştırmanız gerekmez. Bunlar tamamlamak için kullanılabilecek alternatif yöntemlerdir.

Adım 6: Sonucu Kontrol Edin

Merge tamamlandıktan sonra:

git status

Komutuyla çalışma alanını kontrol edin.

Ardından:

git log --oneline --graph --all

Komutunu çalıştırın.

Bu örnekte branch'ler ayrıldığı için Git geçmişinde iki geliştirme hattını birleştiren bir merge commit görüntülenmelidir.

Dosyanızın son içeriği ise:

Merhaba GitHub ve Nizokka Akademi!

Olacaktır.

Böylece ilk merge conflict çözümümüzü başarıyla tamamladık.

13. Git Merge --abort Nedir?

Bazen bir merge işlemi sırasında beklenmedik çakışmalar oluşabilir.

Çakışmayı hemen çözmek yerine birleştirme işleminden vazgeçmek isteyebilirsiniz.

Git bunun için aşağıdaki komutu sunar:

git merge --abort

Bu komut, devam eden merge işlemini iptal etmeye ve işlem öncesindeki durumu yeniden oluşturmaya çalışır.

Örneğin:

git merge feature/login

Komutunu çalıştırdınız ve conflict oluştu.

Birleştirme işlemini şimdilik iptal etmek için:

git merge --abort

Komutunu kullanabilirsiniz.

Ardından:

git status

Komutuyla mevcut durumu kontrol edin.

Önemli: Merge başlamadan önce kaydedilmemiş değişiklikler varsa Git bazı durumlarda bu değişiklikleri tamamen eski haline getiremeyebilir.

Bu nedenle önemli bir merge işleminden önce çalışma alanınızı temiz tutmak ve değişiklikleri güvenli biçimde kaydetmek önerilir.

14. Git Merge --continue ile Git Merge --abort Arasındaki Fark

Komut	İşlevi
git merge --continue	Çakışmalar çözüldükten sonra devam eden merge işlemini tamamlar.
git merge --abort	Devam eden merge işlemini iptal etmeye ve önceki durumu geri getirmeye çalışır.

Bu iki komut birbirinin alternatifi değildir.

Merge işlemini tamamlamak istiyorsanız --continue, vazgeçmek istiyorsanız --abort kullanılır.

15. Git Merge --squash Nedir?

Git'in sunduğu başka bir seçenek de squash işlemidir.

Örneğin bir feature branch üzerinde çok sayıda commit oluşturduğunuzu düşünelim:

feat: giriş ekranı eklendi

fix: buton hatası düzeltildi

style: giriş ekranı düzenlendi

docs: giriş açıklamaları eklendi

Bu değişiklikleri ana geliştirme hattında tek bir commit olarak kaydetmek isteyebilirsiniz.

Bu durumda aşağıdaki komut kullanılabilir:

git merge --squash feature/login

Bu işlem, feature branch'in birleştirme sonucundaki değişikliklerini staging alanında hazırlar.

Ancak normal git merge işleminden farklı olarak branch geçmişini bir merge commit ile birleştirmez ve otomatik commit oluşturmaz.

Uygun koşullarda değişiklikleri kaydetmek için:

git commit -m "Kullanıcı giriş özelliği eklendi"

Komutunu çalıştırabilirsiniz.

Squash işlemi, özellik geliştirme sırasında oluşan küçük commit'leri ana geliştirme hattında daha toplu göstermek isteyen ekipler için faydalı olabilir.

16. Git Merge ile Git Rebase Arasındaki Fark

Git Merge ve Git Rebase, farklı geliştirme geçmişlerini bir araya getirme amacıyla kullanılabilen iki farklı yaklaşımdır.

Ancak çalışma yöntemleri aynı değildir.

Git Merge, farklı geliştirme hatlarını birleştirir ve gerektiğinde merge commit oluşturur.

Git Rebase, belirli commit'leri farklı bir başlangıç noktası üzerinde yeniden uygulayarak geliştirme geçmişini düzenler.

Özellik	Git Merge	Git Rebase
Temel amaç	Geliştirme geçmişlerini birleştirmek	Commit'leri yeni bir temel üzerinde yeniden uygulamak
Commit geçmişi	Mevcut geçmişi koruyarak birleştirebilir	Yeniden uygulanan commit'lerin kimliklerini değiştirir
Merge commit	Gerektiğinde oluşturur	Standart kullanımda doğrusal geçmiş oluşturur
Çakışma ihtimali	Bulunur	Bulunur
Paylaşılan geçmiş	Genellikle mevcut geçmişi korur	Yeniden yazma nedeniyle dikkat gerektirir

Git Rebase özellikle commit geçmişini düzenlemek için faydalıdır. Ancak daha önce ekip arkadaşlarıyla paylaşılmış commit'lerin yeniden yazılması sorunlara neden olabilir.

Bu nedenle rebase işlemleri dikkatli kullanılmalıdır.

Git Rebase konusunu serimizin dokuzuncu bölümünde ayrıntılı olarak inceleyeceğiz.

17. GitHub Üzerinde Merge İşlemi Nasıl Yapılır?

Git Merge yalnızca terminal üzerinden kullanılmaz. GitHub da branch'lerdeki değişikliklerin incelenmesi ve birleştirilmesi için araçlar sunar.

GitHub üzerinde yaygın kullanılan yöntemlerden biri Pull Request oluşturmaktır.

Örneğin feature/login branch'inde yeni bir özellik geliştirdiğinizi düşünelim.

Bu branch'i GitHub'a göndermek için:

git push -u origin feature/login

Komutunu kullanabilirsiniz.

GitHub üzerinde ilgili repository'yi açtıktan sonra feature/login branch'inden main branch'ine bir Pull Request oluşturabilirsiniz.

Pull Request sayesinde ekip üyeleri:

• Yapılan kod değişikliklerini inceleyebilir.
• Yorumlar ve öneriler ekleyebilir.
• Otomatik test sonuçlarını kontrol edebilir.
• Gerekli düzeltmeleri isteyebilir.
• Uygun koşullarda değişiklikleri birleştirebilir.

GitHub, repository ayarlarına bağlı olarak Merge pull request, Squash and merge ve Rebase and merge gibi farklı birleştirme seçenekleri sunabilir.

Ancak Pull Request oluşturmak ile git merge komutunu doğrudan çalıştırmak aynı işlem değildir.

Pull Request, kod inceleme ve entegrasyon için bir iş akışı sağlar.

Git Merge ise commit geçmişlerini birleştiren Git işlemidir.

18. Visual Studio Code ile Merge Conflict Çözümü

Merge conflict çözmek için terminal kullanmak zorunlu değildir.

Visual Studio Code gibi kod editörleri, çakışan değişiklikleri görsel olarak incelemeye yardımcı olabilir.

Visual Studio Code üzerinde bir merge conflict oluştuğunda editör, ilgili dosyada çakışan bölümleri gösterebilir.

Kullanılan editör sürümüne ve görünümüne bağlı olarak şu tür seçeneklerle karşılaşabilirsiniz:

• Mevcut değişikliği kabul etme.
• Gelen değişikliği kabul etme.
• Her iki değişikliği kabul etme.
• Birleştirme sonucunu manuel düzenleme.

Ancak otomatik seçimlerin her zaman doğru sonucu üretmeyebileceğini unutmayın.

Özellikle JavaScript, PHP veya Python gibi programlama dillerinde çakışma çözüldükten sonra kodun söz dizimini ve çalışma mantığını kontrol etmek gerekir.

Çözüm tamamlandıktan sonra dosyayı kaydedip Git durumunu inceleyebilirsiniz:

git status

Ardından çözülmüş dosyayı staging alanına ekleyin:

git add dosya-adi

Devam eden merge işlemini tamamlamak için:

git merge --continue

Komutunu kullanabilirsiniz.

19. Git Merge Conflict Oluşmasını Nasıl Azaltabiliriz?

Merge conflict tamamen ortadan kaldırılamasa da doğru geliştirme alışkanlıklarıyla çakışma ihtimali azaltılabilir.

Küçük ve Anlamlı Commit'ler Oluşturun

Birbirinden bağımsız çok sayıda değişikliği tek bir commit içerisinde toplamak yerine mantıksal olarak ilişkili değişiklikleri ayrı commit'lerde kaydedin.

Feature Branch'leri Uzun Süre Açık Tutmayın

Uzun süre ana geliştirme hattından ayrı kalan branch'lerde değişiklik farklılıkları büyüyebilir.

Uygun sıklıkta entegrasyon yapmak çakışmaları yönetmeyi kolaylaştırabilir.

Ekip İçi İletişimi Güçlendirin

Aynı dosyanın aynı bölümlerinde çalışan geliştiricilerin birbirlerinden haberdar olması gereksiz çakışmaları azaltabilir.

Kodun Sorumluluklarını Ayırın

İyi yapılandırılmış yazılım projelerinde farklı özelliklerin ayrı modüllerde bulunması, bağımsız geliştirme çalışmalarını kolaylaştırabilir.

Birleştirme Öncesinde Testleri Çalıştırın

Merge conflict oluşmasa bile birleştirilen kodlar çalışma zamanında hatalara neden olabilir.

Bu nedenle mümkün olduğunda otomatik testler, kod analizi ve manuel kontroller gerçekleştirilmelidir.

20. Git Merge Yaparken Karşılaşılan Yaygın Hatalar

Hata 1: Already Up to Date

Aşağıdaki mesajla karşılaşabilirsiniz:

Already up to date.

Bu mesaj genellikle birleştirmek istediğiniz branch'in ilgili commit geçmişinin mevcut branch tarafından zaten içerildiğini gösterir.

Dolayısıyla Git'in yeni bir birleştirme işlemi gerçekleştirmesi gerekmeyebilir.

Hata 2: You Have Not Concluded Your Merge

Git, önceki merge işlemi tamamlanmadığında yeni bir birleştirme başlatmanıza izin vermeyebilir.

Bu durumda:

git status

Komutuyla devam eden merge işlemini kontrol edin.

Çakışmaları çözüp işlemi tamamlayabilir veya uygun koşullarda git merge --abort kullanabilirsiniz.

Hata 3: Local Changes Would Be Overwritten

Merge sırasında yerel değişikliklerinizin üzerine yazılma ihtimali varsa Git işlemi durdurabilir.

Bu durumda mevcut değişiklikleri inceleyin:

git status

git diff

Ardından değişikliklerinizi uygun bir commit ile kaydedebilir veya geçici olarak stash içerisinde saklayabilirsiniz.

Hata 4: Not Something We Can Merge

Aşağıdakine benzer bir hata alabilirsiniz:

merge: feature/unknown -
not something we can merge

Bu hata genellikle belirtilen branch veya referansın Git tarafından bulunamadığı durumlarda ortaya çıkar.

Öncelikle branch isimlerini kontrol edin:

git branch -a

Uzak branch referanslarının güncellenmesi gerekiyorsa:

git fetch origin

Komutunu kullanabilirsiniz.

Hata 5: Conflict Marker İşaretlerini Dosyada Bırakmak

Merge conflict çözerken en yaygın hatalardan biri çakışma işaretlerinin yanlışlıkla dosyada bırakılmasıdır.

Örneğin:

<<<<<<< HEAD
=======
>>>>>>> feature/login

Bu işaretler JavaScript veya PHP gibi dosyalarda söz dizimi hatalarına neden olabilir.

Bu nedenle conflict çözümünden sonra dosyaları kontrol edin.

Birleştirme sırasında Git tarafından çözülmüş olarak staging alanına alınan dosyalardaki boşluk hatalarını kontrol etmek için uygun koşullarda:

git diff --cached --check

Komutundan yararlanabilirsiniz.

Ancak bu komut, tüm mantıksal veya söz dizimsel hataları tespit etmez. Kod inceleme ve testler yine gereklidir.

21. Git Merge Komutları Hızlı Referans Tablosu

Komut	Açıklama
git merge branch-ismi	Belirtilen branch'i aktif branch ile birleştirir.
git merge --ff-only branch-ismi	Yalnızca fast-forward mümkünse birleştirir.
git merge --no-ff branch-ismi	Fast-forward mümkün olsa bile merge commit oluşturur.
git merge --squash branch-ismi	Birleştirme sonucunu tek commit hazırlığı olarak staging alanına alır.
git merge --abort	Devam eden merge işlemini iptal etmeye çalışır.
git merge --continue	Çakışmalar çözüldükten sonra merge işlemini tamamlar.
git status	Çakışan ve değiştirilen dosyaları gösterir.
git diff	Dosya değişikliklerini incelemeyi sağlar.
git log --oneline --graph --all	Commit ve branch geçmişini grafik biçiminde gösterir.
git add dosya-adi	Çözülmüş conflict dosyasını staging alanına ekler.
git push origin main	Uygun yerel main commit'lerini uzak depoya gönderir.

22. Sık Sorulan Sorular

Git Merge Nedir?

Git Merge, farklı Git branch'lerinde oluşturulan geliştirme geçmişlerini bir araya getirmek için kullanılan komuttur.

Git Merge Yapınca Branch Silinir mi?

Hayır. Git Merge işlemi kaynak branch'i otomatik olarak silmez. Branch'i artık kullanmayacaksanız uygun koşullarda ayrıca silebilirsiniz.

Git Merge Conflict Nedir?

Merge conflict, Git'in farklı branch'lerde bulunan bazı değişiklikleri otomatik olarak birleştiremediği durumdur. Bu durumda çakışan değişikliklerin manuel veya uygun araçlarla çözülmesi gerekir.

Merge Conflict Nasıl Çözülür?

Öncelikle git status ile çakışan dosyalar belirlenir. Ardından conflict marker işaretleri incelenerek dosya doğru içerikle düzenlenir. Çözüm git add ile staging alanına eklenir ve git merge --continue ile birleştirme tamamlanır.

Git Merge --abort Ne İşe Yarar?

Git merge --abort, devam eden merge işlemini iptal etmeye ve mümkün olduğunca işlem öncesindeki durumu geri getirmeye çalışır.

Fast-Forward Merge ile Normal Merge Arasındaki Fark Nedir?

Fast-forward merge, uygun commit geçmişlerinde branch işaretçisini ileri taşıyarak birleştirme yapar. Ayrılmış geliştirme geçmişlerinde ise genellikle iki ebeveynli yeni bir merge commit oluşturulur.

Git Merge ve Git Pull Aynı Şey mi?

Hayır. Git merge, commit geçmişlerini birleştirmek için kullanılır. Git pull ise uzak depodan değişiklikleri alıp yapılandırmaya bağlı olarak merge veya rebase ile entegre etmeye çalışır.

Git Merge Yapmadan Önce Commit Oluşturmak Gerekir mi?

Her durumda yeni bir commit oluşturmak zorunlu değildir. Ancak birleştirme öncesinde çalışma alanındaki önemli değişikliklerin güvenli biçimde kaydedilmiş olması önerilir.

Merge Conflict Oluşması Kötü Bir Şey mi?

Merge conflict, yazılım geliştirme sırasında karşılaşılabilen normal bir durumdur. Önemli olan çakışmanın nedenini anlamak, doğru çözümü uygulamak ve sonucu test etmektir.

GitHub Üzerinde Merge İşlemi Yapılabilir mi?

Evet. GitHub Pull Request sistemi üzerinden uygun izinler ve repository kuralları kapsamında branch'ler birleştirilebilir.

23. Sonuç: Git Merge ve Merge Conflict Çözümünü Öğrendik

Bu rehberde Git Merge komutunun ne işe yaradığını, farklı branch'lerin nasıl birleştirildiğini ve birleştirme sırasında karşılaşılabilecek sorunları öğrendik.

Fast-Forward Merge ve Three-Way Merge arasındaki farkları inceledik. Önceki bölümde oluşturduğumuz feature branch'i main ile birleştirdik.

Ardından ayrı bir eğitim projesinde gerçek bir merge conflict oluşturarak çakışmayı adım adım çözdük.

Ayrıca git merge --abort, git merge --continue, git merge --no-ff ve git merge --squash komutlarını öğrendik.

Git Merge, takım çalışmalarında ve profesyonel yazılım geliştirme süreçlerinde sık kullanılan temel araçlardan biridir.

Git ve GitHub Eğitim Serisi - Bölüm 6: Git Clone, Pull ve Fetch Komutları: GitHub Projelerini İndirme ve Güncelleme.

Bir sonraki bölümde GitHub üzerindeki projeleri bilgisayarımıza nasıl indireceğimizi, uzak repository'deki değişiklikleri nasıl alacağımızı ve git pull ile git fetch arasındaki farkları gerçek örneklerle inceleyeceğiz.

Nizokka Akademi üzerindeki Git, GitHub, JavaScript, PHP, Python ve diğer yazılım geliştirme eğitimlerini takip ederek programlama becerilerinizi geliştirmeye devam edebilirsiniz.

Kaynaklar ve Ek Okumalar

• Git Resmi Dokümantasyonu - git merge
• Pro Git - Basic Branching and Merging
• Git Resmi Dokümantasyonu - git mergetool
• GitHub Docs - Komut Satırında Merge Conflict Çözümü
• Git Resmi Dokümantasyonu - git status

```