Git Nasıl Kullanılır: Kapsamlı Bir Referans Rehberi

Git Nasıl Kullanılır: Kapsamlı Bir Referans Rehberi

Giriş: Sürüm Kontrol Sistemleri ve Git

Yazılım geliştirme dünyasında, projeler genellikle birden fazla kişi tarafından ortaklaşa yürütülür ve zaman içinde sayısız değişiklikten geçer. Bu karmaşık süreçte, yapılan her değişikliği takip etmek, farklı sürümleri yönetmek, hataları geri almak ve ekip üyeleri arasında koordinasyonu sağlamak hayati önem taşır. İşte tam bu noktada Sürüm Kontrol Sistemleri (Version Control Systems – VCS) devreye girer. VCS’ler, bir projenin tüm geçmişini kaydetmenize, belirli bir noktadaki durumuna geri dönmenize, farklı özellikler üzerinde eş zamanlı çalışmanıza ve ekip üyelerinin katkılarını sorunsuz bir şekilde birleştirmenize olanak tanır.

Sürüm Kontrol Sistemleri Nedir?

Sürüm kontrol sistemleri, dosyaların ve dizinlerin zaman içindeki değişikliklerini yöneten yazılımlardır. Temelde, projenizin her bir sürümünü bir anlık görüntü (snapshot) olarak kaydederler. Bu anlık görüntüler sayesinde, projenizin herhangi bir önceki durumuna kolayca geri dönebilir, kimin ne zaman hangi değişikliği yaptığını görebilir ve farklı geliştirme yollarını (dalları) izleyebilirsiniz. Merkezi (CVCS) ve Dağıtık (DVCS) olmak üzere iki ana kategoriye ayrılırlar. SVN ve CVS merkezi sistemlere örnekken, Git dağıtık bir sistemdir. Dağıtık sistemlerde, projenin tüm geçmişi her geliştiricinin yerel makinesinde bulunur, bu da daha fazla esneklik ve çevrimdışı çalışma yeteneği sağlar.

Git Neden Bu Kadar Popüler?

Git, Linus Torvalds tarafından 2005 yılında Linux çekirdeğinin geliştirilmesi için tasarlanmış dağıtık bir sürüm kontrol sistemidir. Kısa sürede tüm dünyada en yaygın kullanılan VCS haline gelmesinin birçok nedeni vardır:

* Hız: Git, diğer VCS’lere göre inanılmaz derecede hızlıdır. Çoğu işlem yerel olarak gerçekleştirilir, bu da ağ gecikmelerini ortadan kaldırır.
* Dağıtık Yapı: Her geliştiricinin projenin tam bir kopyasına sahip olması, merkezi bir sunucuya bağımlılığı ortadan kaldırır ve çevrimdışı çalışmayı mümkün kılar. Ayrıca, merkezi sunucunun çökmesi durumunda veri kaybı riskini azaltır.
* Dallanma ve Birleştirme (Branching & Merging): Git’in dallanma modeli oldukça hafif ve esnektir. Yeni özellikler veya hata düzeltmeleri üzerinde izole bir şekilde çalışmak, ardından bu değişiklikleri ana projeye kolayca birleştirmek çok basittir.
* Veri Bütünlüğü: Git, verileri SHA-1 hash’leri kullanarak saklar ve her nesnenin (commit, tree, blob) bütünlüğünü garanti eder. Bu, veri bozulmasını tespit etmeyi ve önlemeyi kolaylaştırır.
* Açık Kaynak ve Büyük Topluluk: Açık kaynaklı olması ve devasa bir geliştirici topluluğuna sahip olması, sürekli gelişimini ve geniş destek kaynaklarının bulunmasını sağlar.
* Esneklik: Git, çok çeşitli iş akışlarını destekler ve küçük kişisel projelerden büyük kurumsal projelere kadar her ölçekteki projede kullanılabilir.

Bu rehber, Git’i etkin bir şekilde kullanmak için bilmeniz gereken temel kavramları, komutları ve en iyi uygulamaları adım adım açıklayacaktır.

Git Temelleri ve Kurulum

Git’i kullanmaya başlamadan önce, sisteminize kurmanız ve temel yapılandırmaları yapmanız gerekir. Bu bölüm, Git’in kurulumunu ve ilk ayarlarını kapsar.

Git Kurulumu

Git, çoğu işletim sistemi için kolayca kurulabilir.

