Git Temel Komutları ve Kullanımı: Sürüm Kontrolüne Giriş

Hiç üzerinde çalıştığınız bir projenin eski bir sürümüne hızla geri dönme ihtiyacı hissettiniz mi? Ya da bir özelliği geliştirirken ana kod tabanına zarar vermekten endişe mi duydunuz? Belki de aynı kod üzerinde ekip arkadaşlarınızla birlikte çalışırken yaşanan karışıklıklar yüzünden başınız ağrıdı. İşte tam bu noktada, modern yazılım geliştirmenin temel taşlarından biri olan Git ve sürüm kontrol sistemleri devreye giriyor! Git, projelerinizin her bir değişikliğini kaydetmenize, farklı versiyonlarını yönetmenize ve ekip içinde sorunsuz bir işbirliği yapmanıza olanak tanır. Bu sayede kodunuzun geçmişini her zaman takip edebilir, hataları kolayca düzeltebilir ve güvenle yenilikler yapabilirsiniz.

Sürüm kontrol sistemleri (Version Control Systems – VCS), geliştiricilerin kod tabanında yaptıkları tüm değişiklikleri izlemelerine, bu değişiklikleri geriye doğru takip etmelerine ve gerekirse projenin herhangi bir noktasına geri dönmelerine imkan tanır. Dağıtık sürüm kontrol sistemi (DVCS) olan Git, geliştiricilerin kendi yerel depolarında projenin tam geçmişini tutmalarına olanak tanır. Bu, internet bağlantısı olmadan bile çalışabileceğiniz ve daha sonra değişikliklerinizi merkezi depoyla senkronize edebileceğiniz anlamına gelir. Bu esneklik, günümüzün uzaktan çalışan ve küresel yazılım geliştirme ekipleri için hayati öneme sahiptir, çünkü iş akışını kesintiye uğratmadan sürekli geliştirme ve entegrasyon imkanı sunar.

Peki, Git tam olarak ne tür sorunları çözer? Öncelikle, “Kim ne zaman neyi değiştirdi?” sorusunun cevabını her zaman bilirsiniz. Bir hata ortaya çıktığında, hatanın hangi değişiklikle geldiğini ve kimin yaptığını hızla tespit edebilirsiniz. İkincisi, deneysel özellikler geliştirmek istediğinizde, ana projenize zarar verme endişesi olmadan güvenle yeni “dallar” (branches) oluşturabilirsiniz. Bu, bir nevi projenizin paralel evrenlerini oluşturmak gibidir. Üçüncüsü ve belki de en önemlisi, ekip çalışması söz konusu olduğunda Git, karmaşıklığı en aza indirir. Birden fazla kişinin aynı anda farklı bölümler üzerinde çalışmasına ve daha sonra bu çalışmaları kolayca birleştirmesine olanak tanır. Çakışmalar (conflicts) yaşansa bile, Git bunları çözmek için güçlü araçlar sunar. Bu makalede, Git’in temel komutlarını, kullanım senaryolarını ve projelerinizde nasıl etkin bir şekilde uygulayacağınızı adım adım keşfedeceğiz. Hazırsanız, Git dünyasına dalmaya başlayalım!

Git’in Temel Taşları ve Kurulumu: Ortamınızı Nasıl Hazırlarsınız?

Git’i etkin bir şekilde kullanabilmek için, arkasındaki temel kavramları anlamak ve ardından doğru bir kurulum yapmak çok önemlidir. Bu kavramlar, Git’in nasıl çalıştığını ve komutların ne işe yaradığını daha iyi kavramanıza yardımcı olacaktır. Gelin, Git’in yapı taşlarını inceleyelim ve ardından sisteminize kurulumunu gerçekleştirelim.

Git’in Temel Kavramları:

