Git Diff Açıklandı: Örneklerle Eksiksiz Kılavuz

Git diff, kod deponuzda gerçekleşen değişikliklere açılan pencerenizdir. Temelde, dosyalarınızın farklı durumları arasındaki farkları gösteren bir komuttur — ister mevcut çalışmanızı aşamaya aldıklarınızla kıyaslayın, ister dallar ve commit’ler arasındaki değişiklikleri karşılaştırın. Bunu Git’in “Ne değişti?” sorusuna verdiği cevap olarak düşünün. git diff çalıştırdığınızda, Git dosyaların içeriğini satır satır analiz eder, eklenen, kaldırılan veya değiştirilenleri belirler ve tam olarak neyin nerede değiştiğini vurgulayan standartlaştırılmış bir formatta sunar.

Git diff, commit’lenmeden önce değişikliklere net bir bakış sağlayarak geliştiricilerin kod kalitesini güvence altına almasına yardımcı olur. Burada, temel karşılaştırmalardan geliştirme iş akışınızı ve ekip iş birliğini iyileştirecek ileri tekniklere kadar bu vazgeçilmez komutu nasıl etkili kullanacağınızı ele alacağız.

Önkoşullar

Bu eğitimi takip etmek için şu Git kavramlarına aşina olmalısınız:

• Temel Git iş akışı (init, add, commit)
• Git depoları ve yapıları
• Dallar ve nasıl çalıştıkları
• Commit’ler ve commit geçmişi
• Aşama alanı (index)

Bu kavramları tazelemeniz gerekiyorsa, şu kaynaklar yardımcı olacaktır:

• Git Hızlı Başvuru — Yaygın Git komutları için hızlı referans
• Git’e Giriş kursu — Git temellerini öğrenen yeni başlayanlar için
• Yeni Başlayanlar için GitHub ve Git Eğitimi — Git ve GitHub’a pratik bir giriş
• Orta Düzey Git kursu — Git becerilerini ilerletmek isteyenler için

Örnekleri takip etmek için sisteminizde Git’in kurulu olması gerekir. Tüm komutlar terminal veya komut isteminden çalıştırılabilir.

Git Diff Neden Geliştiriciler İçin Vazgeçilmez?

Her geliştirici, tek başına çalışsa da yüzlerce kişilik bir ekipte olsa da kodunda nelerin değiştiğini bilmelidir. Git diff olmadan hangi satırları değiştirdiğinizi tahmin etmek zorunda kalır, bu da sorun gidermeyi ve iş birliğini neredeyse imkansız hale getirir.

Git diff, değişiklik yönetimi için esastır ve etkili inceleme süreçleriyle kaliteli yazılımın temelini oluşturur. Değişiklikleri incelerken, git diff yalnızca neyin değiştiğini değil, bu değişikliklerin neden önemli olduğunu anlamak için gereken bağlamı sağlar. 

Koddaki evrime doğrudan görünürlük sağlamak, ekiplerin standartları korumasına ve hataların canlı ortama taşınmasını engellemesine yardımcı olur.

Projeler karmaşıklık kazandıkça, git diff birkaç temel nedenle gerçekten vazgeçilmez hale gelir:

• Değişiklik doğrulama: Tam olarak neyi commit’lemek üzere olduğunuzu teyit edin; yanlışlıkla hata ayıklama kodu veya ilgisiz değişiklikler eklemeyi önleyin
• Bilgi aktarımı: Tüm dosyaları okumadan ekip arkadaşlarınızın neler yaptığını anlayın
• Çakışma çözümü: Birleştirmeler sırasında değişikliklerin nerede ve nasıl çakıştığını tam olarak belirleyin
• Tarihsel analiz: Belirli değişikliklerin ne zaman eklendiğini takip ederek hataları avlayın veya özellik evrimini anlayın
• Hedefe yönelik kod incelemeleri: Zaman kazandırmak ve inceleme kalitesini artırmak için dikkatinizi gerçekten değişen kod kısımlarına odaklayın

Git diff’i etkili kullanmak için, bu karşılaştırmaları mümkün kılan altyapıyı — Git’in “Üç Ağaç” modelini — anlamak gerekir.

Git’in Üç Ağaçlı Mimarisi

Git diff’i anlamak için önce Git’in temel “üç ağaç” mimarisini kavramanız gerekir. İsmine rağmen, bunlar dosya sistemindeki gerçek ağaçlar değil; kodunuzun bulunduğu üç ayrı durumdur. 