* Windows: Git’in resmi web sitesinden (git-scm.com) “Git for Windows” yükleyicisini indirebilirsiniz. Kurulum sırasında varsayılan seçenekleri kabul etmek genellikle yeterlidir. Bu, Git Bash (Unix benzeri komut satırı ortamı) ve Git GUI gibi araçları da kuracaktır.
* macOS: Xcode Komut Satırı Araçları’nı yükleyerek Git’i alabilirsiniz: xcode-select --install. Alternatif olarak, Homebrew paket yöneticisi ile brew install git komutunu kullanarak daha güncel bir sürüm yükleyebilirsiniz.
* Linux: Çoğu Linux dağıtımında Git, paket yöneticisi aracılığıyla kurulabilir.
* Debian/Ubuntu tabanlı sistemler: sudo apt update && sudo apt install git
* Fedora tabanlı sistemler: sudo dnf install git
* Arch Linux: sudo pacman -S git

Kurulumdan sonra, terminal veya komut istemcisinde git --version komutunu çalıştırarak Git’in doğru şekilde kurulup kurulmadığını ve sürümünü kontrol edebilirsiniz.

Temel Git Yapılandırması

Git’i ilk kez kurduktan sonra, commit’lerinizde kimliğinizin görünmesi için adınızı ve e-posta adresinizi yapılandırmanız önemlidir. Bu bilgiler, yaptığınız her değişiklikle birlikte kaydedilir.

git config --global user.name "Adınız Soyadınız"
git config --global user.email "eposta@adresiniz.com"

--global bayrağı, bu ayarların sisteminizdeki tüm Git depoları için geçerli olmasını sağlar. Eğer belirli bir depo için farklı bir isim veya e-posta kullanmak isterseniz, o deponun dizininde --global bayrağı olmadan aynı komutları çalıştırabilirsiniz.

Diğer faydalı yapılandırma ayarları şunlardır:

* Varsayılan Metin Düzenleyici: Git, commit mesajları gibi durumlarda bir metin düzenleyici açar. Varsayılanı değiştirmek için:

git config --global core.editor "nano" # veya "vim", "code --wait", vb.

* Renkli Çıktı: Git’in çıktısını daha okunaklı hale getirmek için renkli çıktıları etkinleştirebilirsiniz (çoğu kurulumda varsayılan olarak etkindir):

git config --global color.ui auto

* Alias’lar (Kısayollar): Sık kullandığınız komutlar için kısayollar oluşturabilirsiniz. Örneğin, git status yerine git st yazmak için:

git config --global alias.st status
    git config --global alias.co checkout
    git config --global alias.br branch
    git config --global alias.ci commit
    git config --global alias.lg "log --graph --pretty=format:'%Cred%h%Creset -%C(yellow)%d%Creset %s %Cgreen(%cr) %C(bold blue)%Creset' --abbrev-commit --date=relative"

Bu ayarları kontrol etmek için git config --list komutunu kullanabilirsiniz.

Git İş Akışı ve Temel Komutlar

Git’in temelini oluşturan üç ana durum ve bu durumlar arasında dosyaları hareket ettiren temel komutlar vardır. Bu bölüm, bir projenin başlangıcından itibaren temel Git işlemlerini açıklar.

Çalışma Dizini, Hazırlık Alanı ve Depo Kavramları

Git’in çalışma prensibini anlamak için üç ana durum veya alan kavramını bilmek önemlidir:

1. Çalışma Dizini (Working Directory): Projenizin dosyalarının bilgisayarınızda gördüğünüz, üzerinde çalıştığınız gerçek halidir. Bu alandaki dosyalar değiştirilebilir, eklenebilir veya silinebilir.
2. Hazırlık Alanı (Staging Area / Index): Bir sonraki commit’inize dahil etmek istediğiniz değişikliklerin toplandığı geçici bir alandır. git add komutuyla dosyaları bu alana eklersiniz. Bu, sadece belirli değişiklikleri commit etmenizi sağlar, çalışma dizininizdeki tüm değişiklikleri değil.
3. Yerel Depo (Local Repository): Projenizin tüm commit geçmişinin depolandığı yerdir. git commit komutuyla hazırlık alanındaki değişiklikler kalıcı olarak yerel depoya kaydedilir. Her commit, projenin belirli bir anlık görüntüsünü temsil eder.

Bu üç alan arasındaki ilişkiyi anlamak, Git’i etkili kullanmanın anahtarıdır.

Yeni Bir Depo Başlatma (git init)

Yeni bir Git deposu oluşturmak veya mevcut bir dizini Git ile yönetmeye başlamak için git init komutunu kullanırız.

# Yeni bir proje için:
mkdir yeni-proje
cd yeni-proje
git init