• Depo (Repository): Projenizin tüm dosyalarını ve onların tüm geçmiş sürümlerini içeren bir veritabanıdır. Yerel (kendi bilgisayarınızda) ve Uzak (GitHub gibi bir sunucuda) olmak üzere iki ana türü bulunur.
• Commit (Kaydetme): Projenizin belirli bir andaki anlık görüntüsüdür. Yapılan mantıksal değişiklikleri (yeni özellik, hata düzeltmesi) benzersiz bir kimlik ve açıklayıcı bir mesajla kaydeder.
• Dal (Branch): Projenizin ana geliştirme hattından ayrılan bağımsız bir geliştirme yoludur. Ana kod tabanını etkilemeden yeni özellikler geliştirmek veya hataları düzeltmek için kullanılır.
• Birleştirme (Merge): Bir dalda yapılan değişiklikleri başka bir dala aktarma işlemidir. Genellikle, bir özellik dalındaki değişiklikler ana dala birleştirilir.
• Çalışma Dizini (Working Directory), Geçiş Alanı (Staging Area) ve Yerel Depo (Local Repository): Dosyalarınızın Git’teki üç ana durumunu temsil eder. Çalışma dizini, üzerinde aktif olarak çalıştığınız dosyaları; Geçiş Alanı, bir sonraki commit’e dahil etmek istediğiniz değişiklikleri; Yerel Depo ise kalıcı olarak kaydedilmiş commit geçmişini içerir.

Git Ortamını Kurma ve Hazırlama:

Git’i kullanmaya başlamanın ilk adımı, onu bilgisayarınıza kurmaktır. Neyse ki, Git birçok işletim sistemi için kolayca kurulabilir bir araçtır.

• Windows İçin: git-scm.com adresinden en güncel sürümü indirip kurulum sihirbazını takip edebilirsiniz.
• macOS İçin: Homebrew kullanıyorsanız, terminalde

  brew install git

  komutunu çalıştırın. Alternatif olarak, Xcode Command Line Tools ile

  xcode-select --install

  komutunu kullanabilirsiniz.

• Linux İçin: Çoğu Linux dağıtımında paket yöneticileriyle kolayca kurulabilir. Örneğin, Debian/Ubuntu için:

  sudo apt update && sudo apt install git

Kurulumun ardından, terminalinizde

git --version

yazarak Git'in başarılı bir şekilde yüklendiğini teyit edebilirsiniz.

İlk Yapılandırma ve Depo Oluşturma:

Git'i ilk defa kurduktan sonra, commit'lerinizle ilişkilendirilecek kullanıcı adınızı ve e-posta adresinizi ayarlamanız gerekir. Bu bilgiler, projenin geçmişinde kimin hangi değişikliği yaptığını takip etmek için kullanılır.

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

Yeni bir projeye başlıyor ve onu Git ile sürüm kontrolü altına almak istiyorsanız, proje dizininizde

git init

komutunu kullanmanız yeterlidir. Bu, .git adlı gizli bir klasör oluşturarak mevcut dizini bir Git deposuna dönüştürür. Eğer mevcut bir uzak depoyu kendi bilgisayarınıza getirmek istiyorsanız,

git clone https://github.com/kullanici/repo-adi.git

komutunu kullanarak projenin tüm geçmişiyle birlikte bir kopyasını alabilirsiniz. Artık Git ortamınız hazır ve temel komutlarla çalışmaya başlayabilirsiniz!

Temel Git Komutları ve Uygulamalı Kullanım: Günlük İş Akışında En Çok Kullanılan Git Komutları Nelerdir?

Git'in temel komutları, her gün karşılaşacağınız senaryolarda size yardımcı olacak en sık kullanılan araçlardır. Bu bölümde, bu komutları adım adım öğrenecek ve gerçek dünya senaryolarıyla pekiştireceğiz, böylece Git'i günlük iş akışınıza kolayca entegre edebilirsiniz.

