Explicação do Git Diff: Um guia completo com exemplos

O Git diff é a janela que você tem para as alterações que ocorrem no repositório de código. Basicamente, é um comando que mostra as diferenças entre vários estados dos seus arquivos, seja comparando o seu trabalho atual com o que você já preparou ou comparando as alterações entre ramificações e commits. Pense nisso como a maneira do Git de responder à pergunta: "O que mudou?" Quando você executa git diff, o Git analisa o conteúdo dos arquivos linha por linha, identificando o que foi adicionado, removido ou modificado, e apresenta essas informações em um formato padronizado que destaca exatamente o que foi alterado e onde.

O Git diff ajuda os desenvolvedores a garantir a qualidade do código, fornecendo uma visão clara das modificações antes que elas sejam confirmadas. Aqui, abordaremos como usar esse comando essencial de forma eficaz, desde comparações básicas até técnicas avançadas que melhorarão seu fluxo de trabalho de desenvolvimento e a colaboração em equipe.

Pré-requisitos

Para acompanhar este tutorial, você deve estar familiarizado com estes conceitos do Git:

• Fluxo de trabalho básico do Git (init, add, commit)
• Repositórios Git e sua estrutura
• Ramos e como eles funcionam
• Confirmações e histórico de confirmações
• A área de preparação (índice)

Se você precisar se aprofundar nesses conceitos, estes recursos o ajudarão:

• Folha de dicas do Git- Referência rápida para comandos comuns do Git
• Curso de introdução ao Git- Para iniciantes que estão aprendendo os conceitos básicos do Git
• Tutorial do GitHub e do Git para iniciantes- Introdução prática ao Git e ao GitHub
• Curso de Git intermediário- Para aqueles que estão prontos para aprimorar suas habilidades no Git

Você precisará de Git instalado em seu sistema para que você possa seguir os exemplos. Todos os comandos podem ser executados em um terminal ou prompt de comando.

Por que o Git Diff é essencial para os desenvolvedores

Todo desenvolvedor precisa saber o que foi alterado em seu código, esteja ele trabalhando sozinho ou em uma equipe de centenas de pessoas. Sem o git diff, você teria que adivinhar quais linhas foram alteradas, tornando a solução de problemas e a colaboração quase impossíveis.

O Git diff é essencial para o gerenciamento de mudanças e serve como base para a criação de software de qualidade por meio de processos de revisão eficazes. Ao examinar as alterações, o git diff fornece o contexto necessário para que você entenda não apenas o que mudou, mas por que essas alterações são importantes. 

Essa visibilidade direta da evolução do código ajuda as equipes a manter os padrões e evitar que os bugs cheguem à produção.

À medida que os projetos aumentam em complexidade, o git diff se torna realmente indispensável por vários motivos importantes:

• Alterar a verificação:  Confirme exatamente o que você está prestes a confirmar, evitando a inclusão acidental de código de depuração ou alterações não relacionadas
• Transferência de conhecimento: Entenda o que os colegas de equipe fizeram sem ter que ler arquivos inteiros
• Resolução de conflitos:  Identificar exatamente onde e como as alterações entram em conflito durante as mesclagens
• Análise histórica:  Programe quando mudanças específicas foram introduzidas para que você possa encontrar bugs ou entender a evolução dos recursos
• Revisões de código direcionadas:  Concentre a atenção nas partes do código que realmente mudaram, economizando tempo e melhorando a qualidade da revisão

Para usar efetivamente o git diff, é necessário entender a arquitetura subjacente que permite essas comparações: o modelo "Three-Tree" do Git.

Arquitetura de três árvores do Git

Para entender o git diff, primeiro você precisa entender a arquitetura fundamental de "três árvores" do Git. Apesar do nome, essas não são árvores reais no sistema de arquivos, mas sim três estados distintos em que seu código existe. 

Pense nesses estados como três versões diferentes do seu projeto que o Git controla simultaneamente: o diretório de trabalho (seus arquivos reais), a área de preparação (ou índice, onde as alterações são preparadas para o commit) e o repositório (o histórico de commits do seu projeto armazenado no diretório .git ).