Bu durumları Git’in aynı anda takip ettiği üç farklı proje sürümü olarak düşünün: Çalışma Dizini (gerçek dosyalarınız), Aşama Alanı (veya index; değişikliklerin commit’e hazırlanacağı yer) ve Depo (.git dizininde saklanan projenizin commit geçmişi).

Kaynak: Hashnode

Çalışma Dizini, aktif olarak düzenlediğiniz dosyaları içerir — kodu yazdığınız, değişiklik yaptığınız ve çalışmanızı test ettiğiniz yer burasıdır. Aşama Alanı, bir sonraki commit’inize hangi değişikliklerin dahil edileceğini seçtiğiniz bir hazırlık alanı olarak görev yapar. Bunu, gönderilmeden önce paketlerin (değişikliklerinizin) düzenlendiği bir yükleme iskelesi gibi düşünebilirsiniz. 

Son olarak, Depo projenizin tam geçmişini commit serileri olarak saklar — belirli zaman noktalarındaki kodunuzun anlık görüntüleri, tarihsel bir zincir oluşturacak şekilde birbirine bağlanır.

Git diff, bu üç durumu çeşitli kombinasyonlarda karşılaştırarak çalışır. git diff argümansız çalıştırıldığında, Çalışma Dizininizi Aşama Alanıyla karşılaştırır ve yaptığınız ancak henüz aşamaya almadığınız değişiklikleri gösterir. 

git diff --staged kullanmak, Aşama Alanını son commit ile karşılaştırır ve bir sonraki commit’inize nelerin dahil edileceğini gösterir. 

Ve git diff HEAD, Çalışma Dizininizi doğrudan son commit ile karşılaştırarak, aşama durumundan bağımsız olarak tüm commit’lenmemiş değişiklikleri gösterir.

Bu karşılaştırma noktaları, Git’teki tüm diff işlemlerinin temelini oluşturur:

• Çalışma Dizini ↔ Aşama Alanı: Yaptığım ama henüz aşamaya almadığım değişiklikler neler? (git diff)
• Aşama Alanı ↔ Depo: Aşamaya aldığım ve sıradaki commit’te yer alacak değişiklikler neler? (git diff --staged)
• Çalışma Dizini ↔ Depo: Çalışan dosyalarım ile son commit arasındaki toplam fark nedir? (git diff HEAD)
• Commit’ler Arası: Kod, tarihteki belirli noktalar arasında nasıl evrildi? (git diff commit1-hash commit2-hash)

Bu mimariyi anlamak, kod tabanınızda tam olarak neyin, nerede ve ne zaman değiştiğini nokta atışı tespit etmek için git diff’i etkili kullanmanıza yardımcı olur.

Bu mimari kavrayışıyla, şimdi git diff komutlarını pratikte nasıl kullanacağımızı, kodunuzun bu üç durumda nasıl evrildiğine dair içgörü elde etmek için keşfedebiliriz.

Temel Git Diff Kullanımı

Git diff’i iş başında göstermek için örnek bir veri analizi projesi oluşturalım. Bu eğitim boyunca değiştirebileceğimiz Python betikleri, CSV verisi ve metin dosyalarından oluşan küçük bir depo kuracağız.

# Create and initialize our project
mkdir data-analysis-project
cd data-analysis-project
git init

# Create initial files
echo "# Data Analysis Project\nA sample project to demonstrate git diff functionality." > README.md
echo "import pandas as pd\n\ndef load_data(filename):\n return pd.read_csv(filename)\n\ndef analyze_data(data):\n return data.describe()" > analysis.py
echo "id,name,value\n1,alpha,10\n2,beta,20\n3,gamma,30" > data.csv
echo "DEBUG=False\nDATABASE_PATH=./data/" > config.txt
echo "def normalize_data(data):\n return (data - data.min()) / (data.max() - data.min())" > utils.py

# Make our first commit
git add .
git commit -m "Initial commit with basic project structure"

# Check the directory structure
> tree

.
├── README.md
├── analysis.py
├── config.txt
├── data.csv
└── utils.pyAltyapı:

Projemiz artık sürüm kontrolünde beş dosyaya sahip; bu da çeşitli diff senaryolarını göstermek için bir temel sunuyor. İlerledikçe, git diff’in farklı bağlamlarda değişiklikleri nasıl ortaya koyduğunu göstermek için bu dosyaları değiştireceğiz.

git diff sonuçlarını anlamak

