Diferenças e uso de git add e git commit para registrar alterações

Nos artigos anteriores, aprendemos desde a instalação do Git e a criação de repositórios no GitHub, até como clonar o repositório de outra pessoa para o nosso PC com `git clone`. Agora você já está na linha de partida para o desenvolvimento usando Git e GitHub.

Desta vez, vamos focar nos dois comandos essenciais para registrar alterações, `git add` e `git commit`, que você usará com mais frequência em seu trabalho de desenvolvimento. É fácil pensar "ambos não são comandos para salvar alterações?", mas eles têm papéis completamente diferentes. Entender essa diferença é a chave para dominar o Git. Vamos lá!

Conceitos Básicos do Git: Relembrando os 3 "Lugares"

Para entender a diferença entre `git add` e `git commit`, primeiro vamos revisar o conceito dos "três lugares" do fluxo de trabalho básico do Git. Este conceito ajudará a esclarecer o papel dos dois comandos.

• Diretório de Trabalho (Working Directory): É a pasta no seu PC onde você realmente edita os arquivos.
• Área de Preparação (Staging Area): É um lugar temporário, como uma "sala de espera", para colocar as alterações que você deseja registrar (commitar).
• Repositório Local (Local Repository): É o local onde as alterações da área de preparação são formalmente registradas e armazenadas como um histórico (commit).

Talvez seja mais fácil de entender este fluxo comparando-o a "fazer compras":

1. Você anda pela loja e pega produtos (alterações de arquivos) (trabalho no Diretório de Trabalho).
2. Você coloca os produtos que quer comprar no carrinho de compras (adiciona à Área de Preparação com git add).
3. Você vai ao caixa, paga por todos os produtos do carrinho e finaliza a compra (registra no Repositório Local com git commit).

Como você pode ver, `git add` é a operação de "colocar no carrinho", uma ação de seleção, enquanto `git commit` é a operação de "finalizar a compra", uma ação de registro. Seus papéis são completamente diferentes.

O Papel do `git add`: "Escolher" as Alterações a Serem Commitadas

O principal papel do comando `git add` é selecionar, dentre as alterações feitas no diretório de trabalho, apenas aquelas que você deseja incluir no próximo commit e enviá-las para a área de preparação. Por que essa etapa extra é necessária?

É para manter um histórico de alterações em unidades com significado. Por exemplo, imagine que você estava trabalhando em duas tarefas diferentes ao mesmo tempo: "corrigir um erro de digitação no cabeçalho" e "implementar uma nova funcionalidade no rodapé". Se você agrupar essas duas alterações em um único commit, ao revisar o histórico mais tarde, será difícil entender "o que este commit fez exatamente?".

É aí que o `git add` entra. Primeiro, você pode usar `git add` para commitar apenas o arquivo com o erro de digitação corrigido e, em seguida, usar `git add` para os arquivos da funcionalidade do rodapé e registrá-los como outro commit. Dessa forma, seu histórico de alterações se tornará muito mais limpo e organizado. Assim, `git add` é um passo crucial para melhorar a qualidade dos seus commits.

O Papel do `git commit`: "Registrar" as Alterações

O papel do comando `git commit` é salvar permanentemente todas as alterações que estão na área de preparação como um único "ponto de salvamento" no repositório local. Esta é a operação central do controle de versão no Git.

Um commit deve sempre ser acompanhado de uma "mensagem de commit". Esta é uma nota breve que descreve "o que foi alterado" naquele ponto de salvamento. Escrever boas mensagens de commit é extremamente importante para que você no futuro e outros membros da equipe possam entender o histórico.

git commit -m "Corrigir o link de navegação do cabeçalho"

No momento em que você executa este comando, o conteúdo da área de preparação é capturado como um instantâneo e registrado no repositório com um ID único. Uma vez que um histórico é commitado, ele não desaparecerá a menos que você o manipule intencionalmente.

Na Prática! Como Usar add e commit

Agora, vamos usar a pasta `my-first-repo` para verificar o comportamento de `git add` e `git commit` com operações de arquivo reais.

Preparação: Modificar Dois Arquivos ao Mesmo Tempo

Primeiro, edite e salve os arquivos `index.html` e `style.css`.

• `index.html`: Faça alguma alteração, como adicionar uma tag `

  `.

• `style.css`: Faça alguma alteração, como adicionar um estilo para o `body`.

Se você executar `git status` neste estado, ele informará que dois arquivos foram modificados.

git status

Caso 1: Commitar Apenas Um Arquivo

Este é um cenário em que você "quer commitar apenas as alterações do HTML primeiro". Use `git add` para especificar apenas o arquivo que você quer commitar.

git add index.html

Se você verificar o `git status` neste ponto, verá que apenas `index.html` foi para a área de preparação, enquanto `style.css` ainda permanece no diretório de trabalho.

[Imagem: Resultado do git status, mostrando index.html em verde e style.css em vermelho.]

Agora, execute o commit neste estado.

git commit -m "Atualizar a estrutura do HTML"

Com isso, apenas as alterações de `index.html` foram registradas. Se você executar `git status` novamente, verá que apenas as alterações de `style.css` permanecem.

Caso 2: Commitar Todas as Alterações de Uma Vez

A seguir, vamos tentar commitar as alterações restantes de `style.css` e as alterações de um novo arquivo `script.js` de uma só vez. Primeiro, crie o novo arquivo.

echo "console.log('Hello, Git!');" > script.js

Em seguida, use `git add .` para preparar todas as alterações no diretório atual (a modificação de `style.css` e a nova adição de `script.js`) de uma só vez.

git add .

Finalmente, commite todas essas alterações juntas.

git commit -m "Ajustar estilos do CSS e adicionar arquivo JS"

Com isso, todas as alterações foram registradas e o diretório de trabalho está limpo. Se você executar `git status`, deverá ver a mensagem "nothing to commit, working tree clean".