Bu komut, geçerli dizinde .git adında gizli bir alt dizin oluşturur. Bu dizin, Git’in projenin tüm sürüm geçmişini ve yapılandırmasını sakladığı yerdir.

Dosyaları Hazırlık Alanına Ekleme (git add)

Çalışma dizininizde yaptığınız değişiklikleri (yeni dosyalar, değiştirilen dosyalar, silinen dosyalar) bir sonraki commit’e dahil etmek için hazırlık alanına eklemeniz gerekir. Bu işlem git add komutuyla yapılır.

git add dosya.txt          # Belirli bir dosyayı ekle
git add klasor/            # Belirli bir klasördeki tüm dosyaları ekle
git add .                  # Mevcut dizindeki tüm değişiklikleri ekle (dikkatli kullanın)

git add . komutu, yeni eklenen dosyaları, değiştirilen dosyaları ve silinen dosyaları (eğer git rm ile silinmediyse) hazırlık alanına ekler.

Değişiklikleri Kaydetme (git commit)

Hazırlık alanındaki değişiklikleri yerel depoya kalıcı olarak kaydetmek için git commit komutunu kullanırız. Her commit, projenin o anki durumunun bir anlık görüntüsüdür ve benzersiz bir kimliğe (SHA-1 hash) sahiptir. Her commit’e anlamlı bir mesaj eklemek çok önemlidir.

git commit -m "İlk commit: Proje yapısı oluşturuldu"

-m bayrağı, commit mesajını doğrudan komut satırında yazmanızı sağlar. Eğer -m bayrağını kullanmazsanız, Git varsayılan metin düzenleyicinizi açarak mesajı yazmanızı isteyecektir. İyi bir commit mesajı, yapılan değişikliğin ne olduğunu ve neden yapıldığını açıkça belirtmelidir. Genellikle ilk satır kısa bir özet olur, ardından boş bir satır ve daha detaylı bir açıklama gelir.

Depo Durumunu Kontrol Etme (git status)

git status komutu, çalışma dizininizdeki ve hazırlık alanınızdaki mevcut durumu gösterir. Hangi dosyaların değiştirildiğini, hangilerinin hazırlık alanında olduğunu ve hangilerinin takip edilmediğini (untracked) gösterir.

git status

Bu komutun çıktısı size yol gösterici olacaktır:
* “Changes to be committed”: Hazırlık alanındaki dosyalar.
* “Changes not staged for commit”: Çalışma dizinindeki ancak hazırlık alanına eklenmemiş değiştirilmiş dosyalar.
* “Untracked files”: Git tarafından henüz takip edilmeyen yeni dosyalar.

Değişiklikleri Görüntüleme (git diff)

git diff komutu, iki farklı durum arasındaki değişiklikleri karşılaştırmanızı sağlar.

* Çalışma Dizini ile Hazırlık Alanı arasındaki fark:

git diff

Bu, henüz git add ile hazırlık alanına eklemediğiniz değişiklikleri gösterir.
* Hazırlık Alanı ile Son Commit arasındaki fark:

git diff --staged # veya git diff --cached

Bu, git add ile hazırlık alanına eklediğiniz ancak henüz commit etmediğiniz değişiklikleri gösterir.
* İki Commit arasındaki fark:

git diff commit_id1 commit_id2

Belirli commit’ler arasındaki farkı gösterir.

Dosyaları Silme ve Yeniden Adlandırma (git rm, git mv)

Git tarafından takip edilen dosyaları çalışma dizininden silmek ve bu değişikliği hazırlık alanına eklemek için git rm komutunu kullanırız.

git rm dosya.txt             # Dosyayı siler ve hazırlık alanına ekler
git rm -cached dosya.txt     # Dosyayı çalışma dizininde bırakır ama Git takibinden çıkarır

Dosyaları yeniden adlandırmak veya taşımak için git mv komutunu kullanmak en iyisidir. Bu, Git’in dosya geçmişini daha iyi takip etmesini sağlar.

git mv eski_ad.txt yeni_ad.txt

Her iki komut da değişiklikleri otomatik olarak hazırlık alanına ekler, bu yüzden ardından bir git commit yapmanız gerekir.

Commit Geçmişini İnceleme (git log)

git log komutu, projenin commit geçmişini gösterir. Her commit’in SHA-1 hash’ini, yazarını, tarihini ve commit mesajını listeler.

git log