Fonte: Hashnode

O diretório de trabalho contém os arquivos que você está editando ativamente - é aqui que você escreve o código, faz alterações e testa o seu trabalho. A Staging Area funciona como uma zona de preparação onde você seleciona quais alterações devem ser incluídas no seu próximo commit. Você pode pensar nisso como uma doca de carga onde os pacotes (suas alterações) são organizados antes do envio. 

Por fim, o Repositório armazena o histórico completo do seu projeto como uma série de commits, instantâneos do código em pontos específicos no tempo, vinculados entre si para formar uma cadeia histórica.

O Git diff funciona comparando esses três estados em várias combinações. Quando você executa git diff sem argumentos, ele compara o diretório de trabalho com a área de preparação, mostrando as alterações que você fez, mas que ainda não foram preparadas .

O uso do git diff --staged compara a área de preparação com o último commit, mostrando o que será incluído no próximo commit .

E o git diff HEAD compara seu diretório de trabalho diretamente com o último commit, mostrando todas as alterações não confirmadas, independentemente do status de preparação.

Esses pontos de comparação formam a base para todas as operações de comparação no Git:

• Diretório de trabalho ↔ Área de preparação: Quais alterações eu fiz, mas ainda não foram preparadas? (git diff )
• Área de preparação ↔ Repositório: Quais alterações eu preparei que serão confirmadas em seguida? (git diff --staged )
• Diretório de trabalho ↔ Repositório: Qual é a diferença total entre meus arquivos de trabalho e o último commit? (git diff HEAD )
• Entre commits: Como o código evoluiu entre pontos específicos da história? (git diff commit1-hash commit2-hash )

A compreensão dessa arquitetura fornece a você o modelo mental necessário para usar efetivamente o git diff para identificar exatamente o que foi alterado, onde e quando na sua base de código.

Com esse entendimento arquitetônico, podemos agora explorar como usar os comandos git diff na prática para obter insights sobre a evolução do seu código nesses três estados.

Uso básico do Git Diff

Vamos criar um projeto de análise de dados de amostra para demonstrar o git diff em ação. Configuraremos um pequeno repositório com scripts Python, dados CSV e arquivos de texto que você poderá modificar ao longo deste tutorial.

# 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.py

Nosso projeto agora tem cinco arquivos sob controle de versão, o que nos dá uma base para demonstrar vários cenários de diferenças. À medida que progredirmos, modificaremos esses arquivos para mostrar como o git diff revela as alterações em diferentes contextos.

Entendendo os resultados do git diff

Quando você executa um comando git diff, a saída segue um formato padronizado projetado para indicar claramente o que foi alterado. Vamos modificar nosso arquivo analysis.py para ver um diff em ação:

# 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.py

Agora vamos examinar o git diff resultante:

git diff

Você verá um resultado semelhante a este:

Observação: Para sair da saída do git diff, pressione "q" em seu terminal.

Vamos detalhar esse resultado:

1. O cabeçalho (diff --git a/analysis.py b/analysis.py ) mostra qual arquivo está sendo comparado, que é o analysis.py
2. Os metadados do arquivo (index db0e049..a7a7ab0 100644 ) mostra os identificadores internos do Git para as versões anteriores e posteriores
3. Os marcadores de arquivo (--- a/analysis.py and +++ b/analysis.py ) indicam os arquivos "antes" e "depois".
4. O cabeçalho do hunk (@@ -5,3 +5,6 @@) mostra quais linhas foram afetadas. Essa notação pode ser interpretada como:

• -5,3 significa que a partir da linha 5 do arquivo original, 3 linhas são mostradas no diff
• +5,6 significa que a partir da linha 5 do arquivo modificado, 6 linhas são mostradas no diff
• A diferença entre esses números indica que três linhas foram adicionadas

5. Oconteúdo de muda com as linhas que começam com + mostrando as adições

Em arquivos maiores, o git diff agrupa as alterações em "pedaços" - seções do arquivo que contêm alterações. Cada hunk tem seu próprio cabeçalho com números de linha para ajudar você a localizar as alterações no arquivo.

