[Tutorial] Aprendendo sobre versionamento de código com Git
Published: 2022-02-20 14:29:10

O Git é uma ferramenta que não pode faltar no cinto de utilidades de um desenvolvedor, principalmente quando se produz código em grupo.

Segundo a própria Wikipédia: "Git  é um sistema de controle de versões distribuído", ou seja, é ele quem irá auxiliar no gerenciamento das diferentes versões que um projeto pode ter e facilitar o time a integrar seus códigos sem o perigo de um sobrescrever o trabalho do outro.

Então se você quer aprender a utilizar esta poderosa ferramenta, continue descendo e aproveite a leitura!

## Iniciando os conceitos básicos - `git init`

Vamos começar criando um novo diretório e iniciando o git no mesmo. Para iniciar o git no seu diretório, utilize o comando `git init`, como mostrado a seguir:

![Criação de diretório e inicialização do git](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hdkplatdw8e8p0adqgid.png)

Perfeito! Agora com o diretório criado e o git inicializado, vamos entender alguns conceitos. Para isso, considere a imagem a seguir:

![Dev Environment](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2gkz2r3ogxtsrw3vj5v7.png)

Essa é a representação do seu ambiente de desenvolvimento local. Nele você tem o seu diretório de trabalho (Working Directory), a Staging Area e o Local Repository. A Staging Area recebe este nome pois é justamente o local onde os arquivos irão ficar "se preparando" antes de irem para o Local Repository, que por sua vez, é o local de armazenamento onde o git gerencia as versões do seu código.

## Verificando status - `git status`

Agora vamos abrir um editor de código e criar um novo arquivo.

![Arquivo criado no VSCode](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2bkouwjxmgydf5rpft50.png)

Ótimo! Agora com nosso novo arquivo criado, vamos aprender nosso próximo comando git, o `git status`. Ele serve para nos dar um pequeno relatório sobre a situação dos arquivos no nosso diretório. Veja um exemplo:

![Git status](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fkxcsalk6zx6r8tudulm.png)

## Adicionando arquivos na Staging Area - `git add`

Como podemos ver na saída do comando anterior, temos um arquivo que não foi 'trackeado', ou seja, o git não está monitorando-o. Isso quer dizer que o git não irá guardar informações sobre as alterações desse arquivo. Para mudar isso, precisamos movê-lo para a Staging Area, onde ele ficará esperando para ser lançado numa versão do nosso projeto. Para fazer isso, utilizaremos o comando `git add`.

![Git add schema](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jyitmbfq31aq403q74tr.png) 

Podemos utilizar esse comando de duas formas: com o nome do(s) arquivo(s) específicos após o comando ou utilizando um '.' para sinalizar que queremos adicionar todos os arquivos com modificações. Veja a seguir:

![Git add example](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qoossgemtyqimqngweju.png)

![Codigo apos add](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/l7u73j0jxaopbhemoja3.png)
 
Como você pode ver, o VS Code também detectou as alterações que fizemos. Agora, invés do 'U' ao lado do nosso arquivo, agora temos um 'A', sinalizando que o arquivo foi movido para a Staging Area.
 
## Salvando nosso trabalho no Local Repository - `git commit`

O nosso arquivo na Staging Area está pronto para ser salvo no nosso Local Repository. Para isso, precisamos 'commitar' nosso código, isto é, salvar o estado dos arquivos da Staging Area no nosso Local Repository, gerando um commit que armazenará essas informações. Utilizaremos o comando `git commit`.

![Git commit schema](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tjy6gu8gn6ssl6v0vkri.png)

Se checarmos o status do git, veremos que a mensagem mudou:

![Git status após o add](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lvcokbo25r87hux0djiy.png)

Agora ele nos informa que temos arquivos a serem commitados e é exatamente o que faremos agora.

![Git commit command line](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y3ezffb2dqkkxxz9ued0.png)
 
Todo commit precisa de uma mensagem. Geralmente ela deve ser uma pequena descrição do trabalho que foi commitado. Existem diversos padrões de commit e podemos falar deles em outro momento.
 
Como podemos ver também, ele nos retorna algumas informações a respeito do commit criado.

Perfeito, agora nosso trabalho está salvo no nosso Local Repository.

## Removendo arquivos da Staging Area - `git restore`

Em algum momento, podemos querer remover alguma mudança que adicionamos na Staging Area. Para isso, podemos utilizar o comando `git restore`, que irá remover o arquivo da Staging Area. Para demonstrar isso, criaremos um novo arquivo.

![Novo arquivo criado](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/beyxk6y0apsw2xwgajo6.png)![Git status após novo arquivo criado](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zr81ccmexspf3yxw66sm.png)
 
Perfeito, agora temos um novo arquivo no nosso Working Directory. Vamos movê-lo para a Staging Area.

![Arquivo após ser movido para a Staging Area](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7el93d0oh5pphmlguet0.png)![Arquivo após ser movido para a Staging Area - VSCode](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v3kikojenqa6y86nz1tu.png)
 
 
Note que o próprio git nos auxilia ao informar como podemos retirar algum arquivo da Staging Area. Precisaremos do comando `git restore` juntamente com a flag `--staged`.

![Git restore command line](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bfjk98nfzobzy6yk4ufd.png)
 
Como podemos ver, após utilizar o comando, a mensagem exibida pelo `git status` é a mesma de quando criamos o arquivo, e caso verifiquemos o nosso arquivo no VS Code, ele continua o mesmo, a única diferença é que retornou ao status de untracked.