git log komutu için birçok yararlı bayrak vardır:
* git log --oneline: Her commit’i tek bir satırda, kısa SHA ve mesajla gösterir.
* git log --graph: Commit geçmişini bir ASCII grafiği ile görselleştirir, dallanmaları ve birleştirmeleri gösterir.
* git log --pretty=format:"...": Çıktının formatını özelleştirmenizi sağlar.
* git log -p: Her commit ile birlikte yapılan değişiklikleri (yama formatında) gösterir.
* git log --author="Adınız": Belirli bir yazarın commit’lerini gösterir.
* git log --since="2 weeks ago": Belirli bir zamandan sonraki commit’leri gösterir.

Bu komutlar, projenizin geçmişini anlamak ve belirli değişiklikleri bulmak için paha biçilmezdir.

Dallanma ve Birleştirme (Branching & Merging)

Dallanma ve birleştirme, Git’in en güçlü özelliklerinden biridir ve modern yazılım geliştirme iş akışlarının temelini oluşturur. Bu özellikler, ekip üyelerinin aynı proje üzerinde paralel olarak, birbirlerinin çalışmalarını etkilemeden çalışmasına olanak tanır.

Dal Kavramı ve Önemi

Bir dal (branch), projenizin ana geliştirme hattından ayrılan bağımsız bir geliştirme yoludur. Yeni bir özellik geliştirmek, bir hatayı düzeltmek veya deneysel bir çalışma yapmak istediğinizde, genellikle ana daldan (çoğunlukla main veya master olarak adlandırılır) yeni bir dal oluşturursunuz. Bu, ana dalın istikrarlı kalmasını sağlarken, yeni çalışmalarınızı izole bir ortamda geliştirmenize olanak tanır. İşiniz bittiğinde, yaptığınız değişiklikleri ana dala geri birleştirebilirsiniz.

Dal Oluşturma (git branch)

Yeni bir dal oluşturmak için git branch komutunu kullanırız. Bu komut sadece yeni bir dal işaretçisi oluşturur, sizi o dala geçirmez.

git branch yeni-ozellik

Mevcut tüm dalları ve hangi dalda olduğunuzu görmek için:

git branch

Mevcut dalın yanında bir yıldız işareti (*) bulunur.

Dalları Değiştirme (git checkout)

Farklı bir dala geçmek veya belirli bir commit’e dönmek için git checkout komutunu kullanırız.

git checkout yeni-ozellik

Bu komut, çalışma dizininizi ve hazırlık alanınızı yeni-ozellik dalının son commit’ine göre günceller.

Git 2.23 ve sonraki sürümlerinde, yeni bir dal oluşturup ona doğrudan geçmek için git switch komutu ve yeni bir dal oluşturup ona geçmek için git restore komutu tanıtılmıştır. Ancak git checkout hala yaygın olarak kullanılmaktadır.

git checkout -b yeni-dal-adi # Yeni bir dal oluşturur ve o dala geçer

Dalları Birleştirme (git merge)

Bir dalda yaptığınız değişiklikleri başka bir dala (genellikle ana dala) entegre etmek için git merge komutunu kullanırız. Birleştirme işlemi, iki dalın ortak bir geçmişi olduğu durumlarda çalışır ve değişiklikleri birleştirerek yeni bir commit oluşturur.

Önce ana dala geçin:

git checkout main

Ardından yeni-ozellik dalını main dalına birleştirin:

git merge yeni-ozellik

Birleştirme işlemi sırasında farklı senaryolar ortaya çıkabilir:
* Fast-forward Merge: Eğer birleştirilen dal, hedef daldan ileriye gitmişse ve hedef dalda o zamandan beri yeni commit yoksa, Git sadece hedef dal işaretçisini ileriye taşır. Bu durumda yeni bir birleştirme commit’i oluşmaz.
* Three-way Merge: Eğer her iki dalda da ortak atadan sonra farklı commit’ler varsa, Git birleştirme işlemini gerçekleştirmek için bir birleştirme commit’i oluşturur.

Çakışmaların (Conflict) Çözümü: Eğer aynı dosyanın aynı satırlarında veya yakın bölgelerinde her iki dalda da farklı değişiklikler yapılmışsa, Git bu değişiklikleri otomatik olarak birleştiremez ve bir çakışma (conflict) bildirir. Bu durumda, Git dosyayı özel işaretleyicilerle (<<<<<<<, =======, >>>>>>>) işaretler ve çakışmayı manuel olarak çözmeniz gerekir.

1. git status ile çakışan dosyaları görün.
2. Çakışan dosyaları bir metin düzenleyiciyle açın ve işaretleyicileri kaldırarak istediğiniz son durumu oluşturun.
3. Çakışmayı çözdükten sonra dosyaları hazırlık alanına ekleyin: git add .
4. Birleştirme işlemini tamamlamak için commit yapın: git commit. Git genellikle otomatik olarak bir birleştirme mesajı oluşturur, bunu olduğu gibi kabul edebilir veya düzenleyebilirsiniz.