1. git status: Projenizin Durumunu Kontrol Etmek
   Bu komut, çalışma dizininizdeki dosyaların Git tarafından nasıl algılandığını gösterir. Hangi dosyaların değiştirildiğini, geçiş alanına alındığını (staged) veya yeni olduğunu görebilirsiniz.

   git status

   Çıktı, hangi dalda olduğunuzu, hangi dosyaların izlendiğini veya izlenmediğini açıkça belirtir.

2. git add: Değişiklikleri Geçiş Alanına Alma
   Bir dosyada değişiklik yaptığınızda veya yeni bir dosya oluşturduğunuzda, bu değişiklikleri bir sonraki commit'e dahil etmek için geçiş alanına almanız gerekir.

   
   git add index.html          # Belirli bir dosyayı ekle
   git add .                   # Mevcut dizindeki tüm değişiklikleri ekle
               

   git add . komutu, tüm yeni ve değiştirilen dosyaları geçiş alanına ekleyerek toplu bir kaydetme işlemi için hazırlar.

3. git commit: Değişiklikleri Kaydetme
   Geçiş alanına aldığınız değişiklikleri kalıcı olarak yerel deponuza kaydetmek için kullanılır. Her commit'e, yapılan değişiklikleri açıklayan kısa ve öz bir mesaj eklemek çok önemlidir.

   git commit -m "Yeni kullanıcı arayüzü bileşenleri eklendi"

   -m parametresi, commit mesajını doğrudan komut satırında belirtmenizi sağlar.

4. git log: Commit Geçmişini İnceleme
   Deponuzdaki commit geçmişini görmek için kullanılır. Bu, hangi commit'lerin ne zaman yapıldığını, kimin yaptığını ve commit mesajlarını görmenizi sağlar.

   
   git log --oneline --graph --decorate
               

   Bu komut, daha okunabilir ve görsel bir geçmiş sunar.

5. git diff: Değişiklikleri Karşılaştırma
   Çalışma dizininizdeki, geçiş alanınızdaki ve deponuzdaki dosyalar arasındaki farkları görmenizi sağlar.

   
   git diff                    # Çalışma dizini ile geçiş alanı arasındaki farklar
   git diff --staged           # Geçiş alanı ile son commit arasındaki farklar
               

   Bu, bir commit yapmadan önce değişikliklerinizi gözden geçirmek için harika bir yoldur.

6. git push ve git pull: Uzak Depo ile Senkronizasyon
   Yerel deponuzdaki değişiklikleri uzak depoya göndermek (push) veya uzak depodaki değişiklikleri kendi yerel deponuza çekmek ve birleştirmek (pull) için kullanılır.

   
   git push origin main        # main dalındaki değişiklikleri 'origin' uzak deposuna gönder
   git pull origin main        # 'origin' uzak deposundaki main dalındaki değişiklikleri çek ve birleştir
               

7. git branch ve git checkout: Dallarla Çalışma
   Dallar, Git'in en güçlü özelliklerinden biridir. Yeni özellikler geliştirmek veya hataları düzeltmek için güvenle ayrı çalışma alanları oluşturmanıza olanak tanır.

   
   git branch                  # Depodaki tüm dalları listeler
   git branch feature/contact  # Yeni bir dal oluşturur
   git checkout feature/contact # Başka bir dala geçiş yapar
   git checkout -b feature/user-auth # Yeni dal oluştur ve hemen o dala geç
               

8. git merge: Dalları Birleştirme
   Bir dalda yaptığınız iş bittiğinde, bu değişiklikleri ana geliştirme hattına geri birleştirmeniz gerekir. Önce ana dala geçip sonra diğer dalı birleştirirsiniz.

   
   git checkout main
   git merge feature/user-auth
               

Vaka Analizi 1: Basit Bir Özellik Geliştirme Senaryosu

Bir web projesine yeni bir "hakkımızda" sayfası eklemeniz gerektiğini varsayalım. Bu senaryo, yukarıdaki temel komutların nasıl bir araya geldiğini gösterir.