![Arquivo após ser removido da Staging Area](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gdllnx8ylc3ie6jmcgam.png)
  
## Lendo o histórico de commits - `git log`

Caso você queira verificar o histórico dos commits no seu projeto, você pode utilizar o comando `git log`. Ele exibirá uma lista com os commits, bem como algumas informações sobre cada um deles. Vamos lá testar:

![Git log command line](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2a9cbdqswqgpn6kam7x1.png)

Como você pode ver, temos informações como o nome do autor do commit, o hash (que é um código aleatório único para identificar aquele commit), a data de criação e sua mensagem.

No topo, podemos também ver a mensagem `HEAD`. Isso significa que esse commit foi o último a ser realizado, ou seja, está no topo (na cabeça) do histórico do nosso projeto.

## Revertendo o último commit - `git reset`

Vamos supor que você commitou algum arquivo que não estivesse completo ou com alguns bugs e agora precisa desfazer seu último commit. Nessa situação, você pode utilizar o comando `git reset`. Para demonstrar o uso, vamos novamente adicionar o nosso novo arquivo na Staging Area e então fazer o commit:

![Adicionando e commitando novo arquivo](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cswr9ujvry5klt54z3et.png)
 
Agora, se verificarmos o histórico, veremos que o novo commit está no topo:

![Git log atualizado](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m5cpcbi3bosjoluw8l6f.png)

Certo, agora é hora de desfazermos nosso último commit:

![Git reset command line](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/73c5ddaq9z4y9jiq3l0j.png)

Como podemos ver, o nosso arquivo voltou ao seu estado de untracked, o que significa que o nosso commit foi desfeito. Para ter certeza, vamos checar o log:

![Git log atualizado após desfazer último commit](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ezdkthwt3p75uf9imzd4.png)
 
Voalá! O nosso commit não está mais lá.
 
## Renomeando commits - flag `--amend`

Vamos supor que na hora de nomear o seu commit você acabou digitando algo errado da qual não percebeu, como você faria para renomear seu último commit?

Felizmente, o git nos oferece essa opção também e de maneira bem simples. Tudo o que você precisará fazer é novamente utilizar o 
`git commit`, mas dessa vez, com uma flag chamada `--amend`. Ela permitirá que você dê um novo nome para seu último commit. Vamos ver na prática.

![Git log](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bg47b9e87e4x6glpzqfy.png)
 
Como podemos ver, o nosso último commit ainda está como antes. Vamos renomeá-lo:

![Git commit --amend command line](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dte7qny4dfzxoq2xihb1.png)![Git log após commit renomeado](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9bqni1qiiahc0488yifc.png)

Como podemos ver pelo `git log`, a mensagem do último commit foi editada com sucesso!
 
## Removendo arquivos do git - `git rm`

Bom, mas e se quisermos remover de vez um arquivo do nosso sistema de versionamento? Simples: utilizamos o comano `git rm`.

Vamos remover o arquivo que commitamos:

![Git rm](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/c8ezvvfspd2lp0v5p0vf.png)
 
Como podemos ver, na mensagem retornada pelo `git status`, o arquivo foi deletado. Para confirmar a remoção precisamos fazer o commit, assim salvando um novo state onde o arquivo é removido do versionamento. Como eu não desejo executar a remoção, vou somente reverter o processo utilizando o comando `git restore --staged` e em seguida o `git restore` para reverter as alterações e voltar ao estado inicial.

## Salvando suas alterações sem commitar - `git stash`

O git nos oferece também a opção de salvarmos alterações no nosso código sem precisar fazer o commmit. O comando `git stash` nos permite salvar alterações de forma separada dos commits para utilizarmos em um momento futuro, caso desejemos.

Vamos começar modificando nosso arquivo já commitado:

![Arquivo modificado](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v359r11eaysr76wgy3ii.png)
 
Agora, com o arquivo alterado, vamos executar o stash:

![Git stash command line](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nifnknhdjpmek36e5zet.png)![VSCode após stash](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/xi3k5ch0q4ijulfqfwzz.png)
 
Como podemos ver, inicialmente temos o git status nos informando que o arquivo havia sido alterado, em seguida, executamos o comando `git stash push -m` que nos permite associar uma mensagem ao nosso stash, assim como fazemos com os commits. Por fim, executamos novamente o `git status` e vemos que o diretório está limpo como se nada tivesse acontecido.

Vamos agora conferir a lista de stash para ter certeza de que nosso stash foi salvo. Utilizaremos o comando `git stash list`:

![Git stash list command line](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/v4c3aofy04bit4de09aa.png)
   
E aí está, o nosso stash salvo com sucesso. Agora vamos aplicar as alterações que salvamos nesse stash no nosso código novamente.

![Git stash apply command line](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/d39rabp9ecj5nmjnd57r.png)![VSCode após git stash apply](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/z713el8qny1kcblkjpul.png)
  
Prontinho, as alterações que havíamos salvo estão de volta no nosso diretório.

O `git stash` oferece outras opções como

- `git stash`: para fazer o stash sem passar uma mensagem.
- `git stash show`: para listar os arquivos modificados que foram salvos no último stash.
- `git stash pop`: para remover em forma de pilha (do mais recente para o mais antigo).
- `git stash clear`: para remover todos os stashs.