Comparação entre o diretório de trabalho e a área de preparação

Ao executar git diff sem argumentos, você compara o diretório de trabalho (estado atual dos arquivos) com a área de teste (alterações prontas para serem confirmadas). Isso é útil para revisar o que você alterou, mas ainda não preparou para o próximo commit.

Vamos modificar vários arquivos para demonstrar:

# 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.csv

Agora, vamos preparar apenas as alterações do README.md:

git add README.md

Ao executar o git diff agora, você verá apenas as alterações não preparadas no data.csv e no arquivo analysis.py acima:

Isso ajuda você a se concentrar no que ainda não foi preparado. Se você quiser ver o que já foi preparado:

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

Isso mostrará as alterações no README.md que estão preparadas e prontas para serem confirmadas. Esse fluxo de trabalho é fundamental para que você crie commits limpos e lógicos. Você pode preparar partes do seu trabalho que façam sentido juntas, revisar a diferença preparada para verificar se é uma unidade coerente de mudança e, em seguida, confirmá-la.

Comparação entre a área de preparação e o último commit

O comando git diff --staged compara a área de preparação com o último commit que você fez. Isso mostra exatamente o que será incluído no seu próximo commit se você executar git commit agora.

Vamos preparar nossas alterações em data.csv e examinar o que foi preparado:

git add data.csv
git diff --staged

Agora, o resultado mostrará as alterações em README.md e data.csv, já que ambos foram preparados. Essa etapa de revisão é fundamental antes de você fazer o commit - ela funciona como a última linha de defesa contra alterações não intencionais.

Um fluxo de trabalho comum pode ser semelhante:

1. Fazer alterações em vários arquivos
2. Execute git diff para revisar todas as alterações
3. Use o site git add seletivamente para preparar grupos lógicos de alterações
4. Execute git diff --staged para verificar o que está prestes a ser confirmado
5. Confirmar as alterações preparadas com git commit -m "Your message"
6. Repita o procedimento para outros agrupamentos lógicos de alterações

Essa abordagem metódica ajuda a manter um histórico de commits limpo e significativo que facilita a compreensão de como o projeto evoluiu e a identificação de onde os problemas podem ter sido introduzidos. À medida que você ganhar experiência, esses comandos diff se tornarão uma segunda natureza, servindo como seus companheiros constantes no processo de desenvolvimento.

Vamos fazer nossos commits antes de passar para a próxima etapa:

# 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"

Técnicas intermediárias de Git Diff

Agora que entendemos os conceitos básicos do git diff, vamos explorar técnicas mais poderosas que aumentarão a capacidade de você rastrear e analisar as alterações em seus projetos. Continuaremos a trabalhar com nosso projeto de análise de dados para demonstrar esses conceitos intermediários.

Comparação entre diferentes referências

O Git foi criado com base no conceito de referências - ponteiros para estados específicos do seu código. Essas referências incluem ramificações, commits e tags. O comando git diff pode comparar quaisquer duas dessas referências para mostrar o que mudou entre elas.

Vamos criar uma nova ramificação para desenvolver um recurso e fazer algumas alterações:

# 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"

Agora podemos comparar nosso ramo de recursos com o ramo principal:

git diff main feature/advanced-analytics

Esse comando mostra todas as diferenças entre os dois ramos - todos os arquivos que foram modificados, adicionados ou excluídos. Você verá as alterações que fizemos no analysis.py, incluindo nossas novas importações e funções (pressione enter várias vezes, pois o diff completo fica truncado no terminal).

Para comparar com um commit específico, você pode usar o hash do commit:

git log --oneline  # Find the commit hash you want to compare with

git diff 7b3105e  # Replace 7b3105e with the actual commit hash you want to compare

Esse recurso de comparação se torna inestimável quando você tem que fazer isso:

• Preparação para revisões de código, vendo todas as alterações em uma ramificação de recurso
• Verificar quais alterações a ramificação de um colega introduziria antes de fazer a fusão
• Compreender como a base de código evoluiu entre lançamentos ou versões