Dalları Silme (git branch -d)

Bir dalda yapılan değişiklikler başka bir dala başarıyla birleştirildikten sonra, o dala artık ihtiyacınız kalmadığında silebilirsiniz.

git branch -d yeni-ozellik

-d (delete) bayrağı, yalnızca birleştirilmiş dalları siler. Eğer bir dal birleştirilmemiş değişiklikler içeriyorsa ve onu silmek isterseniz, -D (force delete) bayrağını kullanmanız gerekir (dikkatli kullanın, veri kaybına yol açabilir).

git branch -D tehlikeli-dal

Uzak Dallarla Çalışma (git push, git pull, git fetch)

Yerel dallarınızın yanı sıra, uzak depolarda (GitHub, GitLab vb.) da dallar bulunur.

* git push -u origin yeni-ozellik: Yerel yeni-ozellik dalınızı origin adlı uzak depoya gönderir ve bir takip ilişkisi kurar. Artık sadece git push yazmanız yeterli olacaktır.
* git pull origin main: Uzak main dalındaki değişiklikleri çeker ve yerel main dalınızla birleştirir.
* git fetch origin: Uzak depodaki tüm dalların ve commit'lerin en güncel bilgilerini yerel deponuza indirir, ancak çalışma dizininizi veya yerel dallarınızı güncellemez. Bu, değişiklikleri birleştirmeden önce incelemek için kullanışlıdır.

Uzak Depolarla Çalışma

Git, dağıtık bir sistem olduğu için, birden fazla geliştiricinin aynı proje üzerinde çalışmasını sağlamak için uzak depolar (remote repositories) kullanılır. GitHub, GitLab, Bitbucket gibi platformlar, projelerinizi barındırmak ve ekip üyeleri arasında işbirliğini kolaylaştırmak için popüler uzak depo sağlayıcılarıdır.

Uzak Depo Ekleme (git remote add)

Mevcut bir yerel Git deponuzu bir uzak depoya bağlamak için git remote add komutunu kullanırız. Genellikle uzak deponuzun adı origin olarak belirlenir.

git remote add origin https://github.com/kullaniciadi/repo-adi.git

Bu komut, yerel deponuza origin adında bir takma ad tanımlar ve bu takma adı belirtilen URL ile ilişkilendirir. Artık uzak depoya başvurmak için uzun URL yerine origin kullanabilirsiniz.

Mevcut uzak depoları listelemek için:

git remote -v

Bu komut, uzak depoların adlarını ve URL'lerini (hem fetch hem de push için) gösterir.

Değişiklikleri Uzak Depoya Gönderme (git push)

Yerel deponuzdaki commit'leri uzak depoya göndermek için git push komutunu kullanırız. Bu, yaptığınız değişiklikleri başkalarının da görmesini ve erişmesini sağlar.

git push origin main

Bu komut, yerel main dalındaki commit'leri origin adlı uzak deponun main dalına gönderir. Eğer yerel dalınız henüz bir uzak dalla takip ilişkisi kurmadıysa, -u (upstream) bayrağını kullanarak bu ilişkiyi kurmanız gerekir:

git push -u origin main

Bundan sonra, sadece git push yazmanız yeterli olacaktır.

Uzak Depodaki Değişiklikleri Çekme (git pull, git fetch)

Ekip üyelerinizin uzak depoya gönderdiği değişiklikleri yerel deponuza almak için iki ana komut kullanılır:

* git fetch: Uzak depodaki tüm yeni commit'leri ve dalları yerel deponuza indirir, ancak çalışma dizininizi veya yerel dallarınızı değiştirmez. Bu, değişiklikleri yerel olarak birleştirmeden önce incelemenizi sağlar.

git fetch origin

git fetch komutundan sonra, uzak depodaki dalların güncel durumunu origin/main gibi adlarla görebilirsiniz.
* git pull: git fetch ve git merge komutlarının birleşimidir. Uzak depodaki değişiklikleri indirir ve mevcut yerel dalınızla otomatik olarak birleştirir.

git pull origin main

Bu komut, origin adlı uzak depodaki main dalındaki değişiklikleri çeker ve mevcut yerel dalınızla birleştirir. Eğer birleştirme sırasında çakışmalar olursa, bunları manuel olarak çözmeniz gerekir.

git fetch genellikle daha güvenli bir yaklaşımdır, çünkü değişiklikleri yerel deponuza indirdikten sonra onları inceleme ve manuel olarak birleştirme fırsatı verir. git pull ise hızlı bir şekilde güncel kalmak için kullanışlıdır, ancak çakışma potansiyelini artırabilir.

