Introdução

No dia a dia você "salva" um documento, mas no Git a ação equivalente é chamada de commit. Um commit registra um snapshot permanente dos seus arquivos preparados e suas alterações no histórico do repositório. Ao contrário de pressionar Salvar em um editor, um commit não sobrescreve a versão anterior — ele adiciona uma nova entrada em uma linha do tempo que você pode revisitar, comparar ou reverter a qualquer momento.

Esta página é um mapa dos comandos que você usa para salvar alterações localmente e prepará-las para compartilhamento. Cada seção tem um link para um capítulo dedicado com opções completas e exemplos.

As três áreas pelas quais as alterações passam

Para entender como salvar no Git, é útil saber que um arquivo pode existir em três lugares ao mesmo tempo:

• Diretório de trabalho — os arquivos que você edita no disco.
• Área de preparação (também chamada de index) — uma zona de espera onde você monta exatamente o que o próximo commit conterá.
• Repositório — o histórico de commits, armazenado na pasta oculta .git.

Salvar alterações significa movê-las do diretório de trabalho, passando pela área de preparação, até o repositório:

edit files        # changes live in the working directory
git add <file>    # move them into the staging area
git commit        # record them permanently in the repository

O fluxo em duas etapas de add seguido de commit é intencional: ele permite que você faça commit de apenas parte do seu trabalho e deixe o restante para depois, produzindo commits focados e significativos.

git add

O comando git add move as alterações do diretório de trabalho para a área de preparação. Ele informa ao Git quais atualizações incluir no próximo commit. Sozinho, git add não registra nada permanente — você deve seguir com git commit.

git add index.html      # stage a single file
git add src/            # stage everything under a directory
git add .               # stage all changes in the current directory tree

Execute git status a qualquer momento para ver quais arquivos estão preparados, modificados ou não rastreados.

git commit

O comando git commit registra todas as alterações atualmente preparadas como um novo snapshot no repositório. Cada commit é um ponto permanente no histórico ao qual você pode retornar. Como apenas as alterações preparadas são capturadas, git add deve ser executado primeiro.

git commit -m "Add contact form validation"

Use uma mensagem curta e descritiva no modo imperativo ("Add", "Fix", "Update"). Se você omitir -m, o Git abrirá seu editor configurado para que você possa escrever uma mensagem mais longa.

git diff

O comando git diff compara diferentes estados do seu projeto para que você possa revisar exatamente o que está prestes a salvar. Por padrão, git diff mostra as alterações não preparadas — a diferença entre seu diretório de trabalho e a área de preparação. Adicione --staged para ver o que já está preparado e pronto para commit.

git diff             # working directory vs. staging area (not yet staged)
git diff --staged    # staging area vs. last commit (about to be committed)

Revisar um diff antes de fazer commit é a melhor forma de evitar salvar código de depuração ou edições acidentais.

git stash

O comando git stash guarda temporariamente as alterações não commitadas para que seu diretório de trabalho fique limpo — útil quando você precisa trocar de tarefa ou puxar atualizações sem fazer commit de um trabalho incompleto. As alterações são salvas em uma pilha que você pode reaplicar mais tarde.

git stash        # set aside current changes and revert to a clean tree
git stash pop    # re-apply the most recent stash and remove it from the stack

.gitignore

Alguns arquivos nunca devem ser commitados — saída de build, dependências, segredos ou metadados do sistema operacional. O Git lê um arquivo chamado .gitignore para decidir quais caminhos ignorar. Não existe um comando git ignore; você cria e commita esse arquivo por conta própria, listando padrões que o Git deve excluir do rastreamento:

# Dependencies
node_modules/
# OS files
.DS_Store
Thumbs.db
# Secrets
.env

Note que .gitignore afeta apenas arquivos que o Git ainda não está rastreando. Para parar de rastrear um arquivo que foi commitado antes de ser ignorado, use git rm --cached.

Fluxo de trabalho típico

Uma sequência padrão para salvar e compartilhar alterações é a seguinte:

git status                          # see what changed
git add .                           # stage the changes
git diff --staged                   # review what is about to be committed
git commit -m "Implement feature"   # save a permanent snapshot
git push origin main                # upload commits to the remote

As primeiras quatro etapas salvam seu trabalho localmente; git push é o que o compartilha com um servidor remoto como o GitHub.

Desfazendo antes de salvar

Se você preparar algo por engano, pode movê-lo de volta para fora da área de preparação sem perder suas edições:

git restore --staged <file>    # unstage, keep the changes in the working directory
git restore <file>             # discard working-directory changes (cannot be undone)

Para mais formas de desfazer alterações após um commit, consulte git reset.

Prática