Comparação de arquivos específicos

Ao trabalhar com repositórios grandes, você geralmente deseja se concentrar nas alterações de arquivos ou diretórios específicos em vez de ver todas as diferenças. O Git diff facilita isso, permitindo que você especifique caminhos.

Vamos fazer alterações em vários arquivos:

# 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.py

Para ver as alterações apenas no arquivo de configuração:

git diff config.txt

Ou para comparar um arquivo específico entre as ramificações:

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

O -- no comando acima ajuda o Git a distinguir entre referências e caminhos de arquivos. Isso é particularmente útil quando você:

• Trabalhar em repositórios com muitos arquivos, mas com foco em componentes específicos (o que geralmente é o caso)
• Verificar como a configuração foi alterada nas filiais
• Revisar apenas os arquivos mais críticos em um grande conjunto de alterações

Opções de comparação contextual

O Git diff oferece várias opções para você ajustar como as diferenças são exibidas, facilitando a concentração em alterações significativas.

Por exemplo, ao lidar com alterações de formatação de código, as diferenças de espaço em branco podem obscurecer alterações semânticas importantes. Vamos demonstrar com uma alteração de formatação:

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

Agora, a comparação com o git diff padrão mostra as alterações de espaço em branco (observe como as instruções de retorno estão desalinhadas):

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 results

Mas podemos ignorar as alterações de espaço em branco (isso não mostra nenhuma alteração, pois apenas removemos o espaço em branco):

git diff -w analysis.py  # or --ignore-all-space

Outra opção útil é o controle das linhas de contexto - as linhas inalteradas mostradas ao redor das modificações:

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

Essas opções contextuais são particularmente valiosas quando você tem que fazer isso:

• Revisão de código que passou por formatação automatizada
• Concentrar-se em mudanças funcionais em vez de mudanças de estilo
• Necessidade de mais contexto para entender uma determinada mudança
• Trabalhar com arquivos grandes em que o contexto padrão criaria uma saída excessiva

Ao dominar essas técnicas intermediárias, você terá um controle muito mais preciso sobre como revisar e entender as alterações na sua base de código, tornando seu fluxo de trabalho de desenvolvimento mais eficiente e suas revisões de código mais eficazes.

Vamos confirmar as alterações mais recentes antes de passarmos para os aplicativos avançados do git diff:

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

Aplicativos avançados do Git Diff

Com base em nosso conhecimento das técnicas intermediárias do git diff, vamos explorar alguns aplicativos avançados que levarão suas habilidades no Git para o próximo nível. Essas técnicas avançadas são particularmente úteis ao trabalhar em bases de código complexas ou colaborar com equipes maiores.

Uso de ferramentas de comparação externas

Embora o diff integrado do Git seja poderoso, às vezes uma ferramenta de diff visual proporciona maior clareza, especialmente para alterações complexas. O Git permite que você configure ferramentas externas para aprimorar sua experiência de comparação.

Vamos configurar uma ferramenta popular de comparação visual. Usaremos o VSCode como exemplo, mas uma configuração semelhante funciona para ferramentas como Beyond Compare, Meld ou KDiff3:

# 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 vscode

Agora, em vez de usar git diff, você pode usar:

git difftool main feature/advanced-analytics

Isso abrirá a ferramenta de comparação visual que você configurou para exibir as alterações. Aqui está a aparência do Beyond Compare:

As ferramentas de comparação visual oferecem várias vantagens:

1. Comparação lado a lado para facilitar a visualização do contexto
2. Destaque de sintaxe que se alinha às preferências do seu editor
3. Navegação avançada entre as alterações
4. Capacidade de editar arquivos diretamente durante a revisão das diferenças

Ao revisar grandes alterações ou arquivos com estruturas complexas (como JSON ou XML aninhados), as ferramentas de comparação visual podem melhorar muito a compreensão e a eficiência.

Comandos de comparação especializados

O Git oferece comandos diff especializados que dão a você um controle mais granular para casos de uso específicos. Vamos explorar alguns desses comandos avançados:

git diff-tree examina as diferenças entre os objetos de árvore (diretórios):