Değişiklikleri Geri Alma ve Düzenleme

Git'in en güçlü yanlarından biri, projenizin geçmişini esnek bir şekilde yönetebilmenizdir. Bu, hataları geri almanızı, commit'leri düzenlemenizi veya geçici değişiklikleri saklamanızı sağlar.

Hazırlık Alanından Dosya Çıkarma (git reset HEAD )

Yanlışlıkla hazırlık alanına eklediğiniz bir dosyayı (yani git add ile eklediğiniz ancak henüz commit etmediğiniz bir dosyayı) hazırlık alanından çıkarmak için git reset HEAD komutunu kullanırız.

git reset HEAD yanlis_dosya.txt

Bu komut, dosyayı hazırlık alanından kaldırır, ancak çalışma dizininizde değişiklikleri olduğu gibi bırakır. Böylece dosyayı tekrar düzenleyebilir veya hiç commit etmeyebilirsiniz. Git 2.23 sonrası sürümlerde git restore --staged de aynı işi görür.

Son Commit'i Geri Alma (git revert)

git revert komutu, belirli bir commit'in yaptığı değişiklikleri geri alan yeni bir commit oluşturur. Bu, projenin geçmişini değiştirmez, sadece "geri alma" işlemini yeni bir commit olarak kaydeder. Uzak depoya gönderilmiş (public) commit'leri geri almak için güvenli bir yöntemdir.

git revert HEAD # Son commit'i geri alır
git revert commit_id # Belirli bir commit'i geri alır

git revert komutundan sonra, geri alma commit'i için bir mesaj yazmanız istenecektir.

Değişiklikleri Geri Alma (git reset)

git reset komutu, daha güçlü ve esnek bir geri alma aracıdır, ancak geçmişi değiştirebildiği için dikkatli kullanılmalıdır, özellikle uzak depoya gönderilmiş commit'ler üzerinde. Üç ana modu vardır:

* git reset --soft : Belirtilen commit'e geri döner, ancak çalışma dizinindeki ve hazırlık alanındaki tüm değişiklikleri korur. Bu, son commit'i geri alıp, değişiklikleri hazırlık alanında tutarak yeni bir commit yapmak istediğinizde kullanışlıdır.
* git reset --mixed (Varsayılan): Belirtilen commit'e geri döner, hazırlık alanındaki değişiklikleri kaldırır, ancak çalışma dizinindeki değişiklikleri korur. Yani, değişiklikler çalışma dizininde "staged" olmayan (hazırlık alanında olmayan) durumdadır.
* git reset --hard : Belirtilen commit'e geri döner ve çalışma dizinindeki ve hazırlık alanındaki tüm değişiklikleri siler. Bu, en yıkıcı moddur ve tüm kaydedilmemiş değişikliklerinizi kalıcı olarak kaybedeceğiniz için çok dikkatli kullanılmalıdır.

git reset --hard HEAD~1 # Son commit'i tamamen siler ve çalışma dizinini önceki commit'in durumuna getirir.
                         # HEAD~1, HEAD'den bir önceki commit anlamına gelir.

git reset --hard komutunu, sadece yerel deponuzda ve henüz uzak depoya göndermediğiniz değişiklikler üzerinde kullanmalısınız.

Son Commit Mesajını Düzeltme (git commit --amend)

En son commit'inizin mesajını veya içeriğini (hazırlık alanına eklenmiş değişiklikleri) değiştirmek için git commit --amend komutunu kullanırız. Bu, son commit'i "yeniden yazar".

git commit --amend -m "Yeni düzeltilmiş commit mesajı"

Eğer -m bayrağını kullanmazsanız, Git varsayılan düzenleyicinizi açar ve mevcut commit mesajını düzenlemenize izin verir. --amend komutu sadece son commit üzerinde çalışır ve uzak depoya gönderilmemiş commit'ler için idealdir. Uzak depoya gönderilmiş bir commit'i amend ederseniz, push yaparken çakışmalar yaşarsınız.

Geçici Değişiklikleri Saklama (git stash)

Üzerinde çalıştığınız değişiklikleri commit etmeden başka bir dala geçmeniz gerektiğinde, ancak bu değişiklikleri kaybetmek istemediğinizde git stash komutunu kullanabilirsiniz. Bu, çalışma dizininizi temizler ve değişikliklerinizi geçici olarak bir "stash" yığınına kaydeder.

