Bu rehber, yeni bir projenin bir git deposuna nasıl aktarılacağını, değişikliklerin nasıl yapılacağını ve değişikliklerin diğer geliştiricilerle nasıl paylaştırılacağını acıklar.

Oncelikle, bir komut icin yazılmış belgeyi her zaman aşağıdaki komut ile goruntuleyebilirsiniz: Orneğin git log --graph belgesini goruntulemek icin:

Kod:
$ man git-log
Başlamadan once git'e adınız ve e-posta adresinizi vermeniz onerilir. Bunu yapmanın en kolay yolu:

Kod:
$ git config --global user.name "Adınız ve Soyadınız Buraya" $ git config --global user.email [email protected]
Komutlarını calıştırmaktır.

Yeni Bir Projeyi Aktarmak

Varsayalım, proje klasorunde başladığınız bir iş var. Projenizi git surum kontrolune vermek icin icin:

Kod:
$ cd proje $ git init
Git'in cevabı aşağıdaki gibi olacaktır:

Alıntı:
Initialized empty Git repository in .git/
Yeni bir calışma dizini başlattınız. -- .git adında yeni bir dizin yaratıldığını farketmişsinizdir.

Şimdi, git'e gecerli dizindeki butun dosyaların bir goruntusunu almasını soyleyin (git-add komutundaki . işaretine dikkat edin):


Kod:
$ git add .
Bu goruntu, git'in "index" adını verdiği gecici bir alanda saklanır. Index'in iceriğini kalıcı olarak saklamak icin git-commit komutunu kullanın:

Kod:
$ git commit
Bu komut sizden bir teslim mesajı isteyecektir. Şimdi, projenizin ilk surumunu git icinde sakladınız.
Değişiklikler Yapmak

Birkac dosyayı değiştirin ve sonra guncellenmiş iceriği index'e ekleyin:


Kod:
$ git add dosya1 dosya2 dosya3
Teslim icin hazırsınız, Nelerin teslim edilmek uzere olduğunu git-diff komutunu --cached seceneği ile kullanarak gorebilirsiniz:

Kod:
$ git diff --cached
(--cached olmadan, git-diff size, index'e eklenmemiş değişikliklerinizi gosterir.) Ayrıca, durumunuzun kısa bir ozeti icin git-status komutunu kullanabilirsiniz:

Kod:
$ git status # On branch master # Changes to be committed: # (use "git reset HEAD ..." to unstage) # # modified: dosya1 # modified: dosya2 # modified: dosya3 #
Yapacağınız başka değişiklikler varsa, bu aşamada yapın ve değişen dosyaları index'e ekleyin. Sonunda, yaptığınız değişiklikleri teslim etmek icin:

Kod:
$ git commit
Sizden tekrar yaptığınız değişiklikleri acıklayan bir mesaj isteyecektir, ardından projenizin yeni bir surumunu kaydedecektir.

Her dosya icin, git-add kullanmak yerine, şunu kullanabilirsiniz:

Kod:
$ git commit -a
Bu komut otomatik olarak iceriği değişen dosyaları fark edecek, ( yeni dosyaları değil ) onları index'e ekleyecek ve teslim edecektir, hepsi bir adımda.

Teslim mesajları hakkında: Zorunlu olmasa da, teslim mesajlarına değişikliği ozetleyen kısa bir cumle ile (50 karakterden az) başlamanız onerilir. İlk satırın ardından bir satır boşluk daha ekleyin ve sonra daha fazla acıklama girin. Teslimleri e-posta olarak gonderen araclar, ilk satırı konu başlığı, kalan kısmı ise mesaj metni olarak kullanırlar.
Git icerikleri takip eder, dosyaları değil

Bircok surum kontrol sistemi, bir add komutu sunar, bu komut sisteme yeni bir dosya icin değişiklikleri izlemesini bildirir. Git ile gelen add komutu daha basit ve guclu bir iş yapar: git-add komutu, hem yeni hem de değişen dosyalar icin kullanılır ve iki durum icin de dosyaların ve ortamın goruntusunu, bir sonraki teslim icin kaydeder.
Proje gecmişini goruntulemek

Herhangi bir noktada, yaptığınız değişikliklerin gecmişini aşağıdaki komut ile gorebilirsiniz:

Kod:
$ git log
Ayrıca, her adımda yaptığınız değişikliklerin tamamını gormek icin şunu kullanın:

Kod:
$ git log -p
Genellikle, değişikliklerin ozetini gormek her adımı hatırlamakta faydalıdır.

Kod:
$ git log --stat --summary
Dalları yonetmek

Bir git deposu, geliştirmenin bircok dalını idare edebilir. "Deneysel" adında yeni bir dal yaratmak icin şunu kullanın:

Kod:
$ git branch deneysel
Şimdi şu komutu verdiğinizde

Kod:
$ git branch
var olan butun dalların bir listesini gorursunuz:

deneysel
* master

Deneysel dalı sizin şimdi yarattığınız dal ve "master" ise varsayılan dala verilen isimdir. Yıldız işareti, hangi dal uzerinde calıştığınızı gosterir, dal değiştirmek icin;

Kod:
$ git checkout deneysel
komutunu verin ve deneysel dala gecin. Şimdi bir dosyayı değiştirin, değişikliği teslim edin ve tekrar master dala geciş yapın:

(dosyalarda değişiklik yapın)
Kod:
$ git commit -a $ git checkout master
Şimdi yaptığınız değişikliklerin yerinde olmadığını bir kontrol edin. Yaptığınız değişiklikler deneysel dalda kaldı ve siz master dala gectiniz.

Ana dalda başka bir değişikilik daha yapın:

(dosyalarda değişiklik yapın)
Kod:
$ git commit -a
Bu noktada, iki dal birbirinden ayrıldı, ikisinde de farklı değişiklikler var. Deneysel dalda yapılan değişiklikleri master'da birleştirmek icin, şunu calıştırın:

Kod:
$ git merge deneysel
Eğer değişiklikler cakışmazsa, tamamdır. Cakışmalar varsa, şupheli dosyalar solunda bir işaret ile gosterilir;

Kod:
$ git diff
komutu bunu yapacaktır. Dosyaları duzenleyerek cakışmaları cozdukten sonra,

Kod:
$ git commit -a
komutu birleştirmenin sonucunu teslim edecektir. Son olarak,

Kod:
$ gitk
size gecmişteki değişikliklerin, gorsel bir temsilini sunacaktır.

Bu noktada, deneysel dalı silebilirsiniz:

Kod:
$ git branch -d deneysel
Bu komut deneysel dalda yapılan değişikliklerin, gecerli dalda da bulunduğunu kontrol eder.

Eğer cilgin-fikir dalında yaptığınız bir geliştirmeden pişman olduysanız o dalı silebilirsiniz:

Kod:
$ git branch -D cilgin-fikir
Dallar basit ve kolaydır, bir şeyleri denemenin iyi bir yoludur.
Birlikte calışma icin git kullanmak

Diyelim ki, Alice yeni bir proje başlattı ve git deposu da /home/alice/proje klasorunde, ve aynı bilgisayar uzerinde bir kullanıcı olan Bob katkıda bulunmak istiyor.

Bob şu komutla başlıyor:

Kod:
bob$ git clone /home/alice/proje depom
Bu komut depom adında yeni bir dizin oluşturur, bu dizin Alice'in deposunun tamamen bir kopyasıdır, ozgun projenin tum gecmişi ile birlikte.

Bob bazı değişiklikler yapar ve teslim eder:

(dosyalarda değişiklikler yapılır)
Kod:
bob$ git commit -a
(gerektikce tekrar edin)

Hazır olduğunda, Alice'e değişiklikleri /home/bob/depom adresinden cekmesini soyler. Alice bunu yapmak icin şu komutu uygular:

Kod:
alice$ cd /home/alice/proje alice$ git pull /home/bob/depom master
Bu komut Bob'un "master" dalındaki değişiklikleri, Alice'in gecerli dalıyla birleştirir. Eğer o sırada Alice'in de yaptığı değişiklikler varsa, cakışmaları elle duzeltmesi gerekebilir.


"pull" komutu iki işlem gercekleştirir: değişiklikleri uzak bir daldan alır ve gecerli dalda birleştirir.

Genellikle, Alice yaptığı değişiklikleri, "pull" işleminde once teslim etmek isteyecektir. Eğer Bob'un işi, gecmişleri catallandığından beri Alice'in yaptıklarıyla cakışıyorsa, Alice kendi calışma dizininde cakışmaları giderecek ve kendi değişiklikleri bu cakışmaların cozum surecinde ona engel olacaktır. (git, değişiklikleri cekecektir ancak birleştirme yapmayı reddedecektir --- Alice bir şekilde kendi değişikliklerinden kurtulacak ve tekrar uzaktaki değişiklikleri cekmeyi deneyecektir.)


Alice, birleştirmeyi yapmadan once, Bob'un ne yaptığına bakabilir ve değişikliklerin cekmeye değer olup olmadığına karar verebilir, bunun icin "fetch" komutu kullanılabilir;

Kod:
alice$ git fetch /home/bob/depom master alice$ git log -p HEAD..FETCH_HEAD
Alice, gecmişleri catallandığından bu yana Bob'un yaptığı değişiklikleri gorselleştirmek isterse, şu komutu kullanabilir:

Kod:
$ gitk HEAD..FETCH_HEAD
Bu komut git log ile gorduğumuz iki-noktalı aralık gosterimini kullanıyor.

Alice, catallanmadan sonra ikisinin de yaptıkları değişiklikleri gormek isterse uc-noktalı bicimi kullanmalı:

Kod:
$ gitk HEAD...FETCH_HEAD
Bu komutun anlamı, "her iki tarafta da olan değişiklikleri gosterme, taraflardan herhangi birinde olmayan değişiklikleri goster".

Bu aralık gosteriminin, hem gitk hem de "git log" ile kullanılabileceğini hatırlayın.

Bob'un ne yaptığını incelikten sonra, eğer onemli bir durum soz konusu değilse, Alice değişiklikleri Bob'dan cekmeden calışmaya devam edebilir. Bob'un gecmişi onemli bir değişiklik iceriyorsa, Alice geliştirmekte olduğu olduğu işi saklayabilir, bir "pull" komutu ile Bob'dan değişiklikleri cekebilir, sonra ortaya cıkan gecmiş uzerinde sakladığı dosyalarla calışmaya devam edebilir.

Bir topluluk icinde calışırken, genellikle bir depo ile tekrar tekrar calışırsınız. Uzak bir depo tanımı yaparak işinizi kolaylaştırabilirsiniz:

Kod:
alice$ git remote add bob /home/bob/depom
Aşağıdaki komutla, Alice cekme işleminin ilk kısmını git-fetch komutu ile, dalları birleştirmeden yapabilir:

Kod:
alice$ git fetch bob
Uzun haline gore, Alice Bob'dan değişiklikleri, git-remote ile kurulan uzak depo kısayolu ile cekmektedir. Cekilen ne varsa, bir uzak takip dalında tutulur. Bu durumda, dalın adı bob/master dır.

Kod:
alice$ git log -p master..bob/master
bu komut, Bob'un Alice'in master dalından ayrıldığı andan itibaren yaptığı değişiklikleri listeler.

Alice, bu değişiklikleri inceledikten sonra, değişiklikieri kendi master dalında birleştirmek isteyebilir:

Kod:
alice$ git merge bob/master
Bu merge(birleştirme) ayrıca, uzak takip dalından cekilerek de yapılabilir:

alice$ git pull . remotes/bob/master

Komut satırında ne verilirse verilsin, pull her zaman gecerli dal ile birleştirir.

Daha sonra Bob, deposunu Alice'in yaptığı değişikliklerle guncelleyebilir:

Kod:
bob$ git pull
Dikkat edin, Bob, Alice'in yaptığı değişiklikleri almak icin depo adresi vermedi. Bob, Alice'in deposunu kopyaladığı zaman, git deponun adresini kaydetti ve bu adresi cekme işlemi icin kullandı:

Kod:
bob$ git config --get remote.origin.url /home/alice/proje
(git-clone tarafından ayarlanan tum yapılandırma git config -l ile oğrenilebilir ve git-config(1) kılavuz sayfası her seceneğin ne anlama geldiğini acıklamaktadır.)

Git ayrıca, Alice'in bozulmamış master dalını da "origin/master" adı altında saklar:

Kod:
bob$ git branch -r origin/master
Bob başka bir makineden calışmak isterse, ssh protokolu ile kopyalama ve cekme yapabilir:

Kod:
bob$ git clone alice.org:/home/alice/proje depom
Ayrıca, git kendi yerel protokolune sahiptir, rsync ya da http kullanabilir, ayrıntılar icin git-pull(1) kılavuzuna bakınız.

Git ayrıca, CVS-benzeri bir şekilde merkezi bir depo ile kullanılabilir. Ayrıntılar icin git-push(1) ve gitcvs-migration(7).
Gecmişe yolculuk

Git gecmişi birbiriyle ilişkili teslimler halinde gosterir. git-log komutunun bu teslimleri listelediğini gorduk. Her bir kayıt girdisindeki ilk satırın, teslime verilen ad olduğunu unutmayın:

Kod:
$ git log
Alıntı:
commit c82a22c39cbc32576f64f5c6b3f24b99ea8149c7
Author: Junio C Hamano
Date: Tue May 16 17:18:22 2006 -0700
merge-base: Clarify the comments on post processing.

Biz bu adı, git-show komutuna vererek, teslim hakkındaki detaylara ulaşabiliriz:

Kod:
$ git show c82a22c39cbc32576f64f5c6b3f24b99ea8149c7
Teslimleri belirtmenin başka yolları da var. Teslim adının eşsiz kalacak kadar kısmını kullanabilirsiniz:

Kod:
$ git show c82a22c39c # ilk birkac karakter # genellikle yeterlidir. $ git show HEAD # gecerli daldaki değişiklikler $ git show experimental # deneysel daldaki değişiklikler
Hemen hemen her teslim, bir onceki durumu işaret eden bir ana-baba teslime sahiptir.

Kod:
$ git show HEAD^ $ git show HEAD^^ $ git show HEAD~4 $ git show HEAD^1 $ git show HEAD^2
Ayrıca, teslimlere kendi istediğiniz bir adı verebilirsiniz.

Kod:
$ git tag v2.5 1b2e1d63ff
1b2e1d63ff yerine "v2.5" kullanabilirsiniz. Eğer, bu adı başkalarıyla paylaşmak istiyorsanız (orneğin, bir surum belirlemek icin), bir "tag" nesnesi yaratmalı ve imzalamalısınız. Detaylar icin, git-tag(1).

Bir teslimin adına ihtiyac duyan her git komutu icin, bunlardan herhangi birini kullanabilirsiniz, orneğin:

Kod:
$ git diff v2.5 HEAD # HEAD ile v2.5 karşılaştırılır $ git branch kararli v2.5 # v2.5 temel alınarak # "kararli" adinda bir dal yaratır $ git reset --hard HEAD^ # Mevcut dalınızı iptal eder ve # durumunuzu HEAD^ oncesine cevirir.
Son komutu kullanırken dikkatli olun, son teslimden bu yana yaptığınız tum değişiklikleri siler ve teslim edilecek bir değişiklik bırakmaz. git-reset komutunu ortak calışılan bir depoda kullanmayın, bu diğer geliştiricilerin de gereksiz birleştirmeler yapmasına sebep verir. Ortak depoya gonderdiğiniz değişiklikleri geri almak icin git-revert komutunu kullanın.

git-grep komutunu herhangi bir metni, herhangi bir surum icinde aramak icin kullanabilirsiniz

Kod:
$ git grep "merhaba" v2.5
komutu v2.5 icinde "merhaba" gecen tum dosyaları arayacaktır.

Teslim adını vermezseniz, git-grep dizindeki butun dosyalarda arama yapacaktır.

Kod:
$ git grep "merhaba"
git ile takip edilen dosyalarda arama yapmanın kısa bir yoludur.

Bircok git komutu teslimlere gore calışabilir. İşte git-log ile bir ornek:

Kod:
$ git log v2.5..v2.6 # v2.5 ile v2.6 arasında yapılan teslimler. $ git log v2.5.. # v2.5'ten bu yana teslimler $ git log --since="2 weeks ago" # 2 haftadan bu yana teslimler $ git log v2.5.. Dosya # 2.5'ten itibaren dosyayı # değiştiren teslimler
Kod:
$ git log stable..deneysel
komutunu, deneysel dalda yapılan ancak kararli dalda bulunmayan teslimleri listelerken,

Kod:
$ git log deneysel..stable
komutunu, kararlı dalda yapılan ancak, deneysel dalda bulunmayan teslimleri listeler.

Kod:
$ gitk --since="2 weeks ago" drivers
Kod:
$ git diff v2.5:Makefile HEAD:Makefile.in
git-show komutunu dosyaları goruntulemek icin de kullanabilirsiniz:

Kod:
$ git show v2.5:Makefile
Kaynak : forum.ubuntu



__________________