Bir git diff komutu çalıştırdığınızda, çıktı neyin değiştiğini açıkça belirtmek için tasarlanmış standart bir formata uyar. Bir diff’i iş başında görmek için analysis.py dosyamızı değiştirelim:

# Update analysis.py with a new function
echo "import pandas as pd\n\ndef load_data(filename):\n return pd.read_csv(filename)\n\ndef analyze_data(data):\n return data.describe()\n\ndef visualize_data(data):\n return data.plot(kind='bar')" > analysis.pyAltyapı:

Şimdi ortaya çıkan git diff’i inceleyelim:

git diffAltyapı:

Buna benzer bir çıktı göreceksiniz:

Not: git diff çıktısından çıkmak için terminalinizde “q” tuşuna basın.

Bu çıktıyı parçalayalım:

1. Başlık (diff --git a/analysis.py b/analysis.py) hangi dosyanın karşılaştırıldığını gösterir; bu da analysis.py
2. Dosya metaverisi (index db0e049..a7a7ab0 100644) önceki ve sonraki sürümler için dahili Git tanımlayıcılarını gösterir
3. Dosya işaretçileri (--- a/analysis.py and +++ b/analysis.py) “önce” ve “sonra” dosyalarını belirtir
4. Hunk başlığı (@@ -5,3 +5,6 @@) hangi satırların etkilendiğini gösterir. Bu gösterim şu şekilde yorumlanabilir:

• -5,3 orijinal dosyada 5. satırdan başlayarak diff’te 3 satırın gösterildiği anlamına gelir
• +5,6 değiştirilmiş dosyada 5. satırdan başlayarak diff’te 6 satırın gösterildiği anlamına gelir
• Bu sayılar arasındaki fark, 3 satır eklendiğini gösterir

5. İçerik değişiklikleri; + ile başlayan satırlar eklemeleri gösterir

Daha büyük dosyalarda, git diff değişiklikleri “hunk”lara — değişiklik içeren dosya bölümlerine — gruplar. Her hunk, dosyadaki değişikliklerin yerini bulmanıza yardımcı olan satır numaralarını içeren kendi başlığına sahiptir.

Çalışma dizini ile aşama alanını karşılaştırma

git diff argümansız çalıştırıldığında, Çalışma Dizininizi (dosyaların mevcut durumu) Aşama Alanıyla (commit’e hazır değişiklikler) karşılaştırır. Bu, yaptığınız fakat bir sonraki commit’iniz için henüz hazırlamadığınız değişiklikleri gözden geçirmek için kullanışlıdır.

Bunu göstermek için birden fazla dosyayı değiştirelim:

# Update README.md
echo "# Data Analysis Project\nA sample project to demonstrate git diff functionality.\n\n## Installation\nRun \pip install -r requirements.txt" > README.md

# Update data.csv
echo "id,name,value\n1,alpha,10\n2,beta,20\n3,gamma,30\n4,delta,40" > data.csvAltyapı:

Şimdi yalnızca README.md değişikliklerini aşamaya alalım:

git add README.mdAltyapı:

git diff artık yalnızca data.csv ve yukarıdaki analysis.py dosyasındaki aşamaya alınmamış değişiklikleri gösterecektir:

Bu, henüz aşamaya almadıklarınıza odaklanmanıza yardımcı olur. Aşamaya aldıklarınızı görmek isterseniz:

git diff --staged # or git diff --cached (they're synonyms)Altyapı:

Bu, commit’e hazır olan aşamaya alınmış README.md değişikliklerini gösterecektir. Bu iş akışı, temiz ve mantıklı commit’ler oluşturmak için kritik önemdedir. Birlikte anlam ifade eden işinizin bölümlerini aşamaya alabilir, aşamaya alınmış diff’i gözden geçirerek bunun tutarlı bir değişiklik birimi olduğunu doğrulayabilir ve ardından commit edebilirsiniz.

Aşama alanı ve son commit’i karşılaştırma

git diff --staged komutu, Aşama Alanınızı son commit ile karşılaştırır. Şu anda git commit çalıştırırsanız bir sonraki commit’inize tam olarak nelerin dahil edileceğini gösterir.

Şimdi data.csv değişikliklerini aşamaya alalım ve nelerin aşamada olduğunu inceleyelim:

git add data.csv
git diff --stagedAltyapı:

Çıktı artık hem README.md hem de data.csv değişikliklerini gösterecektir; çünkü her ikisi de aşamaya alınmıştır. Bu gözden geçirme adımı commit etmeden önce kritik bir savunma hattı görevi görür — istenmeyen değişiklikleri commit etmenizi önler.

