Git Diff Explicado: Um Guia Completo com Exemplos

Tutoriais
Git

O git diff é sua janela para as mudanças que estão acontecendo em seu repositório de código. Em essência, é um comando que mostra as diferenças entre vários estados de seus arquivos – seja comparando seu trabalho atual com o que você já preparou ou comparando mudanças entre branches e commits. Pense nele 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 mudou e onde.

O git diff ajuda os desenvolvedores a garantir a qualidade do código, fornecendo uma visão clara das modificações antes de serem 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 desenvolvimento e colaboração em equipe.

Pré-requisitos

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

  • Fluxo básico do Git (init, add, commit)
  • Repositórios Git e sua estrutura
  • Ramos (branches) e como funcionam
  • Commits e histórico de commits
  • A área de preparação (index)

Se precisar revisar esses conceitos, estes recursos serão úteis:

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

Por que o Git Diff é Essencial para Desenvolvedores

Todo desenvolvedor precisa saber o que mudou em seu código, seja trabalhando sozinho ou em uma equipe de centenas. Sem o git diff, você ficaria adivinhando 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 construção de software de qualidade por meio de processos de revisão eficazes. Ao examinar as mudanças, o git diff fornece o contexto necessário para entender não apenas o que mudou, mas por que essas mudanças são importantes.

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

À medida que os projetos se tornam mais complexos, o git diff se torna verdadeiramente indispensável por várias razões-chave:

  • Verificação de mudanças: Confirme exatamente o que você está prestes a cometer, evitando a inclusão acidental de código de depuração ou mudanças não relacionadas
  • Transferência de conhecimento : Entender o que os colegas de equipe fizeram sem precisar ler arquivos inteiros
  • Resolução de conflitos:  Identificar exatamente onde e como as alterações entram em conflito durante as fusões
  • Análise histórica :  Rastrear quando alterações específicas foram introduzidas para caçar bugs ou entender a evolução de 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 “Três-Árvores” do Git.

Arquitetura Três-Árvores do Git

Para entender o git diff, você primeiro precisa compreender 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 onde seu código existe.

Considere esses estados como três versões diferentes do seu projeto que o Git acompanha 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 comprometido do seu projeto armazenado no .git diretório).

Fonte: Hashnode

O Diretório de Trabalho contém os arquivos que você está editando ativamente — é aqui que você escreve código, faz alterações e testa seu trabalho. A Área de Preparação atua 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 um cais de carga onde pacotes (suas alterações) são organizados antes do envio.

Finalmente, o Repositório armazena o histórico completo do seu projeto como uma série de commits, snapshots do seu código em pontos específicos no tempo, ligados para formar uma cadeia histórica.

O Git diff opera comparando esses três estados em várias combinações. Quando você executa git diff sem argumentos, ele compara seu Diretório de Trabalho com a Área de Staging, mostrando alterações que você fez, mas ainda não preparou para o commit.

Usando git diff --staged compara a Área de Staging com o último commit, mostrando o que será incluído no seu próximo commit.

E git diff HEAD compara seu Diretório de Trabalho diretamente ao último commit, mostrando todas as alterações não comitadas, independentemente do status de staging.

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

  • Diretório de Trabalho ↔ Área de Staging: Quais alterações eu fiz, mas ainda não comitei? (git diff)
  • Área de Preparação ↔ Repositório: Que alterações eu preparei que serão comprometidas 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 na história? (git diff hash-do-commit1 hash-do-commit2)

Compreender essa arquitetura dá a você o modelo mental necessário para usar efetivamente o git diff para identificar exatamente o que mudou, onde e quando em sua base de código.

Com essa compreensão arquitetural em prática, podemos agora explorar como usar comandos git diff na prática para obter insights sobre a evolução do seu código através desses 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. Vamos configurar um pequeno repositório com scripts Python, dados CSV e arquivos de texto que podemos modificar ao longo deste tutorial.

# Criar e inicializar nosso projeto
mkdir data-analysis-project
cd data-analysis-project
git init

# Criar arquivos iniciais
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

# Fazer nosso primeiro commit
git add .
git commit -m "Initial commit with basic project structure"

# Verificar a estrutura do diretório
> tree

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

Nosso projeto agora tem cinco arquivos sob controle de versão, nos dando uma base para demonstrar vários cenários de diff. Conforme avançamos, iremos modificar esses arquivos para mostrar como o git diff revela mudanças em diferentes contextos.

Compreensão dos resultados do git diff

Ao executar 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:

# Atualize analysis.py com uma nova função
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á uma saída semelhante a esta:

Nota: Para sair da saída do git diff, pressione “q” no seu terminal.