# 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_COMMIT

O git diff-index compara a árvore de trabalho com o índice (área de preparação) ou uma árvore:

# Compare working directory with the index
git diff-index --patch HEAD

git diff-index é particularmente útil para a criação de scripts e automação. Ele permite que você verifique programaticamente quais alterações seriam incluídas no seu próximo commit, o que o torna valioso para hooks de pré-commit e scripts de validação.

Por exemplo, você pode usá-lo em um pipeline de CI/CD para verificar se determinados arquivos não foram modificados ou para garantir que as alterações de configuração sigam padrões específicos antes de permitir commits.

git diff-files mostra as alterações entre os arquivos no diretório de trabalho e o índice:

# Check differences for specific files
git diff-files --patch config.txt

Esses comandos especializados são particularmente úteis para você:

• Criar fluxos de trabalho e scripts personalizados do Git
• Depuração de problemas com os componentes internos do Git
• Realização de análise direcionada do estado do repositório
• Criação de ferramentas de automação que interagem com o Git

Análise do histórico do código

Um dos aplicativos mais poderosos do git diff é analisar como o código evoluiu ao longo do tempo, o que pode ser crucial para depurar ou entender o desenvolvimento de recursos.

Vamos examinar um commit específico usando a notação especial ^!:

# 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^!

A sintaxe ^! é uma forma abreviada de comparar um commit com seu pai, mostrando exatamente o que foi alterado nesse commit.

Para rastrear como um arquivo específico evoluiu ao longo do tempo:

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

Ao procurar por um bug, você pode usar git diff com git bisect:

# 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^!

O Git bisect é uma poderosa ferramenta de depuração que realiza uma pesquisa binária no histórico de commits para descobrir qual commit introduziu um bug. Combinado com o git diff, ele cria um fluxo de trabalho eficiente:

1. Inicie o processo de bissecção com git bisect start

2. Marque o commit atual como ruim (contendo o bug) com git bisect bad

3. Marque um commit reconhecidamente bom (onde o bug não existe) com git bisect good

4. O Git verifica automaticamente um commit no meio do seu histórico para você testar.

5. Depois de testar o commit atual, informe ao git o resultado:

• Se o bug existir nesse commit: git bisect bad
• Se o bug não existir nesse commit, você poderá usar o mesmo: git bisect good

6. O Git continuará verificando diferentes commits com base no seu feedback (após cada comando git bisect bad/good ), restringindo a pesquisa a cada vez. Repita o processo de teste e marcação até que o git identifique o primeiro commit incorreto.

7. Quando o git encontrar o commit problemático, ele exibirá uma mensagem indicando qual commit introduziu o bug.

8. Examine exatamente o que mudou no compromisso identificado com você: git diff HEAD^!

9. Esse comando mostra exatamente qual código foi modificado no commit que introduziu o bug, permitindo que você concentre seus esforços de depuração nessas alterações específicas.

10. Saia do bisect a qualquer momento com: git bisect reset Isso o levará de volta ao ramo em que você estava antes de iniciar o processo de bissetriz.

11. Você também pode automatizar o processo de bissecção com: git bisect run Where é um comando que retorna 0 para commits bons e diferente de zero para commits ruins.

Esse fluxo de trabalho reduz drasticamente o tempo de depuração, especialmente em grandes bases de código com muitos commits entre estados funcionais e quebrados.

Essas técnicas de análise de histórico são de grande valia para você:

• Descobrir quando e por que um bug foi introduzido
• Compreender a evolução de um recurso ou componente
• Alterações de auditoria para revisões de segurança
• Documentar o processo de tomada de decisão por trás das alterações de código

Ao dominar esses aplicativos avançados de git diff, você poderá navegar pelo histórico do seu projeto com precisão, depurar problemas com mais eficiência e obter insights mais profundos sobre a evolução da sua base de código.

Referência do comando Git Diff

O Git diff oferece uma ampla gama de opções para você personalizar a saída e o comportamento em situações específicas. Aqui você encontra uma referência abrangente dos parâmetros mais comumente usados para aprimorar sua análise diferencial:

Opções básicas de comparação

• git diff - Comparar o diretório de trabalho com a área de preparação
• git diff --staged (ou --cached )- Compare a área de preparação com o último commit
• git diff HEAD - Comparar o diretório de trabalho com o último commit
• git diff - Comparar o diretório de trabalho com um commit específico
• git diff - Comparar dois commits específicos
• git diff - Comparar duas ramificações

Limitação de caminho

• git diff -- - Limitar a comparação a um arquivo ou diretório específico
• git diff --stat - Mostrar resumo das alterações (arquivos alterados, inserções, exclusões), uma opção muito útil para grandes diferenças
• git diff --name-only - Mostrar apenas os nomes dos arquivos alterados
• git diff --name-status - Mostrar nomes e status (adicionado, modificado, excluído) de arquivos alterados

Controle de exibição

• git diff -w (ou --ignore-all-space) - Ignora alterações de espaço em branco
• git diff --ignore-space-change - Ignorar alterações na quantidade de espaços em branco
• git diff --color-words - Mostrar diferenças no nível da palavra com cores
• git diff --word-diff - Mostrar diferenças no nível da palavra em um formato diferente
• git diff -U - Mostrar n linhas de contexto (o padrão é 3)
• git diff --no-prefix - Não mostre os prefixos a/ e b/ na saída do diff

Filtragem de conteúdo

• git diff --binary - Mostrar alterações em arquivos binários
• git diff -S - Procure por alterações que adicionem ou removam a string especificada
• git diff -G - Procure alterações que correspondam ao padrão regex especificado
• git diff --pickaxe-all - Ao usar -S ou -G, mostre todas as alterações no arquivo, não apenas as correspondentes

Opções de formato

• git diff --patch-with-stat - Mostrar resumo de patches e estatísticas
• git diff --compact-summary - Mostrar o resumo das estatísticas em um formato compacto
• git diff --numstat - Mostre as estatísticas em um formato amigável à máquina
• git diff --summary - Mostrar resumo de criação/exclusão

Essas opções podem ser combinadas para criar comparações poderosas e direcionadas. Por exemplo, para ver as alterações em nível de palavra em um arquivo específico, ignorando os espaços em branco:

git diff --color-words -w -- analysis.py

Ou para localizar todos os locais onde uma função específica pode ter sido adicionada ou removida:

git diff -S"def perform_advanced_analysis" main feature/advanced-analytics

Compreender essas opções ajuda você a eliminar o ruído e a se concentrar precisamente nas alterações que importam, tornando seus fluxos de trabalho de revisão e análise de código mais eficientes. Se você estiver procurando bugs, preparando uma solicitação pull ou apenas tentando entender o que mudou, a opção certa do git diff pode facilitar muito a sua tarefa.

Conclusão

Ao longo deste artigo, exploramos o git diff como um comando versátil para visualizar as alterações de código. Cobrimos a comparação de arquivos de trabalho com alterações preparadas, examinando as diferenças entre ramificações e commits e usando comandos especializados para obter insights mais profundos. Incorporar o git diff em seu fluxo de trabalho ajuda a criar commits mais limpos, detectar problemas antecipadamente e facilitar melhores revisões de código. 

Seja trabalhando sozinho ou em equipe, dominar o git diff faz com que você deixe de simplesmente escrever código e passe a entender como a sua base de código evolui com o tempo.

Para continuar a desenvolver sua experiência em Git, confira estes recursos valiosos: 

• A abrangente Folha de dicas do Git para você ter uma referência rápida
• Introdução ao Git para iniciantes que desejam consolidar os fundamentos
• A prática Tutorial do GitHub e do Git para iniciantes para você aprender na prática
• Git intermediário para você aprimorar suas habilidades com estratégias de ramificação e técnicas de colaboração
• Fundamentos do Git para que você tenha uma visão mais aprofundada do modelo interno do Git e dos fluxos de trabalho avançados.

Esses recursos o ajudarão a desenvolver o que você aprendeu sobre o git diff e a elevar o domínio do controle de versão para o próximo nível.