Yaygın bir iş akışı şöyle görünebilir:

1. Birden çok dosyada değişiklik yapın
2. git diff çalıştırarak tüm değişiklikleri gözden geçirin
3. Mantıksal değişiklik gruplarını seçerek git add <file> kullanın
4. git diff --staged çalıştırarak commit edilecekleri doğrulayın
5. Aşamaya alınmış değişiklikleri git commit -m "Your message" ile commit edin
6. Diğer mantıksal değişiklik grupları için tekrarlayın

Bu sistematik yaklaşım, projenizin nasıl evrildiğini anlamayı ve sorunların nerede ortaya çıkmış olabileceğini saptamayı kolaylaştıran temiz, anlamlı bir commit geçmişi korumanıza yardımcı olur. Deneyim kazandıkça, bu diff komutları ikinci doğanız haline gelecek ve geliştirme sürecinde sürekli yol arkadaşınız olacaktır.

Bir sonraki aşamaya geçmeden önce commit’lerimizi yapalım:

# data.csv and README.md are to be committed
git commit -m "Modify data.csv and README.md files"

# Stage and commit analysis.py
git add analysis.py
git diff --staged  # Review the changes one more time
git commit -m "Add a new function to analysis.py"Altyapı:

Orta Düzey Git Diff Teknikleri

Artık git diff’in temellerini anladığımıza göre, projelerinizdeki değişiklikleri izleme ve analiz etme becerinizi artıracak daha güçlü teknikleri keşfedelim. Bu orta düzey kavramları göstermek için veri analizi projemiz üzerinde çalışmaya devam edeceğiz.

Farklı referanslar arasında karşılaştırma

Git, kodunuzun belirli durumlarına işaret eden referanslar kavramı üzerine kuruludur — dallar, commit’ler ve etiketler bu referanslara dahildir. git diff komutu, aralarındaki değişiklikleri göstermek için bu referansların herhangi ikisini karşılaştırabilir.

Bir özellik geliştirmek için yeni bir dal oluşturalım ve bazı değişiklikler yapalım:

# Create and switch to a new branch
git checkout -b feature/advanced-analytics

# Modify the analysis.py file with a new function
echo "import pandas as pd
import numpy as np

def load_data(filename):
   return pd.read_csv(filename)

def analyze_data(data):
   return data.describe()

def visualize_data(data):
   return data.plot(kind='bar')

def perform_advanced_analysis(data):
   """Performs advanced statistical analysis on the dataset"""
   results = {}
   results['correlation'] = data.corr()
   results['skew'] = data.skew()
   return results" > analysis.py

# Commit the changes
git add analysis.py
git commit -m "Add advanced analysis function"Altyapı:

Şimdi özellik dalımızı ana dal ile karşılaştırabiliriz:

git diff main feature/advanced-analyticsAltyapı:

Bu komut, iki dal arasındaki tüm farkları — değiştirilmiş, eklenmiş veya silinmiş her dosyayı — gösterir. analysis.py’de yaptığımız değişiklikleri, yeni içe aktarmalarımız ve fonksiyonumuz dahil göreceksiniz (terminalde tam diff kesildiği için tümünü görmek adına birkaç kez enter’a basın).

Belirli bir commit ile karşılaştırmak için commit hash’ini kullanabilirsiniz:

git log --oneline  # Find the commit hash you want to compare withAltyapı:

git diff 7b3105e  # Replace 7b3105e with the actual commit hash you want to compareAltyapı:

Bu karşılaştırma yeteneği şu durumlarda paha biçilmez hale gelir:

• Bir özellik dalındaki tüm değişiklikleri görerek kod incelemelerine hazırlanırken
• Birleştirmeden önce bir meslektaşınızın dalının hangi değişiklikleri getireceğini kontrol ederken
• Kod tabanınızın sürümler veya yayınlar arasında nasıl evrildiğini anlarken

Belirli dosyaları karşılaştırma

Büyük depolarla çalışırken, çoğu zaman tüm farkları görmek yerine belirli dosya veya dizinlerdeki değişikliklere odaklanmak istersiniz. Git diff, yolları belirtebilmenizi sağlayarak bunu kolaylaştırır.

Birden fazla dosyada değişiklik yapalım:

# Update config.txt
echo "DEBUG=True
DATABASE_PATH=./data/
LOG_LEVEL=INFO" > config.txt

# Update utils.py
echo "def normalize_data(data):
   return (data - data.min()) / (data.max() - data.min())