git stash save "Özellik X üzerinde yarıda kalan iş" # Değişiklikleri kaydeder
git stash list                                  # Kaydedilmiş stash'leri listeler
git stash pop                                   # En son kaydedilen stash'i uygular ve yığından kaldırır
git stash apply stash@{1}                       # Belirli bir stash'i uygular (yığından kaldırmaz)
git stash drop                                  # En son stash'i yığından kaldırır

git stash komutu, özellikle acil bir hata düzeltmesi yapmanız gerektiğinde veya farklı bir dala geçip başka bir işe başlamanız gerektiğinde çok kullanışlıdır.

Etiketleme (Tagging)

Git'te etiketleme, projenizin belirli noktalarına (genellikle önemli sürümlerine, örneğin v1.0, v2.0) kalıcı işaretler koymanızı sağlar. Bu etiketler, daha sonra bu belirli commit'lere kolayca başvurmak için kullanılır.

Etiket Oluşturma (git tag)

İki tür etiket vardır:
1. Hafif Etiketler (Lightweight Tags): Sadece belirli bir commit'e işaret eden bir pointer gibidir.

git tag v1.0.0

2. Açıklamalı Etiketler (Annotated Tags): Daha fazla bilgi (etiketleyen kişi, tarih, mesaj) içeren tam teşekküllü Git nesneleridir. Genellikle sürüm etiketleri için tercih edilir.

git tag -a v1.0.0 -m "Sürüm 1.0.0 yayınlandı"

Varsayılan olarak, etiketler HEAD'in (mevcut commit) üzerine yerleştirilir. Eğer geçmişteki bir commit'e etiket eklemek isterseniz, commit ID'sini belirtebilirsiniz:

git tag -a v0.9.0 9fceb02 -m "İlk beta sürümü"

Etiketleri Görüntüleme

Mevcut etiketleri listelemek için:

git tag

Belirli bir desene uyan etiketleri aramak için:

git tag -l "v1.0.*"

Bir etiketin detaylarını görmek için:

git show v1.0.0

Etiketleri Uzak Depoya Gönderme

Varsayılan olarak, git push komutu etiketleri uzak depoya göndermez. Etiketleri uzak depoya göndermek için açıkça belirtmeniz gerekir:

git push origin v1.0.0          # Belirli bir etiketi gönder
git push origin --tags          # Tüm yerel etiketleri gönder

Bir etiketi silmek için (yerelden ve uzaktan):

git tag -d v1.0.0                   # Yerel etiketi sil
git push origin :refs/tags/v1.0.0   # Uzak etiketi sil

Gelişmiş Konular ve En İyi Uygulamalar

Git'i daha verimli kullanmak ve projelerinizi daha iyi yönetmek için bazı gelişmiş konuları ve en iyi uygulamaları bilmek faydalıdır.

.gitignore Dosyası

Projenizde Git tarafından takip edilmesini istemediğiniz dosyalar veya dizinler olabilir (örneğin, derleme çıktıları, günlük dosyaları, bağımlılık klasörleri, kişisel ayar dosyaları). Bu tür öğeleri .gitignore adlı bir dosyaya ekleyerek Git'in bunları görmezden gelmesini sağlayabilirsiniz.

Örnek .gitignore içeriği:

# Log dosyaları
*.log
logs/

Derleme çıktıları
*.o
*.a
*.class
build/
dist/

Bağımlılık klasörleri (Node.js için)
node_modules/

Editör veya IDE dosyaları
.vscode/
.idea/

İşletim sistemi dosyaları
.DS_Store
Thumbs.db

.gitignore dosyası, projenizin kök dizininde yer almalıdır. Git, bu dosyayı okur ve listelenen desenlere uyan dosyaları ve dizinleri git add komutuyla bile hazırlık alanına eklemez.

Git İş Akış Modelleri (Feature Branch, Gitflow, GitHub Flow)

Büyük ekiplerde veya karmaşık projelerde, Git'in dallanma ve birleştirme özelliklerini nasıl kullanacağınızı tanımlayan belirli iş akış modelleri benimsemek, tutarlılığı ve düzeni sağlar.