1. Ana daldan yeni bir özellik dalı oluşturun ve o dala geçin:

   git checkout -b feature/about-page

2. Yeni sayfayı oluşturun: about.html dosyasını oluşturun ve içeriğini ekleyin.
3. Değişiklikleri geçiş alanına alın ve commit edin:

   
   git add about.html
   git commit -m "Yeni hakkımızda sayfası eklendi."
               

4. Ana geliştirme dalına geri dönün:

   git checkout main

5. Özellik dalını ana dalla birleştirin:

   git merge feature/about-page

6. Değişiklikleri uzak depoya gönderin:

   git push origin main

7. Artık özellik dalını silebilirsiniz (isteğe bağlı):

   git branch -d feature/about-page

Bu senaryo, Git'in dallanma ve birleştirme yeteneklerinin günlük geliştirme akışında ne kadar güçlü olduğunu göstermektedir. Ana dalda çalışmaya devam eden diğer ekip üyelerini etkilemeden, izole bir ortamda yeni özellikler geliştirebilirsiniz. Bu temel komutlarda ustalaşmak, Git ile etkili bir şekilde çalışmanın ilk ve en önemli adımıdır.

Çatışma Çözümü ve Geri Alma İşlemleri: Ortak Çalışmalarda Karşılaşılan Sorunlar Nasıl Çözülür?

Ekip olarak çalışırken veya aynı projenin farklı dallarında değişiklikler yaparken, Git'in değişiklikleri otomatik olarak birleştiremediği durumlarla karşılaşmak kaçınılmazdır. İşte bu durumlara "birleştirme çakışması" veya "merge conflict" denir. Ayrıca, bazen yanlış bir commit yaptığınızı veya önceki bir duruma geri dönmeniz gerektiğini fark edebilirsiniz. Git, bu tür durumlara yönelik güçlü çözüm mekanizmaları sunarak sizi zor durumdan kurtarır.

Çakışmalar Nasıl Ortaya Çıkar ve Nasıl Çözülür?

Bir çakışma, genellikle iki farklı dalda aynı dosyanın aynı satırında farklı değişiklikler yapıldığında ortaya çıkar ve Git, hangi değişikliğin doğru olduğuna karar veremez. Git, birleştirme işlemi sırasında bir çakışma tespit ettiğinde, size hangi dosyalarda çakışma olduğunu bildirir ve birleştirme işlemini duraklatır.

Çakışan bir dosyanın içeriği aşağıdaki gibi işaretlerle doldurulmuş olarak karşınıza çıkar:

<<<<<<< HEAD
Bu satır üzerinde bulunduğunuz daldaki hali.
=======
Bu satır birleştirmeye çalıştığınız daldaki hali.
>>>>>>> feature/yeni-ozellik
    

Burada HEAD ile ======= arasındaki kısım sizin geçerli dalınızdaki değişikliği, ======= ile >>>>>>> arasındaki kısım ise birleştirmeye çalıştığınız dalın değişikliğini gösterir.

Çakışma Çözme Adımları:

1. Çakışan Dosyayı Belirleyin: git status komutu hangi dosyaların çakıştığını gösterir.
2. Dosyayı Düzenleyin: Çakışan dosyayı bir metin düzenleyiciyle açın. Git'in eklediği <<<<<<<, ======= ve >>>>>>> işaretlerini kaldırın ve hangi kodun kalması gerektiğine karar vererek dosyayı manuel olarak düzenleyin.
3. Çözülen Dosyayı Geçiş Alanına Alın: Çakışmaları çözdükten sonra, dosyayı tekrar geçiş alanına almalısınız:

   git add <çakışan-dosya-adı>

4. Birleştirme Commit'ini Yapın: Tüm çakışmalar çözüldüğünde ve dosyalar geçiş alanına alındığında, birleştirme işlemini tamamlamak için bir commit yapın. Git, genellikle otomatik bir commit mesajı sunar, bunu kabul edebilir veya düzenleyebilirsiniz:

   git commit