def clean_data(data):
   return data.dropna()" > utils.pyAltyapı:

Yalnızca config dosyasındaki değişiklikleri görmek için:

git diff config.txtAltyapı:

Veya belirli bir dosyayı dallar arasında karşılaştırmak için:

# Compare analysis.py file between main and feature/advanced-analytics branches
git diff main feature/advanced-analytics -- analysis.pyAltyapı:

Yukarıdaki komuttaki --, Git’in referanslarla dosya yollarını ayırt etmesine yardımcı olur. Bu özellikle şu durumlarda kullanışlıdır:

• Birçok dosyanın bulunduğu depolarda çalışırken belirli bileşenlere odaklanmak istediğinizde (çoğu zaman böyle olacaktır)
• Yapılandırmanın dallar arasında nasıl değiştiğini kontrol ederken
• Büyük bir değişiklik setinde yalnızca en kritik dosyaları incelerken

Bağlamsal diff seçenekleri

Git diff, farkların nasıl görüntüleneceğini ayarlamak için çeşitli seçenekler sunar ve anlamlı değişikliklere odaklanmayı kolaylaştırır.

Örneğin, kod biçimlendirme değişiklikleriyle uğraşırken, boşluk farkları önemli anlamsal değişiklikleri gölgeleyebilir. Bunu bir biçimlendirme değişikliğiyle gösterelim:

# Make a whitespace change to analysis.py
sed -i '' 's/    return/  return/g' analysis.py  # Reduce indentationAltyapı:

Şimdi, standart git diff ile karşılaştırma boşluk değişikliklerini gösterir (return deyimlerinin hizasının bozulduğuna dikkat edin):

git diff analysis.py

# OUT:
--- a/analysis.py
+++ b/analysis.py
@@ -2,17 +2,17 @@ import pandas as pd
import numpy as np

def load_data(filename):
-    return pd.read_csv(filename)
+  return pd.read_csv(filename)

def analyze_data(data):
-    return data.describe()
+  return data.describe()

def visualize_data(data):
-    return data.plot(kind='bar')
+  return data.plot(kind='bar')

def perform_advanced_analysis(data):
    Performs advanced statistical analysis on the dataset
    results = {}
    results['correlation'] = data.corr()
    results['skew'] = data.skew()
-    return results
+  return resultsAltyapı:

Ancak boşluk değişikliklerini yok sayabiliriz (yalnızca boşluk kaldırdığımız için bu, herhangi bir değişiklik göstermeyecektir):

git diff -w analysis.py  # or --ignore-all-spaceAltyapı:

Başka bir yararlı seçenek ise bağlam satırlarını — değişikliklerin çevresinde gösterilen değişmemiş satırları — kontrol etmektir:

git diff -U1 analysis.py  # Show only 1 line of context (default is 3)
git diff -U5 analysis.py  # Show 5 lines of contextAltyapı:

Bu bağlamsal seçenekler özellikle şu durumlarda değerlidir:

• Otomatik biçimlendirmeden geçmiş kodu incelerken
• Biçimden ziyade işlevsel değişikliklere odaklanırken
• Belirli bir değişikliği anlamak için daha fazla bağlama ihtiyaç duyduğunuzda
• Varsayılan bağlamın çok fazla çıktı üreteceği büyük dosyalarla çalışırken

Bu orta düzey tekniklerde ustalaşarak, kod tabanınızdaki değişiklikleri nasıl inceleyip anlayacağınıza çok daha ince ayar çekebilir, geliştirme iş akışınızı verimli, kod incelemelerinizi ise etkili hale getirebilirsiniz.

İleri git diff uygulamalarına geçmeden önce son değişiklikleri commit edelim:

git add .
git commit -m "Modify analysis.py, config.txt, and utils.py"Altyapı:

İleri Düzey Git Diff Uygulamaları

git diff’in orta düzey tekniklerine ilişkin anlayışımıza dayanarak, Git becerilerinizi bir üst seviyeye taşıyacak bazı ileri uygulamaları keşfedelim. Bu ileri teknikler, özellikle karmaşık kod tabanlarında çalışırken veya daha büyük ekiplerle iş birliği yaparken faydalıdır.

Harici diff araçlarını kullanma

Git’in yerleşik diff’i güçlüdür; ancak bazen görsel bir diff aracı, özellikle karmaşık değişikliklerde daha iyi netlik sağlar. Git, diff deneyiminizi geliştirmek için harici araçlar yapılandırmanıza izin verir.

