Já teve dificuldades para lembrar quais alterações você fez no seu código? Ou talvez você tenha apagado acidentalmente uma linha importante e passou horas tentando descobrir como recuperá-la? Ou talvez você apenas fez algumas alterações e quer revisá-las antes de fazer o commit? Todos já passamos por isso. Mas não se preocupe! Existe uma ferramenta poderosa no arsenal do Git que pode facilitar muito a sua vida: o Git Diff. Neste post, vamos aprender sobre ele.

Entendendo os Fundamentos do Git Diff

O Git Diff é como ter uma lupa em suas alterações de código. Ele permite que você compare duas versões do seu código e veja exatamente o que foi adicionado, removido ou modificado.

Imagine que você está trabalhando em um documento com uma função de “rastrear as alterações” habilitada. O Git Diff funciona de forma semelhante, mas para o seu código. Ele destaca as diferenças entre duas versões de um arquivo, facilitando a compreensão do que mudou e como.

Como Usá-lo:

O comando básico do Git Diff é: git diff. Este comando comparará o estado atual do seu diretório de trabalho com o último commit que você fez. Aqui está um exemplo simples usando um arquivo chamado Foo.swift:

class Foo {
    func bar() {
        print("Hello, world!")
    }
}

Digamos que você faça uma alteração em Foo.swift:

class Foo {
    func bar() {
        print("Hello, world! I've been updated.")
    }
}

Agora, se você executar git diff no seu terminal, verá a seguinte saída:

git diff

diff --git a/Foo.swift b/Foo.swift
index 495198a..6543e6d 100644
--- a/Foo.swift
+++ b/Foo.swift
@@ -3,4 +3,4 @@
 class Foo {
     func bar() {
-        print("Hello, world!")
+        print("Hello, world! I've been updated.")
     }
 }

Esta saída mostra:

• - - - a/Foo.swift: Esta linha representa a versão original do arquivo.
• +++ b/Foo.swift: Esta linha representa a versão modificada do arquivo.
• @@ -3,4 +3,4 @@: Esta linha indica os números das linhas onde as alterações ocorreram.
• - print(“Hello, world!”): Esta linha mostra o código original que foi deletado.
• + print(“Hello, world! I’ve been updated.”): Esta linha mostra o novo código que foi adicionado.

Visualizando as alterações, o Git Diff ajuda você a entender o impacto das suas modificações de código e rastrear a evolução do seu projeto.

Na próxima seção, vamos mergulhar em alguns argumentos úteis do Git Diff que podem levar suas habilidades de comparação de código para o próximo nível!

Argumentos Essenciais do Git Diff (Dicas e Truques)

O Git Diff oferece uma variedade de argumentos que podem ajustar sua saída e tornar sua experiência de comparação de código ainda mais perspicaz. Aqui estão alguns argumentos essenciais para impulsionar suas habilidades com o Git Diff:

Argumento “staged” ou “cached”

git diff --staged

git diff --cached

Esses comandos comparam as alterações que você preparou para seu próximo commit (usando git add) com o estado atual do seu diretório de trabalho. É incrivelmente útil para revisar suas alterações preparadas antes de fazer o commit, garantindo que você está fazendo commit apenas das modificações desejadas.

Argumento “w”

git diff -w

Mostra apenas as alterações no conteúdo real, ignorando alterações de espaço em branco. Isso é útil quando você está focado na lógica do código e não se importa com a formatação.

Argumento “word-diff”

git diff --word-diff

Esta é uma opção incrível para ver as diferenças de texto. Esse argumento exibe diffs de nível de palavra, destacando as palavras específicas que foram alteradas dentro de uma linha. Isso facilita a identificação de alterações sutis e a compreensão do contexto das modificações.

Considere a última alteração em Foo.swift. Se usarmos o git diff --word-diff, veremos o seguinte resultado:

git diff --word-diff