Geri Alma İşlemleri: Yanlışları Düzeltme

Git, hatalar yaptığınızda size geri dönme yeteneği sunar. Ancak, farklı geri alma komutlarının farklı etkileri olduğunu anlamak önemlidir.

• git reset: Yerel deponuzdaki commit geçmişini değiştirir. En sık kullanılan parametresi --hard'dır.

  git reset --hard HEAD~1

  Bu komut, son commit'inizi geri alır ve aynı zamanda çalışma dizininizdeki ve geçiş alanınızdaki değişiklikleri de siler. Yani, dosya sisteminiz de önceki commit'in durumuna döner. Bu komutu dikkatli kullanmalısınız, özellikle uzak depoya gönderdiğiniz commit'ler üzerinde kullanmaktan kaçının.

• git revert: Var olan bir commit'in etkilerini geri alan, ancak yeni bir commit oluşturan bir komuttur.

  git revert 

  revert, geçmişi silmek yerine, önceki bir commit'i geri alan yeni bir commit oluşturarak proje geçmişini korur. Bu, özellikle paylaşılan (uzak depoya gönderilmiş) commit'leri geri almak için güvenli bir yöntemdir.

• git restore (veya git checkout ): Çalışma dizininizdeki veya geçiş alanınızdaki belirli dosyaları önceki durumlarına döndürür.

  
  git restore          # Çalışma dizinindeki değişiklikleri geri alır
  git restore --staged  # Geçiş alanındaki bir dosyayı çalışma dizinine geri alır
              

  Bu komutlar, henüz commit edilmemiş değişiklikleri geri almak için kullanışlıdır. Çakışma çözümünü ve geri alma işlemlerini doğru anlamak, Git ile güvenle çalışmanın anahtarıdır.

İleri Düzey Git İpuçları ve En İyi Uygulamalar: Git Yeteneklerinizi Nasıl Geliştirebilirsiniz?

Git'in temel komutlarında ustalaştıktan sonra, iş akışınızı daha da optimize edecek ve daha karmaşık senaryolarla başa çıkmanıza yardımcı olacak bazı ileri düzey ipuçları ve en iyi uygulamaları öğrenmek isteyebilirsiniz. Bu bölümde, günlük Git deneyiminizi bir üst seviyeye taşıyacak püf noktalarına değineceğiz, böylece sürüm kontrol becerilerinizi daha da geliştirebilirsiniz.

1. git stash: Geçici Değişiklikleri Saklama

Bazen bir dalda çalışırken, acil bir hata düzeltmesi veya farklı bir göreve geçmeniz gerekebilir, ancak henüz mevcut değişikliklerinizi commit etmeye hazır değilsinizdir. İşte bu durumlarda git stash imdadınıza yetişir. stash, çalışma dizininizdeki ve geçiş alanınızdaki değişiklikleri geçici olarak saklamanıza olanak tanır, böylece temiz bir çalışma dizinine sahip olursunuz.

git stash save "Acil düzeltme için değişiklikleri kaydet" # Değişiklikleri kaydet
git stash list                                        # Saklanan değişiklikleri listele
git stash pop                                         # Son saklanan değişiklikleri uygula ve stash'ten çıkar
    

2. .gitignore Dosyası: İstenmeyen Dosyaları İzlemeden Hariç Tutma

Her projenin, Git tarafından izlenmesini istemediğiniz dosyaları veya dizinleri vardır (örneğin derlenmiş dosyalar, log dosyaları, bağımlılık klasörleri). Bu dosyaları .gitignore adlı özel bir dosyaya ekleyerek Git'in bunları görmezden gelmesini sağlayabilirsiniz.

# .gitignore örneği
*.log
/tmp/
node_modules/
.env
    