Popüler bir görsel diff aracı kuralım. Örnek olarak VSCode’u kullanacağız, ancak Beyond Compare, Meld veya KDiff3 gibi araçlar için de benzer yapılandırma geçerlidir:

# Configure Git to use VSCode as the diff tool (project-specific)
git config diff.tool vscode
git config difftool.vscode.cmd "code --wait --diff \$LOCAL \$REMOTE"

# To use other popular tools, you could use:
# For Beyond Compare (project-specific):
git config diff.tool bc3
git config difftool.bc3.path "/path/to/beyond/compare"

# Installation commands:
# For Beyond Compare:
# On macOS: brew install --cask beyond-compare
# On Ubuntu: sudo apt-get install beyond-compare
# On Windows: Download from https://www.scootersoftware.com/download.php

# Note: To apply these settings globally instead of just the current project,
# add the --global flag to each command, for example:
# git config --global diff.tool vscodeAltyapı:

Artık git diff yerine şunu kullanabilirsiniz:

git difftool main feature/advanced-analyticsAltyapı:

Bu, yapılandırdığınız görsel diff aracını açarak değişiklikleri gösterecektir. Beyond Compare şu şekilde görünür:

Görsel diff araçlarının birkaç avantajı vardır:

1. Yan yana karşılaştırma ile bağlamı görmeyi kolaylaştırır
2. Tercihlerinize uygun sözdizimi vurgulama
3. Değişiklikler arasında gelişmiş gezinme
4. Farkları incelerken dosyaları doğrudan düzenleme imkanı

Büyük değişiklikleri incelerken veya karmaşık yapılara (iç içe JSON veya XML gibi) sahip dosyalarla çalışırken, görsel diff araçları kavrayışı ve verimliliği ciddi ölçüde artırabilir.

Uzmanlaşmış diff komutları

Git, belirli kullanım durumları için size daha ayrıntılı kontrol sağlayan uzmanlaşmış diff komutları sunar. Bu güçlü komutlardan bazılarını keşfedelim:

git diff-tree, ağaç nesneleri (dizinler) arasındaki farkları inceler:

# Get the hash of the last two commits
LAST_COMMIT=$(git rev-parse HEAD)
PREV_COMMIT=$(git rev-parse HEAD~1)

# Show changes in the last commit
git diff-tree --patch $PREV_COMMIT $LAST_COMMITAltyapı:

git diff-index, çalışma ağacını index (aşama alanı) veya bir ağaç ile karşılaştırır:

# Compare working directory with the index
git diff-index --patch HEADAltyapı:

git diff-index özellikle betik yazımı ve otomasyon için kullanışlıdır. Sıradaki commit’inize hangi değişikliklerin dahil edileceğini programlı olarak kontrol etmenize olanak tanır; bu da ön-commit kancaları ve doğrulama betikleri için değerlidir.

Örneğin, belirli dosyaların değiştirilmediğini doğrulamak veya commit’lere izin vermeden önce yapılandırma değişikliklerinin belirli kalıpları takip ettiğinden emin olmak için bir CI/CD hattında kullanabilirsiniz.

git diff-files, çalışma dizinindeki dosyalar ile index arasındaki değişiklikleri gösterir:

# Check differences for specific files
git diff-files --patch config.txtAltyapı:

Bu uzmanlaşmış komutlar özellikle şu durumlarda kullanışlıdır:

• Özel Git iş akışları ve betikleri oluştururken
• Git’in iç işleyişiyle ilgili sorunları giderirken
• Depo durumunun hedefe yönelik analizini yaparken
• Git ile etkileşime giren otomasyon araçları oluştururken

Kod geçmişini analiz etme

git diff’in en güçlü uygulamalarından biri, özellikle hata ayıklama veya özellik geliştirmeyi anlama açısından kritik olabilen kodun zaman içinde nasıl evrildiğini analiz etmektir.

Özel ^! gösterimini kullanarak belirli bir commit’i inceleyelim:

# Get the hash of our advanced analytics commit
ANALYTICS_COMMIT=$(git log --oneline | grep "advanced analysis" | cut -d ' ' -f 1)

# Show only changes introduced in that specific commit
git diff $ANALYTICS_COMMIT^!Altyapı:

^! sözdizimi, yalnızca o tek commit’te nelerin değiştiğini göstermek için bir commit’i ebeveyniyle karşılaştırmanın kısaltmasıdır.

Belirli bir dosyanın zaman içinde nasıl evrildiğini izlemek için:

# Analyze how analysis.py changed over the last 3 commits
git log -p -3 analysis.pyAltyapı:

Bir hatayı avlarken, git bisect ile birlikte git diff kullanabilirsiniz:

# Add a bug to simulate a regression
echo "import pandas as pd
import numpy as np

def load_data(filename):
   # Bug: accidentally returning None instead of the data
   pd.read_csv(filename)
   return None

def analyze_data(data):
   return data.describe()

def visualize_data(data):
   return data.plot(kind='bar')

def perform_advanced_analysis(data):
   results = {}
   results['correlation'] = data.corr()
   results['skew'] = data.skew()
   return results" > analysis.py

git add analysis.py
git commit -m "Update analysis.py with a hidden bug"

# Now use git bisect to find when the bug was introduced
git bisect start
git bisect bad  # Mark current commit as containing the bug
git bisect good main  # Mark the main branch as working correctly

# Git will check out commits for you to test
# Once found, you can examine the exact change that introduced the bug
git diff HEAD^!Altyapı:

Git bisect, commit geçmişinizde hatayı hangi commit’in tanıttığını bulmak için ikili arama yapan güçlü bir hata ayıklama aracıdır. git diff ile birleştirildiğinde verimli bir iş akışı oluşturur:

1. git bisect start ile bisect sürecini başlatın

2. Geçerli commit’i hatayı içeren kötü (bad) olarak işaretleyin: git bisect bad

3. Hatanın olmadığı bilinen bir commit’i iyi (good) olarak işaretleyin: git bisect good <commit-hash>

4. Git, test etmeniz için geçmişinizin ortasındaki bir commit’i otomatik olarak check-out eder.

5. Geçerli commit’i test ettikten sonra Git’e sonucu söyleyin:

• Hata bu commit’te varsa: git bisect bad
• Hata bu commit’te yoksa: git bisect good

6. Git, her git bisect bad/good komutundan sonra geri bildiriminize göre farklı commit’leri check-out etmeye devam ederek aramayı her seferinde daraltır. Git sorunlu ilk commit’i tespit edene kadar test edip işaretleme işlemini tekrarlayın.

7. Git, sorunlu commit’i bulduğunda hatayı hangi commit’in tanıttığını belirten bir mesaj görüntüler.

8. Tanımlanan commit’te tam olarak nelerin değiştiğini şununla inceleyin: git diff HEAD^!

9. Bu komut, hatayı tanıtan commit’te tam olarak hangi kodun değiştirildiğini göstererek hata ayıklama çabalarınızı bu belirli değişikliklere odaklamanızı sağlar.

10. İstediğiniz zaman bisect sürecinden çıkmak için: git bisect reset — bu, bisect’e başlamadan önce bulunduğunuz dala geri döndürür.

11. Bisect sürecini şu komutla otomatikleştirebilirsiniz: git bisect run <test-script> — İyi commit’ler için 0, kötü commit’ler için sıfır olmayan bir değer döndüren bir komut olmalıdır.

Bu iş akışı, çalışan ve bozuk durumlar arasında çok sayıda commit bulunan büyük kod tabanlarında hata ayıklama süresini dramatik biçimde azaltır.

Bu geçmiş analizi teknikleri şuralar için paha biçilmezdir:

• Bir hatanın ne zaman ve neden tanıtıldığını bulmak
• Bir özelliğin veya bileşenin evrimini anlamak
• Güvenlik incelemeleri için değişiklikleri denetlemek
• Kod değişikliklerinin arkasındaki karar alma sürecini belgelendirmek

Bu ileri git diff uygulamalarında ustalaşarak, projenizin geçmişinde hassasiyetle gezinebilir, sorunları daha verimli şekilde ayıklayabilir ve kod tabanınızın evrimine dair daha derin içgörüler elde edebilirsiniz.

Git Diff Komut Başvurusu

Git diff, belirli durumlar için çıktısını ve davranışını özelleştirmenizi sağlayan geniş bir seçenek yelpazesi sunar. İşte diferansiyel analizini güçlendirmek için en yaygın kullanılan parametrelerin kapsamlı bir başvurusu:

Temel karşılaştırma seçenekleri

• git diff - Çalışma dizinini aşama alanıyla karşılaştır
• git diff --staged (veya --cached) - Aşama alanını son commit ile karşılaştır
• git diff HEAD - Çalışma dizinini son commit ile karşılaştır
• git diff <commit> - Çalışma dizinini belirli bir commit ile karşılaştır
• git diff <commit1> <commit2> - İki belirli commit’i karşılaştır
• git diff <branch1> <branch2> - İki dalı karşılaştır