diff --git a/Foo.swift b/Foo.swift
index 495198a..6543e6d 100644
--- a/Foo.swift
+++ b/Foo.swift
@@ -3,4 +3,4 @@
 class Foo {
     func bar() {
         print("Hello, [-world!")-]{+world! I've been updated.")+}
     }
 }

Usando esse argumento, você pode ver claramente que a frase “I’ve been updated.” foi adicionada, enquanto o restante da linha permanece inalterado. Talvez isso não tenha ficado tão claro aqui no post do blog, mas se você estiver usando o Git na linha de comando, provavelmente verá um resultado colorido do Git Diff e ficará mais fácil entender as alterações.

Argumento “color-words”

git diff --color-words

Esse argumento destaca as palavras alteradas com cores diferentes, facilitando a distinção visual das partes modificadas do código. É muito semelhante ao “word-diff”, mas pode ser mais fácil de entender.

Argumento “HEAD”

git diff HEAD

Este comando mostra as diferenças entre seu diretório de trabalho atual e o último commit (HEAD). É útil para revisar suas alterações não preparadas antes de fazer o commit ou verificar quais alterações você fez desde o último commit. Esta é a opção padrão quando você não especifica nada após o diff.

Argumento com nome de branch

git diff branch_name

Este argumento compara seu branch atual com outro branch, como “feature-branch”. Isso é incrivelmente útil para entender as diferenças entre branches, especialmente antes de fazer merge ou quando você tenta identificar conflitos.

Usando uma ferramenta de diff externa

Às vezes, a saída padrão do Git diff pode não ser visualmente atraente ou fornecer contexto suficiente. Nesses casos, você pode usar ferramentas de diff externas para aprimorar sua experiência de comparação de código.

Uma ferramenta de diff externa popular é o Difftastic, uma ferramenta de diff estrutural que compara arquivos com base em sua sintaxe.

Para usar o Difftastic, você precisa instalá-lo. Você pode verificar as instruções no link acima. Depois de instalá-lo, você pode configurar o Git para usá-lo como a ferramenta de diff externa padrão:

git config --global diff.external difft

Depois de configurar o difft, basta executar git diff como de costume. O Git usará automaticamente o difft para exibir as diferenças, fornecendo uma saída mais visualmente atraente e informativa. O mesmo diff de Foo.swift aparecerá assim:

Foo.swift --- Swift
File permissions changed from 100600 to 100644.
1 class Foo {                         1 class Foo {
2     func bar() {                    2     func bar() {
3         print("Hello, world!")      3         print("Hello, world! I've been updated.")
4     }                               4     }
5 }                                   5 }

Isso é semelhante a uma opção lado a lado que podemos ver no GitHub ou GitLab. Eu gosto muito dessa ferramenta.

Esses são apenas alguns dos muitos argumentos úteis oferecidos pelo Git Diff. Explorar a documentação do Git revelará ainda mais opções avançadas para ajustar sua experiência de comparação de código.

Dominando esses argumentos e explorando ferramentas de diff externas, você estará equipado para entender e gerenciar alterações de código de forma eficiente, levando a um código mais limpo, melhor depuração e colaboração mais suave.

Conclusão: O Poder do Git Diff

Neste post, exploramos sua funcionalidade básica e aprendemos argumentos essenciais para aprimorar suas capacidades. Do rastreamento de alterações de código à localização de bugs e otimização de revisões de código, o Git Diff se mostra uma ferramenta indispensável no arsenal de qualquer pessoa desenvolvedora.

Agora que você tem um melhor entendimento do Git Diff, é hora de colocar seu conhecimento em prática. Experimente diferentes argumentos, explore opções avançadas e descubra como o Git Diff pode transformar seu fluxo de trabalho de desenvolvimento.

Não deixe que as alterações de código sejam um mistério! Abrace o poder do Git Diff e desbloqueie um novo nível de eficiência e compreensão em sua jornada de desenvolvimento.

Até o próximo post!