Vamos analisar essa saída:

  1. O cabeçalho (diff --git a/analysis.py b/analysis.py) mostra qual arquivo está sendo comparado, que é analysis.py
  2. os metadados do arquivo (index db0e049..a7a7ab0 100644) mostram identificadores internos do Git para as versões antes e depois
  3. Os marcadores de arquivo (--- a/analysis.py e +++ b/analysis.py) indicam os arquivos “antes” e “depois”
  4. O cabeçalho do bloco (@@ -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 no arquivo original, 3 linhas são mostradas na diferença
  • +5,6 significa que a partir da linha 5 no arquivo modificado, 6 linhas são mostradas na diferença
  • A diferença entre esses números indica que 3 linhas foram adicionadas

5. A alteração de conteúdo com linhas que começam com + mostrando adições

Nos arquivos maiores, o git diff agrupa as alterações em “hunks” – seções do arquivo que contêm alterações. Cada hunk tem seu próprio cabeçalho com números de linha para ajudá-lo a localizar as alterações no arquivo.

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

Executar git diff sem argumentos compara o seu Diretório de Trabalho (estado atual dos arquivos) com a Área de Preparação (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:

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

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

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

git add README.md

Executar git diff agora mostrará apenas as alterações não preparadas em 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á preparou:

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

Isso mostrará as alterações em README.md que estão preparadas e prontas para serem enviadas. Este fluxo de trabalho é crucial para construir commits limpos e lógicos. Você pode preparar partes do seu trabalho que fazem sentido juntas, revisar a diferença preparada para verificar se é uma unidade coerente de mudança e, em seguida, comitá-la.

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

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

Vamos preparar nossas alterações no data.csv e examinar o que está preparado:

git add data.csv
git diff --staged

A saída agora mostrará alterações tanto no README.md quanto no data.csv, já que ambos foram preparados. Esta etapa de revisão é crítica antes de fazer o commit — ela atua como sua última linha de defesa contra commits de alterações indesejadas.

Um fluxo de trabalho comum pode parecer:

  1. Faça alterações em vários arquivos
  2. Execute git diff para revisar todas as alterações
  3. Use git add <file> seletivamente para adicionar grupos lógicos de alterações
  4. Execute git diff --staged para verificar o que está prestes a ser comprometido
  5. Comprometa as alterações adicionadas com git commit -m "Sua mensagem"
  6. Repita para outros grupos 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 seu projeto evoluiu e a identificação de onde problemas podem ter sido introduzidos. À medida que você ganha experiência, esses comandos diff se tornarão algo natural, servindo como seus companheiros constantes no processo de desenvolvimento.

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

# data.csv e README.md devem ser commitados
git commit -m "Modify data.csv and README.md files"

# Estagiar e commitar 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 aprimorarão sua capacidade de rastrear e analisar mudanças em seus projetos. Continuaremos trabalhando com nosso projeto de análise de dados para demonstrar esses conceitos intermediários.

Comparando entre diferentes referências

Git é construído em torno do conceito de referências — ponteiros para estados específicos do seu código. Essas referências incluem branches, 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 branch para desenvolver um recurso e fazer algumas mudanças:

# Criar e mudar para um novo branch
git checkout -b feature/advanced-analytics

# Modificar o arquivo analysis.py com uma nova função
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

# Comitar as mudanças
git add analysis.py
git commit -m "Add advanced analysis function"

Agora podemos comparar nosso branch de funcionalidade com o branch principal:

git diff main feature/advanced-analytics

Este comando mostra todas as diferenças entre os dois branches — cada arquivo que foi modificado, adicionado ou deletado. Você verá as mudanças que fizemos no analysis.py, incluindo nossas novas importações e função (pressione enter várias vezes, pois a diferença completa é truncada 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

Essa capacidade de comparação se torna inestimável quando:

  • Preparando para revisões de código ao ver todas as mudanças em um branch de funcionalidade
  • Verificando quais mudanças o branch de um colega introduziria antes de mesclar
  • Entendendo como seu código evoluiu entre lançamentos ou versões

Comparando arquivos específicos

Quando trabalhando com grandes repositórios, você frequentemente quer se concentrar em mudanças em 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 mudanças em vários arquivos:

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

# Atualizar 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 mudanças apenas no arquivo de configuração:

git diff config.txt

Ou para comparar um arquivo específico entre branches:

# Comparar o arquivo analysis.py entre os branches main e feature/advanced-analytics
git diff main feature/advanced-analytics -- analysis.py

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

  • Trabalhando em repositórios com muitos arquivos, mas focando em componentes específicos (o que muitas vezes será o caso)
  • Verificando como a configuração mudou entre branches
  • Revisando apenas os arquivos mais críticos em um grande conjunto de mudanças

Opções de diff contextual

O Git diff fornece várias opções para ajustar como as diferenças são exibidas, facilitando o foco em mudanças significativas.

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

# Faça uma alteração de espaçamento em branco no analysis.py
sed -i '' 's/    return/  return/g' analysis.py  # Reduce indentation

Agora, comparando com o git diff padrão, mostra mudanças de espaçamento em branco (observe como as declaraçõ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 mudanças de espaçamento em branco (isso não mostra mudanças, pois apenas removemos espaços em branco):

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

Outra opção útil é controlar as linhas de contexto – as linhas inalteradas exibidas 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:

  • Revisar código que passou por formatação automatizada
  • Focar em mudanças funcionais em vez de mudanças de estilo
  • Precisar de mais contexto para entender uma mudança específica
  • Trabalhar com arquivos grandes onde o contexto padrão criaria muita saída

Ao dominar essas técnicas intermediárias, você terá um controle muito mais fino sobre como revisa e entende as mudanças em 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 últimas mudanças antes de avançarmos para aplicações avançadas do git diff:

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

Aplicações Avançadas do Git Diff

Construindo sobre nossa compreensão das técnicas intermediárias do git diff, vamos explorar algumas aplicações avançadas que levarão suas habilidades de 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 colaborando com equipes maiores.

Usando ferramentas de diffs externas

Embora o diff embutido do Git seja poderoso, às vezes uma ferramenta de diff visual oferece melhor clareza, especialmente para mudanças complexas. O Git permite que você configure ferramentas externas para aprimorar sua experiência com diffs.

Vamos configurar uma ferramenta de diff visual popular. Usaremos o VSCode como exemplo, mas configurações semelhantes funcionam para ferramentas como Beyond Compare, Meld ou KDiff3:

# Configure o Git para usar o VSCode como a ferramenta de diff (específica do projeto)
git config diff.tool vscode
git config difftool.vscode.cmd "code --wait --diff \$LOCAL \$REMOTE"

# Para usar outras ferramentas populares, você poderia usar:
# Para Beyond Compare (específica do projeto):
git config diff.tool bc3
git config difftool.bc3.path "/path/to/beyond/compare"

# Comandos de instalação:
# Para Beyond Compare:
# No macOS: brew install --cask beyond-compare
# No Ubuntu: sudo apt-get install beyond-compare
# No Windows: Baixe de https://www.scootersoftware.com/download.php

# Nota: Para aplicar essas configurações globalmente em vez de apenas no projeto atual,
# adicione a flag --global a cada comando, por exemplo:
# 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 diferenciação visual configurada para exibir as alterações. Aqui está como o Beyond Compare se parece:

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

  1. Comparação lado a lado facilitando a visualização do contexto
  2. Realce de sintaxe que se alinha com suas preferências de editor
  3. Navegação avançada entre as alterações
  4. Capacidade de editar arquivos diretamente enquanto revisa as diferenças

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

Comandos de diferenciação especializados

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

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

# Obter o hash dos dois últimos commits
LAST_COMMIT=$(git rev-parse HEAD)
PREV_COMMIT=$(git rev-parse HEAD~1)

# Mostrar as alterações no último commit
git diff-tree --patch $PREV_COMMIT $LAST_COMMIT

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

# Comparar o diretório de trabalho com o índice
git diff-index --patch HEAD

git diff-index é particularmente útil para scripting e automação. Ele permite que você verifique programaticamente quais mudanças seriam incluídas em seu próximo commit, tornando-o 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 certos arquivos não foram modificados ou para garantir que as mudanças de configuração sigam padrões específicos antes de permitir commits.

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

# Verifique as diferenças para arquivos específicos
git diff-files --patch config.txt

Esses comandos especializados são particularmente úteis para:

  • Criar fluxos de trabalho e scripts personalizados do Git
  • Depurar problemas com os internos do Git
  • Realizar análises direcionadas do estado do repositório
  • Criar ferramentas de automação que interagem com o Git

Analisar o histórico de código

Uma das aplicações mais poderosas do git diff é analisar como o código evoluiu ao longo do tempo, o que pode ser crucial para depuração ou compreensão do desenvolvimento de funcionalidades.

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

# Obtenha o hash do nosso commit de análise avançada
ANALYTICS_COMMIT=$(git log --oneline | grep "advanced analysis" | cut -d ' ' -f 1)

# Mostrar apenas as alterações introduzidas nesse commit específico
git diff $ANALYTICS_COMMIT^!

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

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

# Analisar como o analysis.py mudou nos últimos 3 commits
git log -p -3 analysis.py

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

# Adicione um bug para simular uma regressão
echo "import pandas as pd
import numpy as np

def load_data(filename):
   # Bug: retornando acidentalmente None em vez dos dados
   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"

# Agora use o git bisect para encontrar quando o bug foi introduzido
git bisect start
git bisect bad  # Mark current commit as containing the bug
git bisect good main  # Mark the main branch as working correctly

# O Git irá verificar commits para você testar
# Uma vez encontrado, você pode examinar a mudança exata que introduziu o bug
git diff HEAD^!

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

1. Inicie o processo de bisect com git bisect start

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

3. Marque um commit conhecido como bom (onde o bug não existe) com git bisect good <commit-hash>

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

5. Após testar o commit atual, informe ao git o resultado:

  • Se o bug existir neste commit: git bisect bad
  • Se o bug não existir neste commit: git bisect good

6. O Git continuará verificando commits diferentes com base no seu feedback (após cada comando git bisect bad/good), reduzindo a busca a cada vez. Repita o processo de testes e marcação até o Git identificar o primeiro commit ruim.

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

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

9. Este 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 retornará para o branch em que você estava antes de iniciar o processo de bisect.

11. Você também pode automatizar o processo de bisect com: git bisect run <test-script> Onde é um comando que retorna 0 para commits bons e não-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 inestimáveis para:

  • Encontrar quando e por que um bug foi introduzido
  • Compreender a evolução de um recurso ou componente
  • Auditar alterações 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 essas aplicações avançadas de diferença do git, você será capaz de navegar pela história do seu projeto com precisão, depurar problemas de forma mais eficiente e obter insights mais profundos sobre a evolução de sua base de código.

Referência de Comando Git Diff

O Git diff oferece uma ampla gama de opções para personalizar sua saída e comportamento para situações específicas. Aqui está 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 diretório de trabalho com área de preparação
  • git diff --staged (ou --cached) – Comparar área de preparação com último commit
  • git diff HEAD – Comparar diretório de trabalho com último commit
  • git diff <commit> – Comparar diretório de trabalho com commit específico
  • git diff <commit1> <commit2> – Comparar dois commits específicos
  • git diff <branch1> <branch2> – Comparar dois branches

Limitação de caminho

  • git diff -- <path> – 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 diffs grandes
  • git diff --name-only – Mostrar somente os nomes dos arquivos alterados
  • git diff --name-status – Mostra nomes e status (adicionado, modificado, deletado) dos arquivos alterados

Exibe controle

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

Filtragem de conteúdo

  • git diff --binary – Mostra mudanças em arquivos binários
  • git diff -S<string> – Procura por mudanças que adicionam ou removem a string especificada
  • git diff -G<regex> – Procura por mudanças que correspondem ao padrão regex especificado
  • git diff --pickaxe-all – Ao usar -S ou -G, mostre todas as mudanças no arquivo, não apenas as correspondentes

Opções de formato

  • git diff --patch-with-stat – Mostre o patch e o resumo das estatísticas
  • git diff --compact-summary – Mostre o resumo das estatísticas em um formato compacto
  • git diff --numstat – Mostre as estatísticas em um formato amigável para máquinas
  • git diff --summary – Mostre o resumo de criação/deleção

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

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

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

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

Entender essas opções ajuda você a filtrar o ruído e focar precisamente nas mudanças que importam, tornando seus fluxos de trabalho de revisão e análise de código mais eficientes. Seja para caçar bugs, preparar uma solicitação de pull ou apenas tentar entender o que mudou, a opção certa de diff do git pode tornar sua tarefa significativamente mais fácil.

Conclusão

Ao longo deste artigo, exploramos o git diff como um comando versátil para visualizar alterações de código. Cobrimos a comparação de arquivos de trabalho com alterações preparadas, examinamos diferenças entre branches e commits, e utilizamos comandos especializados para insights mais profundos. Incorporar o git diff em seu fluxo de trabalho ajuda a construir commits mais limpos, identificar problemas precocemente e facilitar revisões de código mais eficientes.

Seja trabalhando individualmente ou em equipe, dominar o git diff eleva você de simplesmente escrever código para entender como sua base de código evolui ao longo do tempo.

Para continuar aprimorando sua expertise em Git, confira estes recursos valiosos:

Esses recursos ajudarão você a expandir o que aprendeu sobre git diff e elevar sua maestria em controle de versão para o próximo nível.

Source:
https://www.datacamp.com/tutorial/git-diff-guide