Yol sınırlama

• git diff -- <path> - Karşılaştırmayı belirli bir dosya veya dizinle sınırla
• git diff --stat - Değişikliklerin özeti (değişen dosyalar, eklemeler, silmeler) — büyük diff’ler için çok kullanışlı bir seçenek
• git diff --name-only - Yalnızca değişen dosyaların adlarını göster
• git diff --name-status - Değişen dosyaların adlarını ve durumlarını (eklendi, değişti, silindi) göster

Görüntü kontrolü

• git diff -w (veya --ignore-all-space) - Boşluk değişikliklerini yok say
• git diff --ignore-space-change - Boşluk miktarındaki değişiklikleri yok say
• git diff --color-words - Sözcük düzeyinde farklılıkları renkli göster
• git diff --word-diff - Sözcük düzeyinde farklılıkları farklı bir formatta göster
• git diff -U<n> - n satır bağlam göster (varsayılan 3)
• git diff --no-prefix - Diff çıktısında a/ ve b/ öneklerini gösterme

İçerik filtreleme

• git diff --binary - İkili dosyalardaki değişiklikleri göster
• git diff -S<string> - Belirtilen dizeyi ekleyen veya kaldıran değişiklikleri ara
• git diff -G<regex> - Belirtilen regex desenine uyan değişiklikleri ara
• git diff --pickaxe-all - -S veya -G kullanılırken, yalnızca eşleşenleri değil dosyadaki tüm değişiklikleri göster

Format seçenekleri

• git diff --patch-with-stat - Yama ve istatistik özetini göster
• git diff --compact-summary - İstatistik özetini kompakt formatta göster
• git diff --numstat - İstatistikleri makine dostu formatta göster
• git diff --summary - Oluşturma/silme özetini göster

Bu seçenekler, güçlü ve hedefe yönelik karşılaştırmalar oluşturmak için birleştirilebilir. Örneğin, boşlukları yok sayarken belirli bir dosyadaki sözcük düzeyi değişiklikleri görmek için:

git diff --color-words -w -- analysis.pyAltyapı:

Veya belirli bir fonksiyonun eklenmiş ya da kaldırılmış olabileceği tüm yerleri bulmak için:

git diff -S"def perform_advanced_analysis" main feature/advanced-analyticsAltyapı:

Bu seçenekleri anlamak, gürültüyü kesip tam olarak önemli olan değişikliklere odaklanmanıza yardımcı olur; böylece kod inceleme ve analiz iş akışlarınız daha verimli hale gelir. İster hata avlıyor, ister bir çekme isteğine hazırlanıyor, ister yalnızca neyin değiştiğini anlamaya çalışıyor olun, doğru git diff seçeneği görevinizi önemli ölçüde kolaylaştırabilir.

Sonuç

Bu makale boyunca, git diff’i kod değişikliklerini görüntülemek için çok yönlü bir komut olarak inceledik. Çalışan dosyaları aşamaya alınmış değişikliklerle karşılaştırmayı, dallar ve commit’ler arasındaki farkları incelemeyi ve daha derin içgörüler için uzmanlaşmış komutları kullanmayı ele aldık. git diff’i iş akışınıza dahil etmek, daha temiz commit’ler oluşturmanıza, sorunları erken yakalamanıza ve daha iyi kod incelemeleri yapmanıza yardımcı olur. 

İster tek başınıza ister bir ekipte çalışın, git diff’te ustalaşmak sizi sadece kod yazmaktan, kod tabanınızın zaman içinde nasıl evrildiğini anlamaya taşır.

Git uzmanlığınızı geliştirmeye devam etmek için şu değerli kaynaklara göz atın: 

• Kapsamlı Git Hızlı Başvuru hızlı referans için
• Git’e Giriş — temelleri pekiştirmek isteyen yeni başlayanlar için
• Pratik Yeni Başlayanlar için GitHub ve Git Eğitimi — uygulamalı öğrenim için
• Orta Düzey Git — dallanma stratejileri ve iş birliği teknikleriyle becerilerinizi ilerletmek için
• Git’in Temelleri — Git’in içsel modeli ve ileri iş akışlarına dair daha derin içgörüler için. 

Bu kaynaklar, git diff hakkında öğrendiklerinizi pekiştirmenize ve sürüm kontrolü ustalığınızı bir üst seviyeye taşımanıza yardımcı olacaktır.