Git: Primeiros passos

2025-04-10

/2025/04/10/git-primeiros-passos/ Mauro Abner

#git

Sumário

1. Os três estados
2. Comandos para inciar um projeto Git
3. Comandos git dentro de um projeto
4. Trabalhando com repositórios remotos
5. Informações Adicionais

1. Os três estados

No Git, um arquivo pode ser rotulado com três estados: modificado (modified), preparado (staged) e registrado (committed):

Modificado (modified) significa que você alterou o arquivo, mas ainda não o enviou para área de preparação (staging area)
Preparado (staged) significa que você marcou um arquivo modificado em sua versão atual para que este arquivo seja registrado (commit).
Registrado (committed) significa que as mudanças realizadas foram registradas com segurança no Diretório Git (Git directory) local.

Isso nos leva áreas principais do git:

Diretório de Trabalho (Working directory) - muitas vezes chamado de Árvore de Trabalho (Working Tree).
Área de Preparação (Staging Area) - muitas vezes chamada de Índice (Index)^[1]
Diretório Git (Git directory).

Se um arquivo no diretório de trabalho (Working directory) sofrer algum tipo de mudança (alguma implementação ou correção), esta versão é considerada modificada (modified).

Se o desenvolvedor/tech writer considerar que esta versão modificada (modified) do arquivo está pronta para ser registrada (committed), então tal versão será armazenada na área de preparação (staging area), e será considerada uma versão preparada (staged) para ser registrada (committed).

Por fim todos os arquivos preparada (staged) — armazenados na área de preparação (staging area) — podem ser registrados (commit), o que os adicionará ao Repositório Git (Git directory).

Deste modo o fluxo de trabalho básico do Git fica mais ou menos assim:

Modifica-se (modify) uma série de arquivos em seu diretório de trabalho (Working directory).
Prepara-se (stage) seletivamente apenas as alterações que farão parte do próximo registro (commit), o que adiciona essas alterações à área de preparação (staging area).
Faz-se o registro (commit) de todos os arquivos que estão na área de preparação (staging area), fazendo com que cada arquivo tenha instantâneos (snapshot)^[2] que serão registrados (committed) no diretório Git (Git directory).

Agora voltando ao momento que os arquivos que estão no diretório de trabalho (Working directory). Inicialmente esses arquivos são considerados: rastreado (tracked) ou não rastreado (untracked).

Arquivos rastreados (tracked) são arquivos que estavam no último instantâneo, bem como quaisquer arquivos recém-preparados (newly staged files). Ou seja, arquivos rastreados são arquivos que o Git já conhece e que podem ser ainda não modificados (unmodified), já modificados (modified) ou preparados (staged).

Já Arquivos não rastreados (untracked) são quaisquer arquivos em seu diretório de trabalho que não estavam em seu último instantâneo (snapshot), isto é, nunca foram registrados (committed) e não estão em sua área de preparação (staging area).

Por exemplo, quando você clona (clone) um repositório pela primeira vez, todos os seus arquivos serão rastreados (tracked) e ainda não modificados (unmodified) porque o Git acabou de verificá-los (checked out) e não encontrou nenhum edição feita por você.

Conforme você edita os arquivos, o Git os vê como modificados(modified), porque estão diferentes do último registro (commit).

À medida que você trabalha, você prepara (stage) seletivamente esses arquivos modificados (modified) e, em seguida, registra (commit) todas as alterações preparadas (staged), e o ciclo se repete.

2. Comandos para inciar um projeto Git

Após criar uma pasta para um projeto (diretório) devemos acessá-la pelo Git Bash.

Estou usando Windows neste tutorial

$ cd '/c/Users/usuario_generico/OneDrive - usuario_generico/Área de Trabalho/novo_projeto'

E uma vez que acessamos, devemos inicializar o git dentro deste diretório:

git init

Feito isto, é necessário configurar o nome do usuário e um email que será usado para assinar este projeto. Esta informação pode ser global ou local. Os comandos abaixo servem para configurar esta informação localmente.

git config user.name "fulano"

git config user.email "fulanos@provedordeemail.com"