* Feature Branch Workflow: En basit ve yaygın iş akışıdır. main (veya master) dalı her zaman kararlıdır. Yeni bir özellik veya hata düzeltmesi için main daldan yeni bir dal oluşturulur. İş bitince bu dal main'e birleştirilir ve silinir.
* GitHub Flow: Feature Branch Workflow'a benzer ancak daha basitleştirilmiştir. Genellikle sadece bir ana dal (main) vardır. Tüm yeni özellikler doğrudan main'den dallanır ve tamamlandığında main'e geri birleştirilir. Genellikle sürekli entegrasyon/sürekli dağıtım (CI/CD) ile birlikte kullanılır.
* Gitflow Workflow: Daha karmaşık ve büyük projeler için tasarlanmıştır. main ve develop olmak üzere iki ana uzun ömürlü dalı vardır. main dalı her zaman üretimde olan sürümü temsil ederken, develop dalı bir sonraki sürümün birleştirildiği daldır. Ayrıca feature, release ve hotfix gibi kısa ömürlü dalları da içerir. Daha fazla dallanma ve birleştirme kuralı gerektirir.

Seçtiğiniz iş akışı, ekibinizin büyüklüğüne, projenizin karmaşıklığına ve dağıtım sıklığına bağlı olmalıdır.

Rebase vs. Merge

Dalları birleştirmenin iki ana yolu vardır: git merge ve git rebase.

* git merge: İki dalın geçmişini birleştirerek yeni bir birleştirme commit'i oluşturur. Bu, dalların geçmişini korur ve yapılan birleştirme işlemini açıkça gösterir. Daha güvenli bir seçenektir, çünkü geçmişi değiştirmez.
* git rebase: Bir dalın commit'lerini başka bir dalın üzerine "yeniden temel alır". Bu, dalınızdaki commit'leri sanki hedef dalın en son commit'inden başlamış gibi yeniden yazar. Tarihçeyi daha doğrusal ve temiz hale getirir, ancak commit ID'lerini değiştirir.

# main dalına geç
git checkout main
feature dalını main üzerine rebase et
git rebase feature

git rebase komutunu, henüz uzak depoya gönderilmemiş (yerel) dallar üzerinde kullanmak en iyisidir. Uzak depoya gönderilmiş commit'leri rebase etmek, takım arkadaşlarınız için sorunlara yol açabilir çünkü geçmişi değiştirirsiniz. Genel kural, rebase'i yerel temizlik için, merge'i ise kamuya açık geçmişi birleştirmek için kullanmaktır.

Alt Modüller (Submodules)

Bir Git deposunu başka bir Git deposunun alt dizini olarak dahil etmeniz gerektiğinde Git alt modüllerini kullanabilirsiniz. Bu, bir projede harici bir kütüphaneyi veya başka bir Git projesini bağımlılık olarak yönetmek için kullanışlıdır.

git submodule add https://github.com/ornek/kutuphane.git lib/kutuphane

Alt modüllerin kendine özgü karmaşıklıkları vardır ve dikkatli yönetilmesi gerekir.

Git Hook'ları

Git Hook'ları, Git'teki belirli olaylar (örneğin, commit yapmadan önce, push yapmadan önce) gerçekleştiğinde otomatik olarak çalışan özel betiklerdir. Bu betikler, kod kalitesini zorlamak, testleri çalıştırmak veya belirli iş akışlarını otomatikleştirmek için kullanılabilir. Hook'lar .git/hooks dizininde bulunur.

Örnek olarak, bir pre-commit hook'u, bir commit yapılmadan önce kodunuzu biçimlendirebilir veya linting kontrolü yapabilir.

Sonuç

Git, modern yazılım geliştirmenin vazgeçilmez bir aracıdır. Bu rehber, Git'in temel kavramlarından başlayarak dallanma, birleştirme, uzak depolarla çalışma ve geçmişi yönetme gibi kritik konuları kapsayan kapsamlı bir referans sunmuştur. Her bir komutun ne işe yaradığını, nasıl kullanıldığını ve hangi durumlarda tercih edilmesi gerektiğini anlamak, Git'i etkin bir şekilde kullanmanın anahtarıdır.

Unutmayın ki Git'i öğrenmek bir süreçtir ve pratikle pekişir. Kendi projelerinizde farklı komutları denemekten çekinmeyin, ancak özellikle geçmişi değiştiren komutları (örneğin git reset --hard, git rebase) kullanırken dikkatli olun ve önemli değişiklikler yapmadan önce bir yedek almayı veya bir dalda çalışmayı alışkanlık haline getirin.

Git'in gücü, sadece bireysel geliştiricilerin değil, aynı zamanda büyük ekiplerin işbirliğini, verimliliğini ve proje kalitesini artırmasından gelir. Bu rehberdeki bilgileri kullanarak, Git'i projelerinizde güvenle uygulayabilir ve sürüm kontrolünü ustaca yönetebilirsiniz. Git dünyasında keşfedilecek daha birçok özellik ve gelişmiş teknik bulunmaktadır; öğrenmeye devam edin ve Git'in sunduğu tüm olanaklardan yararlanın!