Bu dosyayı projenizin kök dizinine yerleştirin. Git, bir commit işlemi sırasında bu dosyaları otomatik olarak atlayacaktır. Bu, deponuzun temiz kalmasını ve yalnızca önemli kod ve yapılandırma dosyalarının takip edilmesini sağlar, böylece gereksiz dosyalar geçmişi kirletmez.

3. Anlamlı Commit Mesajları Yazma

İyi commit mesajları, bir projenin tarihi boyunca gezinmeyi çok daha kolay hale getirir. Her commit mesajı, yapılan değişikliği açıkça belirtmeli ve neden yapıldığını anlatmalıdır. Genellikle şu format önerilir:

Tip: Konuyu en fazla 50 karakterle özetle

Açıklama (isteğe bağlı, bir boş satır bırakarak başla).
Bu kısım, değişikliğin neden yapıldığını,
hangi sorunu çözdüğünü veya hangi özelliği eklediğini
daha detaylı açıklar.
    

Kısa başlık,

git log --oneline

komutunu kullandığınızda okunabilirliği artırır. Detaylı açıklama ise, daha sonra bu commit'e geri döndüğünüzde veya başka bir ekip üyesi incelerken bağlamı anlamasını sağlar.

4. Branching Modelleri ve İş Akışları

Farklı ekipler ve projeler için optimize edilmiş çeşitli dallanma stratejileri (branching models) vardır. En popüler olanlardan ikisi:

• Git Flow: Daha yapılandırılmış bir modeldir ve genellikle büyük, uzun ömürlü projeler için uygundur. Birden fazla ana dal (master/main, develop) ve destekleyici dallar (feature, release, hotfix) kullanır.
• GitHub Flow: Daha basit ve çevik bir modeldir. Tek bir ana dal (main) ve ondan ayrılan kısa ömürlü özellik dalları kullanır. Özellik tamamlandığında, main dala birleştirilir ve hemen dağıtılır. Küçük ve hızlı projeler için idealdir.

Projenizin ve ekibinizin ihtiyaçlarına en uygun modeli seçmek, işbirliğini ve yayınlama süreçlerini önemli ölçüde kolaylaştıracaktır. Bu ileri düzey teknikler, Git'in sunduğu tüm esnekliği kullanmanıza ve sürüm kontrol deneyiminizi daha verimli hale getirmenize yardımcı olacaktır.

Sonuç ve Sıkça Sorulan Sorular: Git ile Sürüm Kontrolüne Hakim Olmak Neden Önemli?

Bu makale boyunca, Git'in temel kavramlarından başlayarak kurulumuna, günlük kullanılan komutlarına, çakışma çözümüne ve hatta ileri düzey ipuçlarına kadar birçok önemli konuyu ele aldık. Gördüğümüz gibi, Git sadece bir kod depolama aracı olmaktan çok daha fazlasıdır; modern yazılım geliştirme sürecinde ekiplerin verimli, güvenli ve organize bir şekilde çalışmasını sağlayan kritik bir platformdur.

Git sayesinde, her değişikliğinizi güvenle kaydedebilir, projenizin geçmişini tam şeffaflıkla takip edebilir ve potansiyel hataları hızla tespit edip düzeltebilirsiniz. Dallanma ve birleştirme yetenekleri, birden fazla kişinin aynı anda farklı özellikler üzerinde çalışmasına olanak tanırken, çakışma çözüm mekanizmaları işbirliğini sorunsuz hale getirir. Uzak depolarla senkronizasyon, küresel ekiplerin bile aynı kod tabanı üzerinde eşzamanlı çalışabilmesini mümkün kılar. Git'e hakim olmak, sadece bireysel bir geliştirici olarak yeteneklerinizi artırmakla kalmaz, aynı zamanda bir ekibin parçası olarak proje yönetimi ve işbirliği becerilerinizi de geliştirir. Bu, sektördeki talepleri karşılamanıza ve daha büyük, daha karmaşık projelere katkıda bulunmanıza yardımcı olacaktır. Umuyoruz ki bu rehber, Git yolculuğunuza güçlü bir başlangıç yapmanız için size ilham vermiştir. Şimdi sıra sizde: terminali açın ve Git ile harikalar yaratmaya başlayın!

