Introdução

O Git é uma das ferramentas de controle de versão mais populares e essenciais para desenvolvedores de software. Ele permite que os programadores acompanhem as mudanças feitas no código, colaborem com outras pessoas e revertam alterações quando necessário. No entanto, uma parte crucial do Git que muitos desenvolvedores iniciantes não compreendem completamente é a gestão de alterações não confirmadas, ou seja, as mudanças feitas no código que ainda não foram commitadas.

Neste artigo, vamos explorar como verificar as mudanças não confirmadas no Git, fornecendo as ferramentas e comandos que você precisa para garantir que seu código esteja sempre sob controle e pronto para ser integrado a outros desenvolvedores ou à versão principal do projeto.

O que são mudanças não confirmadas no Git?

As mudanças não confirmadas no Git são alterações feitas no seu repositório local, mas que ainda não foram salvas no histórico de commits. Essas mudanças podem incluir:

• Modificações em arquivos existentes – Alterações no código, textos ou outros tipos de conteúdo.
• Arquivos novos – Arquivos que foram adicionados ao seu projeto, mas ainda não foram adicionados ao controle de versão.
• Arquivos removidos – Arquivos que foram excluídos do seu projeto e precisam ser removidos do repositório.

Essas alterações podem ser confirmadas (commitadas) e enviadas para o repositório remoto, ou descartadas, dependendo do que você deseja fazer com elas. O Git oferece várias ferramentas para revisar essas mudanças antes de tomar uma decisão.

Como verificar as mudanças não confirmadas no Git?

Existem diversos comandos que você pode usar para verificar as mudanças não confirmadas no Git. Vamos explorar os mais comuns e úteis.

1. Usando o comando git status

O git status é o comando básico para verificar o estado atual do seu repositório, incluindo as mudanças não confirmadas. Ao executar esse comando, o Git mostrará três principais categorias de informações:

• Arquivos modificados: Arquivos que foram alterados mas ainda não foram adicionados ao staging area (área de preparação para commit).
• Arquivos não rastreados: Arquivos novos que ainda não foram adicionados ao controle de versão do Git.
• Arquivos prontos para commit: Arquivos que já foram adicionados ao staging area e estão prontos para serem commitados.

Exemplo de saída do comando:

git status
No commit yet
Changes to be committed:
  (use "git rm --cached ..." to unstage)
        modified:   arquivo1.js
        new file:   arquivo2.html

Untracked files:
  (use "git add ..." to include in what will be committed)
        arquivo3.css

2. Usando o comando git diff

Enquanto o git status mostra os arquivos que foram modificados, o git diff oferece uma visão detalhada das mudanças específicas em cada arquivo. Ele exibe as linhas de código que foram adicionadas ou removidas.

Para ver a diferença entre as alterações não confirmadas e o último commit, basta usar o comando:

git diff

Esse comando mostrará as linhas de código que foram alteradas, removidas ou adicionadas nos arquivos modificados. Se você deseja ver a diferença de um arquivo específico, pode adicionar o nome do arquivo após o comando:

git diff arquivo1.js

3. Verificando arquivos não rastreados com git ls-files

Se você tem arquivos não rastreados, ou seja, novos arquivos que não foram adicionados ao Git, pode usar o comando git ls-files com a opção --others para listar esses arquivos:

git ls-files --others --exclude-standard

Este comando listará todos os arquivos não rastreados no diretório de trabalho, excluindo arquivos ignorados pelo Git (aqueles definidos no arquivo .gitignore).

4. Verificando arquivos removidos com git rm

Se você removeu arquivos do seu diretório de trabalho, mas não os removeu do repositório do Git, o comando git status mostrará esses arquivos como excluídos. Se você quiser verificar especificamente os arquivos removidos, pode usar o seguinte comando:

git rm --cached arquivo1.js

Isso remove o arquivo do controle de versão, mas não do seu sistema de arquivos local. O comando git status então mostrará a remoção do arquivo, e você poderá confirmar a mudança.

Como adicionar as mudanças ao Git?

Depois de revisar as alterações não confirmadas, você pode querer adicioná-las ao controle de versão para prepará-las para o próximo commit. Para fazer isso, você pode usar os seguintes comandos:

1. Adicionar arquivos modificados

Para adicionar um arquivo modificado ao staging area, use o comando git add seguido pelo nome do arquivo:

git add arquivo1.js

Se você quiser adicionar todas as alterações, pode usar o seguinte comando:

git add .

2. Confirmar as mudanças

Após adicionar as mudanças ao staging area, o próximo passo é realizar o commit com o comando:

git commit -m "Descrição do que foi alterado"

Isso salvará as alterações no histórico de commits do Git.

Conclusão

Verificar as mudanças não confirmadas no Git é uma tarefa essencial para manter o controle do seu código e evitar problemas de integração no futuro. Ao usar os comandos git status, git diff e git ls-files, você pode facilmente visualizar e gerenciar suas alterações antes de confirmá-las no repositório. Com essas ferramentas, o Git permite que você trabalhe de maneira mais eficiente e organizada, garantindo que suas contribuições ao projeto sejam precisas e bem controladas.