Podemos listar todas as configurações do repositório local do git utilizando o seguinte comando, e verificar que as mudanças foram realizadas.

git config --list

Para sair da lista, pressione a tecla q.

3. Comandos git dentro de um projeto

Para vermos, entre outras informações, em qual galho (branch) estamos trabalhando, se algum arquivo está sendo rastreado (tracking) ou se já houveram registros (commits) de mudanças realizadas nos arquivo.
```
git status
```
ou
```
git status -s
```
Não deixe de olhar a documentação oficial sobre Opções do git status e Opções do git status - s
Para adicionar um arquivo que está no diretório de trabalho (Working directory) na área de preparação (staging area) utilize o seguinte comando:

Observe que se um arquivo não era rastreado (untracked), após isto passará a ser.
```
git add nome_do_arquivo_com_extensão
```
Para adicionar todos os arquivos do repositório, sem exceção, basta usar este comando:
```
git add .
```
ou
```
git add -A
```
Para remover um arquivo da área de preparação (staging area), mas mantê-lo no Diretório de Trabalho (Working directory) use:
```
git rm --cached nome_do_arquivo_com_extensão
```
e em seguida é necessário realizar um registro (commit) para registrar essa operação de remoção.
```
git commit -m "Removido arquivo teste.adoc"
```
Se a flag --cached não for passado, o arquivo será excluído tanto da área de preparação (staging area) quanto do Diretório de Trabalho (Working directory).
Se você mover um arquivo para a área de preparação (staging area), mas não o registrar (commit), e voltar a modificar este mesmo arquivo, no diretório de trabalho (Working directory), haverá um diferença de conteúdo entre a versão que está modificada (modified) e a versão preparado (staged). Para visualizar qual é a diferença, basta usar o comando abaixo:
```
git diff --staged
```
Se acaso você quiser ver a diferença entre a versão preparado (staged) e a última versão registrada (committed), basta usar o comando abaixo:
```
git diff
```
Após adicionar os arquivos na área de preparação (Staging Area), você deve registrá-los (committing) junto a uma mensagem que descreva resumidamente do que se trata este registro.
```
git commit -m "O arquivo documento.adoc foi revisado inteiramente"
```
Você já sabe que antes de registrar (commit) um arquivo, você precisa colocá-lo na área de preparação (staging area). Porém se o arquivo já foi posto anteriormente na área de preparação (staging area), este é um arquivo que já é rastreado (tracking) pelo Git, e portanto conhecido por ele. Desta forma é possível pular esta primeira etapa, utilizando o seguinte comando:
```
git commit -a -m "O arquivo documento.adoc foi revisado inteiramente"
```
Para ver o histórico de registros (commits), você deve usar o seguinte comando:
```
git log
```
Você pode acrescentar algumas flags para poder ver as diferenças em cada registro (commit) e pode restringir estes registros apenas paras as duas últimas entradas no registros (log entries).
```
git log -p -2
```
Também há esta outra forma de apresentar o histórico, na qual se mostra o número de cada registro (commit) — número este gerado por um SHA-1 — juntamente com o comentário feito no momento do registro (commit) e outras informações.
```
git log --pretty=format:"%h - %an, %ar : %s"
```
Há outras formar de ver o histórico de registros, como passando a flag --author "Nome do Autor" ou --graph. Lembre-se que para sair da lista, pressione a tecla q.

Se por acaso você quiser ver como um arquivo era em um determinado registro (commit), você pode usar a seguinte sequência de comandos:

NUNCA realize esse procedimento tendo arquivos que não ainda não foram registrados (commited). Se houver qualquer arquivo novo ou na Área de Preparação (staging area) ou no Diretório de Trabalho (Working directory), faça o registro (commit) destes arquivos, antes de usar este usar o comando abaixo.

git log --pretty=format:"%h - %an, %ar : %s"

Em seguida escolha o registro para o qual deseja-se voltar, e pegue os 06 primeiros dígitos do registro (commit), e passe-os como no exemplo abaixo (Lembrando que NNNNNN são os seis primeiros números do registro):

git checkout NNNNNN

Para retornar para o último registro (commit) que foi feito no projeto, basta usar o seguinte comando (Lembrando que alguns projetos podem estar usando main ao invés de master):