Sıkça Sorulan Sorular (SSS)

Git ile GitHub/GitLab/Bitbucket arasındaki fark nedir?

Git, dağıtık bir sürüm kontrol sistemidir (DVCS), yani kodunuzun geçmişini yerel bilgisayarınızda yönetmenizi sağlayan bir yazılımdır. GitHub, GitLab ve Bitbucket ise Git depolarını barındıran web tabanlı platformlardır. Bu platformlar, kodunuzu uzak bir sunucuda depolamanıza, ekip üyeleriyle işbirliği yapmanıza, kod incelemeleri yapmanıza ve proje yönetimi araçlarına erişmenize olanak tanır. Yani Git temel araçtır, diğerleri ise bu aracı kullanarak kodunuzu paylaştığınız ve yönettiğiniz hizmetlerdir.

Ne sıklıkla commit yapmalıyım?

İdeal olarak, her mantıksal olarak anlamlı değişikliği ayrı bir commit olarak kaydetmelisiniz. Bu, küçük, odaklanmış ve işlevsel bir değişiklik anlamına gelebilir. Örneğin, yeni bir özellik eklemenin veya bir hatayı düzeltmenin her aşaması ayrı bir commit olabilir. Sık commit yapmak, projenizin geçmişini daha ayrıntılı hale getirir, hataları daha kolay izlemenizi ve geri almanızı sağlar. Genel kural, commit'lerinizin "bir bütün" olması ve anlamlı bir mesajla açıklanmasıdır.

Branch'leri ne zaman kullanmalıyım?

Yeni bir özellik geliştirmeye başladığınızda, bir hatayı düzeltmeniz gerektiğinde veya deneysel değişiklikler yapmak istediğinizde her zaman yeni bir dal (branch) oluşturmalısınız. Bu, ana kod tabanını (genellikle main veya master dalı) stabilize eder ve diğer ekip üyelerinin çalışmalarını etkilemeden kendi başınıza çalışmanıza olanak tanır. İşiniz bittiğinde ve değişiklikleriniz test edildiğinde, dalınızı ana dala geri birleştirebilirsiniz.

Yanlışlıkla commit'lediğim bir şeyi nasıl silerim?

Bu durum, commit'in uzak depoya gönderilip gönderilmediğine bağlıdır:

• Henüz uzak depoya göndermediyseniz (yerel): git reset HEAD~1 komutuyla son commit'i geri alabilir ve değişiklikleri çalışma dizininizde tutarak düzenleyebilirsiniz. git reset --hard HEAD~1 ise commit'i ve çalışma dizininizdeki tüm değişiklikleri tamamen siler.
• Uzak depoya gönderdiyseniz (paylaşılan): git revert komutunu kullanmak en güvenli yöntemdir. Bu, orijinal commit'i geri alan yeni bir commit oluşturur, böylece projenin geçmişini bozmadan değişiklikleri iptal etmiş olursunuz. Paylaşılan depolarda geçmişi yeniden yazmaktan kaçınılmalıdır.

Git'i terminalden mi GUI'den mi kullanmalıyım?

Her ikisinin de avantajları vardır. Terminalden (komut satırı) Git kullanmak, komutların mantığını daha iyi anlamanızı sağlar, daha esnek ve güçlüdür. GUI (Grafiksel Kullanıcı Arayüzü) araçları (örneğin GitKraken, SourceTree) ise görsel bir arayüz sunarak karmaşık işlemleri daha anlaşılır hale getirebilir ve yeni başlayanlar için daha az korkutucu olabilir. Genellikle, temel komutları terminalden öğrenmek ve daha sonra görsel bir arayüzle desteklemek, en iyi yaklaşımdır.