git checkout master

Pode-se renomear o galho principal de master para main usando o seguinte comando:

Verifique se realmente você está no galho (branch) master usando o comando git status e verifique se não há nenhum arquivo para registrar (commit) antes de fazer esta alteração.
```
git branch -m main
```

Para se criar um galho (branch) no qual se irá trabalhar em uma nova funcionalidade, você devê usar o seguinte comando:

Lembre-se de usar o git status para verifique se não há nenhum arquivo para registrar (commit) antes de fazer esta alteração.
```
git branch nome-do-novo-galho-sem-espacos-e-sem-caracteres-especiais
```
Para mudar para o novo galho (branch) criado, ou qualquer outro branch, inclusive o main ou master use o seguinte comando:
```
git checkout nome-do-novo-galho-sem-espacos-e-sem-caracteres-especiais
```
Se o comando git log for usado, veremos que o HEAD estará apontando para o novo galho (branch).

Você pode mudar de galho (branch) quantas vezes desejar, só lembre de sempre de verificar antes de mudar, se há arquivos para registrar (commit).
Para mesclar (merge) dois galhos (branches), precisamos primeiro verificar em qual galho (branch) estamos, e depois utilizar o comando mesclar (merge) apontado qual o nome do galho (branch) que desejamos mesclar ao galho que já estamos. Normalmente mesclamos (marge) um branch nome-do-galho com o branch main .
```
git marge nome-do-galho
```
Toda mescla (merge), vai gerar um novo registro (commit).

4. Trabalhando com repositórios remotos

Pode-se clonar (clone) - obter uma cópia completa - de um Repositório Remoto (Remote Repositories) ou simplesmente Remoto (Remote), e colocá-lo em seu Diretório Git (Git directory) afim de trabalhar localmente com este repositório. Para fazer isto, basta usar o seguinte comando:
```
git clone https://github.com/usuario_a/nome-do-repositorio.git
```
No exemplo acima, o repositório remoto está hospedado no servidor GitHub, porém poderia estar hospedado em qualquer servidor git.
Caso você deseje ver quais são os Repositório Remoto (Remote Repositories) associados ao seu repositório Git, é só utilizar o seguinte comando:
```
git remote -v
```
- O termo origin é um nome convencional que se refere ao repositório de onde você fez o clone inicial do seu projeto.
- O fetch (pegar, buscar) indica a URL usada quando você executa git fetch.
- O push (empurrar) indica a URL usada quando você executa git push.
Se você já realizou as alterações no projeto que você clonou, já as registrou (committed) e deseja empurrar (push) essas alterações para o Repositório Remoto (Remote Repositories), basta fazer uso do comando git push <remote> <branch>, veja abaixo:
```
git push origin main
```
No caso acima, estamos empurrando (pushing) as atualizações que registramos no galho (branch) principal (main) para o galho principal de Repositório Remoto (Remote Repositories), aqui conhecido como origin.

Se você estiver trabalhando em equipe, é sempre bom fazer um git pull.

Para puxar (pull) as alterações galho (branch) principal (main) do repositório remoto aqui conhecido como origin e mesclar (merge) automaticamente essas alterações no seu galho local, utilize o comando abaixo:

É importante observar que, ao usar o git pull, você está efetivamente trazendo as alterações do repositório remoto para o seu branch local. Certifique-se de estar ciente das implicações e de como isso afetará o histórico do seu projeto.

git pull origin main

5. Informações Adicionais

Veja Pro Git Book e Uma Referência Visual do Git.

FIM ■

1. A terminologia "índice" é uma metáfora que sugere que a área de preparação atua como um índice ou uma lista de alterações que serão incluídas no próximo registro (commit). A ideia é que você está "indexando" as mudanças antes de consolidá-las em um ponto específico na história do seu repositório através de um registro (commit). Os termos "área de preparação" e "índice" são usados de forma intercambiável, ou seja, são sinônimos dentro da documentação do git .

2. Para maiores informações sobre como o git realiza os instantâneos (snapshots) de um projeto, verifique a documentação em git-scm.com.